2408 lines
80 KiB
C++
2408 lines
80 KiB
C++
///////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Microsoft WMIOLE DB Provider
|
|
// (C) Copyright 1999 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// WmiOleDBMap.cpp: implementation of the CWmiOleDBMap class.
|
|
//
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
#include "headers.h"
|
|
#include "dataconvert.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction of class for Schema Rowsets
|
|
//////////////////////////////////////////////////////////////////////
|
|
CWmiOleDBMap::CWmiOleDBMap()
|
|
{
|
|
m_pWbemClassParms = NULL;
|
|
m_pWbemClassDefinition = NULL;
|
|
m_paWbemClassInstances = NULL;
|
|
m_pWbemCommandManager = NULL;
|
|
m_pWbemCollectionManager = NULL;
|
|
m_pWbemCurInst = NULL;
|
|
|
|
m_cRef = 0;
|
|
m_bMethodRowset = FALSE;
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWmiOleDBMap::~CWmiOleDBMap()
|
|
{
|
|
SAFE_DELETE_PTR(m_pWbemClassParms);
|
|
SAFE_DELETE_PTR(m_pWbemClassDefinition);
|
|
SAFE_DELETE_PTR(m_paWbemClassInstances);
|
|
SAFE_DELETE_PTR(m_pWbemCommandManager);
|
|
SAFE_DELETE_PTR(m_pWbemCollectionManager);
|
|
}
|
|
|
|
|
|
STDMETHODIMP_( ULONG ) CWmiOleDBMap::AddRef( void )
|
|
{
|
|
return InterlockedIncrement((long*)&m_cRef);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Decrements a persistence count for the object and if persistence count is 0, the object
|
|
// destroys itself.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_( ULONG ) CWmiOleDBMap::Release( void )
|
|
{
|
|
if (!InterlockedDecrement((long*)&m_cRef)){
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_cRef;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Initialization function for Schema Rowsets
|
|
//////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::FInit(int nSchemaType, DWORD dwFlags, WCHAR * pClassName, WCHAR * pSpecificTable, CWbemConnectionWrapper * Connect)
|
|
{
|
|
// NTRaid:111784 - 111787
|
|
// 06/07/00
|
|
HRESULT hr = S_OK;
|
|
m_pWbemClassParms = new CWbemClassParameters(dwFlags,pClassName,Connect);
|
|
if(m_pWbemClassParms)
|
|
{
|
|
m_pWbemClassParms->SetClassName(pClassName);
|
|
|
|
switch( nSchemaType )
|
|
{
|
|
case SOURCES_ROWSET:
|
|
m_pWbemClassDefinition = (CWbemSchemaClassDefinitionWrapper*)new CWbemSchemaSourcesClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = (CWbemSchemaInstanceList*)new CWbemSchemaSourcesInstanceList(m_pWbemClassParms);
|
|
break;
|
|
|
|
case PROVIDER_TYPES_ROWSET:
|
|
m_pWbemClassDefinition = (CWbemSchemaClassDefinitionWrapper*)new CWbemSchemaProviderTypesClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = (CWbemSchemaInstanceList*)new CWbemSchemaProviderTypesInstanceList(m_pWbemClassParms);
|
|
break;
|
|
|
|
case CATALOGS_ROWSET:
|
|
m_pWbemClassDefinition = (CWbemSchemaClassDefinitionWrapper*)new CWbemSchemaCatalogsClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = (CWbemSchemaInstanceList*)new CWbemSchemaCatalogsInstanceList(m_pWbemClassParms);
|
|
break;
|
|
|
|
case COLUMNS_ROWSET:
|
|
m_pWbemClassDefinition = (CWbemSchemaClassDefinitionWrapper*)new CWbemSchemaColumnsClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = (CWbemSchemaInstanceList*)new CWbemSchemaColumnsInstanceList(m_pWbemClassParms,pSpecificTable);
|
|
break;
|
|
|
|
case TABLES_ROWSET:
|
|
m_pWbemClassDefinition = (CWbemSchemaClassDefinitionWrapper*)new CWbemSchemaTablesClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = (CWbemSchemaInstanceList*)new CWbemSchemaTablesInstanceList(m_pWbemClassParms,pSpecificTable);
|
|
break;
|
|
|
|
case PRIMARY_KEYS_ROWSET:
|
|
m_pWbemClassDefinition = (CWbemSchemaClassDefinitionWrapper*)new CWbemSchemaPrimaryKeysClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = (CWbemSchemaInstanceList*)new CWbemSchemaPrimaryKeysInstanceList(m_pWbemClassParms,pSpecificTable);
|
|
break;
|
|
|
|
case TABLES_INFO_ROWSET:
|
|
m_pWbemClassDefinition = (CWbemSchemaClassDefinitionWrapper*)new CWbemSchemaTablesInfoClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = (CWbemSchemaInstanceList*)new CWbemSchemaTablesInfoInstanceList(m_pWbemClassParms,pSpecificTable);
|
|
break;
|
|
|
|
case PROCEDURES_ROWSET:
|
|
m_pWbemClassDefinition = (CWbemSchemaClassDefinitionWrapper*)new CWbemSchemaProceduresClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = (CWbemSchemaInstanceList*)new CWbemSchemaProceduresInstanceList(m_pWbemClassParms,pSpecificTable);
|
|
break;
|
|
|
|
case PROCEDURE_PARAMETERS_ROWSET:
|
|
m_pWbemClassDefinition = (CWbemSchemaClassDefinitionWrapper*)new CWbemSchemaProceduresParametersClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = (CWbemSchemaInstanceList*)new CWbemSchemaProceduresParametersInstanceList(m_pWbemClassParms,pSpecificTable);
|
|
break;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if(!m_pWbemClassDefinition || !m_pWbemClassDefinition)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Initialization function for opening a class
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::FInit(DWORD dwFlags, WCHAR * pClassName, CWbemConnectionWrapper * Connect)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
m_pWbemClassParms = new CWbemClassParameters(dwFlags,pClassName,Connect);
|
|
// NTRaid:111784 - 111787
|
|
// 06/07/00
|
|
if(m_pWbemClassParms)
|
|
{
|
|
m_pWbemClassParms->SetClassName(pClassName);
|
|
m_pWbemCurInst = NULL;
|
|
m_cRef = 0;
|
|
m_pWbemCommandManager = NULL;
|
|
m_bMethodRowset = FALSE;
|
|
m_pWbemCollectionManager = NULL;
|
|
|
|
m_pWbemClassDefinition = new CWbemClassDefinitionWrapper(m_pWbemClassParms);
|
|
m_paWbemClassInstances = new CWbemInstanceList(m_pWbemClassParms);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if(!m_pWbemClassDefinition || !m_paWbemClassInstances)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
return hr;
|
|
|
|
}
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Initialization function for Commands or methods
|
|
// NTRaid:111788,111890 - 111792
|
|
// 06/07/00
|
|
//////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::FInit(DWORD dwFlags, CQuery * p, CWbemConnectionWrapper * Connect)
|
|
{
|
|
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
//=========================================================
|
|
// If it is a COMMAND_ROWSET or METHOD_ROWSET
|
|
//=========================================================
|
|
switch( p->GetType() ){
|
|
|
|
case COMMAND_ROWSET:
|
|
|
|
m_pWbemCommandManager = new CWbemCommandManager(p);
|
|
|
|
if(m_pWbemCommandManager)
|
|
{
|
|
m_pWbemClassParms = new CWbemCommandParameters(dwFlags,Connect,m_pWbemCommandManager);
|
|
if(m_pWbemClassParms)
|
|
{
|
|
// m_pWbemClassParms->SetEnumeratorFlags(WBEM_FLAG_FORWARD_ONLY);
|
|
m_pWbemClassParms->SetQueryFlags(WBEM_FLAG_DEEP);
|
|
m_paWbemClassInstances = new CWbemCommandInstanceList(m_pWbemClassParms,m_pWbemCommandManager);
|
|
m_pWbemClassDefinition = new CWbemCommandClassDefinitionWrapper(m_pWbemClassParms,m_pWbemCommandManager);
|
|
|
|
if(m_paWbemClassInstances && m_pWbemClassDefinition)
|
|
{
|
|
m_pWbemCommandManager->Init((CWbemCommandInstanceList*)m_paWbemClassInstances,
|
|
(CWbemCommandParameters*)m_pWbemClassParms,
|
|
(CWbemCommandClassDefinitionWrapper*)m_pWbemClassDefinition);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case METHOD_ROWSET:
|
|
m_pWbemClassParms = new CWbemMethodParameters(p,dwFlags,Connect);
|
|
if(m_pWbemClassParms)
|
|
{
|
|
m_pWbemClassParms->SetEnumeratorFlags(WBEM_FLAG_FORWARD_ONLY);
|
|
m_pWbemClassParms->SetQueryFlags(WBEM_FLAG_SHALLOW);
|
|
m_pWbemClassDefinition = new CWbemMethodClassDefinitionWrapper((CWbemMethodParameters*)m_pWbemClassParms);
|
|
if(m_pWbemClassDefinition)
|
|
{
|
|
m_paWbemClassInstances = new CWbemMethodInstanceList((CWbemMethodParameters*)m_pWbemClassParms,
|
|
(CWbemMethodClassDefinitionWrapper *) m_pWbemClassDefinition );
|
|
|
|
if(m_paWbemClassInstances)
|
|
{
|
|
hr = ((CWbemMethodClassDefinitionWrapper*)m_pWbemClassDefinition)->Init();
|
|
m_bMethodRowset = TRUE;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Initialization function for representing objects in Scope/Container
|
|
// if the namespace of the object is different from the current object then , a new Connect will be instantiated
|
|
// whic aggregates the existing connection pointer and store IwbemServices pointer opened on the given path and
|
|
// sets bConnectChanged to TRUE
|
|
// NTRaid:111793
|
|
// 06/07/00
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::FInit(DWORD dwFlags, WCHAR * pObjectPath, CWbemConnectionWrapper * Connect,INSTANCELISTTYPE instListType)
|
|
{
|
|
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
|
|
|
|
m_pWbemClassParms = new CWbemCollectionParameters(dwFlags,Connect,pObjectPath);
|
|
|
|
if(m_pWbemClassParms)
|
|
{
|
|
if(SUCCEEDED(hr = ((CWbemCollectionParameters *)m_pWbemClassParms)->Init(pObjectPath,Connect)))
|
|
{
|
|
m_pWbemCollectionManager = new CWbemCollectionManager;
|
|
if(m_pWbemCollectionManager)
|
|
{
|
|
m_pWbemClassDefinition = new CWbemCollectionClassDefinitionWrapper(m_pWbemClassParms,pObjectPath,instListType);
|
|
m_paWbemClassInstances = new CWbemCollectionInstanceList(m_pWbemClassParms,m_pWbemCollectionManager);
|
|
|
|
if(m_pWbemClassDefinition && m_paWbemClassInstances)
|
|
{
|
|
if(SUCCEEDED(hr = ((CWbemCollectionClassDefinitionWrapper *)m_pWbemClassDefinition)->Initialize(pObjectPath)))
|
|
{
|
|
m_pWbemCollectionManager->Init((CWbemCollectionInstanceList *)m_paWbemClassInstances,
|
|
(CWbemCollectionParameters *)m_pWbemClassParms,
|
|
(CWbemCollectionClassDefinitionWrapper*) m_pWbemClassDefinition);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CWmiOleDBMap::SetSearchPreferences(ULONG cProps , DBPROP rgProp[])
|
|
{
|
|
return m_pWbemClassParms->SetSearchPreferences(cProps,rgProp);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Find the type of column given the column
|
|
// ie. find if a property is PROPERTY or PROPERTY_QUALIFIER or CLASS_QUALLIFIER
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int CWmiOleDBMap::ParseQualifiedNameToGetColumnType(WCHAR * wcsName )
|
|
{
|
|
int nRc = WMI_PROPERTY;
|
|
WCHAR * p = NULL;
|
|
|
|
//========================================================================
|
|
// If there is not a separator in the name, then we know it is simply
|
|
// a WMI property.
|
|
// If there is a separator and the parsed value is equal to the name of
|
|
// the class, then we know we are dealing with a class qualifier,
|
|
// otherwise, it is a property qualifier.
|
|
//========================================================================
|
|
p = wcsstr(wcsName, SEPARATOR);
|
|
if( p ){
|
|
nRc = WMI_PROPERTY_QUALIFIER;
|
|
//====================================================================
|
|
p = NULL;
|
|
p= wcsstr(wcsName,m_pWbemClassParms->GetClassName());
|
|
if( p != NULL && p == wcsName)
|
|
{
|
|
nRc = WMI_CLASS_QUALIFIER;
|
|
}
|
|
}
|
|
|
|
return nRc;
|
|
}
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL CWmiOleDBMap::ParseQualifiedName(WCHAR * Root, WCHAR *& Parent, WCHAR *& Child)
|
|
{
|
|
BOOL fRc = FALSE;
|
|
//========================================================================
|
|
// If there is not a separator in the name, then we know it is simply
|
|
// a WMI property.
|
|
// If there is a separator and the parsed value is equal to the name of
|
|
// the class, then we know we are dealing with a class qualifier,
|
|
// otherwise, it is a property qualifier.
|
|
//========================================================================
|
|
WCHAR *szTemp = NULL;
|
|
try
|
|
{
|
|
szTemp = new WCHAR[wcslen(Root) +1];
|
|
}
|
|
catch(...)
|
|
{
|
|
SAFE_DELETE_ARRAY(szTemp);
|
|
}
|
|
wcscpy(szTemp,Root);
|
|
WCHAR * p = wcstok(szTemp, SEPARATOR);
|
|
if( p ){
|
|
AllocateAndCopy(Parent,p);
|
|
p = wcstok( NULL, SEPARATOR );
|
|
if( p ){
|
|
if( AllocateAndCopy(Child,p)){
|
|
fRc = TRUE;
|
|
}
|
|
else{
|
|
SAFE_DELETE_PTR(Parent);
|
|
}
|
|
}
|
|
}
|
|
SAFE_DELETE_ARRAY(szTemp);
|
|
return fRc;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Check if the property is a vallid
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::ValidProperty(const DBCOLUMNDESC * prgColDesc)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
|
|
if( !(prgColDesc->dbcid.eKind == DBKIND_NAME && prgColDesc->dbcid.uName.pwszName != NULL))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Map the DBPROP to the appropriate qualifier
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::MapDBPROPToStdPropertyQualifier( DBPROP pProp, CVARIANT & Qualifier, CVARIANT & Value, LONG & lFlavor )
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
//========================================================================
|
|
// we do not need to handle qualifier flavors for these standard qualifers
|
|
// because, if a user is going to add a qualifier flavor on a qualifier
|
|
// that just 'happens' to match to a DBPROP, they will be adding it as
|
|
// a wmi qualifier, this function is to just catch the DBPROPS that are
|
|
// matched without the consumers knowledge, so in this case there will
|
|
// be no qualifier flavor
|
|
//========================================================================
|
|
switch(pProp.dwPropertyID){
|
|
|
|
//=================================================================
|
|
// WMI "Not_Null" standard qualifier only take true value.
|
|
//=================================================================
|
|
case DBPROP_COL_NULLABLE:
|
|
|
|
if ( VT_BOOL == V_VT(&pProp.vValue) ) {
|
|
if ( VARIANT_TRUE == V_BOOL(&pProp.vValue) ){
|
|
Qualifier.SetStr(L"Not_Null");
|
|
Value.SetBool(TRUE);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
//=================================================================
|
|
// WMI "Key" standard qualifier
|
|
//=================================================================
|
|
case DBPROP_COL_UNIQUE:
|
|
case DBPROP_COL_PRIMARYKEY:
|
|
if ( VT_BOOL == V_VT(&pProp.vValue) ) {
|
|
Qualifier.SetStr(L"Key");
|
|
Value.SetBool(TRUE);
|
|
hr = S_OK;
|
|
}
|
|
break;
|
|
//=================================================================
|
|
// WMI Flavor
|
|
//=================================================================
|
|
case DBPROP_WMIOLEDB_QUALIFIERFLAVOR:
|
|
if ( VT_I4 == V_VT(&pProp.vValue) ) {
|
|
lFlavor = V_I4(&pProp.vValue) ;
|
|
hr = S_OK;
|
|
}
|
|
break;
|
|
|
|
|
|
default:
|
|
hr = WBEM_E_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::MapDBPROPToStdClassQualifier( DBPROP pProp, CVARIANT & Qualifier, CVARIANT & Value, LONG & uFlavor )
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
//========================================================================
|
|
// Now, the qualifier flavor will be passed through here, so, we need
|
|
// to pick it up as we are doing the double checking. Regarding other
|
|
// maps, see comments in MapDBPROPTStdPropertyQualifier as to why we
|
|
// don't care about flavors on DBPROP matches to standard qualifiers.
|
|
//========================================================================
|
|
|
|
switch(pProp.dwPropertyID){
|
|
|
|
//=================================================================
|
|
// WMI Flavor
|
|
// DON'T set the return code to S_OK, because we want to save the
|
|
// flavor for later....
|
|
//=================================================================
|
|
case DBPROP_WMIOLEDB_QUALIFIERFLAVOR:
|
|
if ( VT_I4 == V_VT(&pProp.vValue) ) {
|
|
uFlavor = V_I4(&pProp.vValue) ;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
hr = WBEM_E_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// save the property
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::SetWMIProperty(const DBCOLUMNDESC * prgColDesc)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CBSTR bstrProperty(prgColDesc->dbcid.uName.pwszName);
|
|
VARIANT varDefault , *pDefaultValue = NULL;
|
|
VariantInit(&varDefault);
|
|
CDataMap map;
|
|
LONG lType = 0;
|
|
|
|
//==================================================================================
|
|
// Ok, we already know we have a valid class here so just check if we have a valid
|
|
// property
|
|
//==================================================================================
|
|
if( S_OK == (hr = ValidProperty(prgColDesc))){
|
|
|
|
// Get the default value for the property if any specified
|
|
GetDefaultValue(prgColDesc , varDefault);
|
|
|
|
map.MapOLEDBTypeToCIMType(prgColDesc->wType,lType);
|
|
|
|
if(V_VT(&varDefault) == VT_EMPTY || V_VT(&varDefault) == VT_NULL)
|
|
{
|
|
pDefaultValue = NULL;
|
|
}
|
|
else
|
|
{
|
|
pDefaultValue = &varDefault;
|
|
}
|
|
//==============================================================================
|
|
// Now, set it property and its value
|
|
//==============================================================================
|
|
hr = m_pWbemClassDefinition->SetProperty((BSTR)bstrProperty,pDefaultValue,lType);
|
|
if ( SUCCEEDED(hr) ){
|
|
|
|
//==========================================================================
|
|
// Now, go through the DBPROPSETS and the DBPROPS in them to see if they
|
|
// happen to match some of the standard qualifiers we have mapped to them
|
|
//==========================================================================
|
|
|
|
for( ULONG i = 0; i < prgColDesc->cPropertySets; i++ ){
|
|
|
|
for ( ULONG j = 0; j < prgColDesc->rgPropertySets[i].cProperties; j++ ) {
|
|
|
|
if(prgColDesc->rgPropertySets[i].rgProperties[j].dwPropertyID != DBPROP_COL_DEFAULT &&
|
|
prgColDesc->rgPropertySets[i].rgProperties[j].dwPropertyID != DBPROP_COL_NULLABLE )
|
|
{
|
|
CVARIANT Value,Qualifier;
|
|
LONG lFlavor;
|
|
|
|
//==================================================================
|
|
// See if we have a match, if we do, save it to WMI
|
|
//==================================================================
|
|
hr = MapDBPROPToStdPropertyQualifier(prgColDesc->rgPropertySets[i].rgProperties[j],Qualifier,Value, lFlavor);
|
|
if( hr == S_OK){
|
|
|
|
hr = m_pWbemClassDefinition->SetPropertyQualifier((BSTR)bstrProperty,Qualifier,Value,0);
|
|
if( hr != S_OK){
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function set value for a qualifier
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::SetWMIClassQualifier(const DBCOLUMNDESC * prgColDesc,BOOL bDefault)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WCHAR * pwcsQualifierName = NULL;
|
|
WCHAR * pwcsClass = NULL;
|
|
VARIANT varDefaultValue;
|
|
VariantInit(&varDefaultValue);
|
|
//==================================================================================
|
|
// Ok, we already know we have a valid class here so just check if we have a valid
|
|
// property
|
|
//==================================================================================
|
|
if( S_OK == (hr = ValidProperty(prgColDesc))){
|
|
|
|
if( ParseQualifiedName(prgColDesc->dbcid.uName.pwszName,pwcsClass,pwcsQualifierName) ){
|
|
|
|
//==========================================================================
|
|
// Now, go through the DBPROPSETS and the DBPROPS in them to see if they
|
|
// have a flavor for this qualifier or happen to map to other class
|
|
// qualifiers
|
|
//==========================================================================
|
|
LONG lQualifierFlavor = 0L;
|
|
for( ULONG i = 0; i < prgColDesc->cPropertySets; i++ ){
|
|
|
|
for ( ULONG j = 0; j < prgColDesc->rgPropertySets[i].cProperties; j++ ) {
|
|
|
|
CVARIANT Value,Qualifier;
|
|
//==================================================================
|
|
// Get the qualifier flavor property if any
|
|
//==================================================================
|
|
if( prgColDesc->rgPropertySets[i].rgProperties[j].dwPropertyID == DBPROP_WMIOLEDB_QUALIFIERFLAVOR &&
|
|
V_VT(&prgColDesc->rgPropertySets[i].rgProperties[j].vValue) == VT_I4)
|
|
{
|
|
lQualifierFlavor = V_I4(&prgColDesc->rgPropertySets[i].rgProperties[j].vValue);
|
|
}
|
|
|
|
}
|
|
}
|
|
if( hr == S_OK )
|
|
{
|
|
CBSTR strQualifier(pwcsQualifierName);
|
|
// If a new qualifer is to be added the get the default value
|
|
if(bDefault == TRUE)
|
|
{
|
|
GetDefaultValue(prgColDesc,varDefaultValue);
|
|
}
|
|
else
|
|
{
|
|
hr = m_pWbemClassDefinition->GetClassQualifier((BSTR)strQualifier, &varDefaultValue, NULL,NULL);
|
|
}
|
|
|
|
hr = m_pWbemClassDefinition->SetClassQualifier(pwcsQualifierName, &varDefaultValue, lQualifierFlavor);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
SAFE_DELETE_PTR(pwcsQualifierName);
|
|
SAFE_DELETE_PTR(pwcsClass);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function set value for a particular property
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::SetWMIPropertyQualifier(const DBCOLUMNDESC * prgColDesc,BOOL bDefault)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WCHAR * pwcsQualifierName = NULL;
|
|
WCHAR * pwcsProperty = NULL;
|
|
VARIANT varDefaultValue;
|
|
VariantInit(&varDefaultValue);
|
|
|
|
//==================================================================================
|
|
// Ok, we already know we have a valid class here so just check if we have a valid
|
|
// property
|
|
//==================================================================================
|
|
if( S_OK == (hr = ValidProperty(prgColDesc))){
|
|
|
|
|
|
|
|
if( ParseQualifiedName(prgColDesc->dbcid.uName.pwszName,pwcsProperty,pwcsQualifierName) ){
|
|
LONG lQualifierFlavor = 0L;
|
|
|
|
|
|
//==========================================================================
|
|
// Now, go through the DBPROPSETS and the DBPROPS in them to see if they
|
|
// have a flavor for this qualifier or happen to map to other class
|
|
// qualifiers
|
|
//==========================================================================
|
|
for( ULONG i = 0; i < prgColDesc->cPropertySets; i++ ){
|
|
|
|
for ( ULONG j = 0; j < prgColDesc->rgPropertySets[i].cProperties; j++ ) {
|
|
|
|
CVARIANT Value,Qualifier;
|
|
//==================================================================
|
|
// Get the qualifier flavor property if any
|
|
//==================================================================
|
|
if( prgColDesc->rgPropertySets[i].rgProperties[j].dwPropertyID == DBPROP_WMIOLEDB_QUALIFIERFLAVOR &&
|
|
V_VT(&prgColDesc->rgPropertySets[i].rgProperties[j].vValue) == VT_I4)
|
|
{
|
|
lQualifierFlavor = V_I4(&prgColDesc->rgPropertySets[i].rgProperties[j].vValue);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
if( hr == S_OK ){
|
|
CBSTR strQualifier(pwcsQualifierName),strProperty(pwcsProperty);
|
|
|
|
if(bDefault == TRUE)
|
|
{
|
|
GetDefaultValue(prgColDesc,varDefaultValue);
|
|
}
|
|
else
|
|
{
|
|
GetPropertyQualifier((BSTR)strProperty,(BSTR)strQualifier,varDefaultValue);
|
|
}
|
|
|
|
hr = m_pWbemClassDefinition->SetPropertyQualifier(pwcsProperty,pwcsQualifierName, &varDefaultValue, lQualifierFlavor);
|
|
}
|
|
}
|
|
}
|
|
|
|
SAFE_DELETE_PTR(pwcsQualifierName);
|
|
SAFE_DELETE_PTR(pwcsProperty);
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to initialize the DBCOLUMNINFO structure
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::SetCommonDBCOLUMNINFO(DBCOLUMNINFO ** pCol, DBORDINAL uCurrentIndex)
|
|
{
|
|
(*pCol)->columnid.eKind = DBKIND_GUID_PROPID;
|
|
(*pCol)->columnid.uGuid.guid = GUID_NULL;
|
|
(*pCol)->columnid.uName.ulPropid = (ULONG)uCurrentIndex;
|
|
(*pCol)->iOrdinal = uCurrentIndex;
|
|
(*pCol)->pTypeInfo = NULL;
|
|
(*pCol)->bPrecision = (BYTE) ~0;
|
|
(*pCol)->bScale = (BYTE) ~0;
|
|
(*pCol)->dwFlags = 0;
|
|
//==================================================================
|
|
// We do support nulls
|
|
//==================================================================
|
|
(*pCol)->dwFlags |= DBCOLUMNFLAGS_ISNULLABLE;
|
|
(*pCol)->dwFlags |= DBCOLUMNFLAGS_MAYBENULL;
|
|
|
|
//==================================================================
|
|
//We should always be able to write to the column
|
|
//==================================================================
|
|
(*pCol)->dwFlags |= DBCOLUMNFLAGS_WRITE;
|
|
return S_OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function which gets column info for qualifier
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetQualifiedNameColumnInfo( cRowColumnInfoMemMgr * pParentCol,DBCOLUMNINFO ** pCol, WCHAR * pName)
|
|
{
|
|
|
|
HRESULT hr = E_UNEXPECTED;
|
|
WCHAR * pColumnName = new WCHAR[ wcslen(pName) + wcslen(QUALIFIER_) + wcslen(SEPARATOR) +2];
|
|
|
|
if( pColumnName ){
|
|
swprintf(pColumnName,L"%s%s%s",pName,SEPARATOR,QUALIFIER_);
|
|
|
|
// if the column is already present in the col info info return
|
|
// This will happen when for row objects obtained from rowsets
|
|
if(((DB_LORDINAL)pParentCol->GetColOrdinal(pColumnName)) >=0)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = pParentCol->AddColumnNameToList(pColumnName, pCol);
|
|
if( hr == S_OK ){
|
|
|
|
//==================================================================
|
|
// We use ordinal numbers for our columns
|
|
//==================================================================
|
|
SetCommonDBCOLUMNINFO(pCol, pParentCol->GetCurrentIndex());
|
|
(*pCol)->wType = DBTYPE_HCHAPTER ;
|
|
(*pCol)->ulColumnSize = sizeof(HCHAPTER);
|
|
(*pCol)->dwFlags = DBCOLUMNFLAGS_ISCHAPTER | DBCOLUMNFLAGS_ISFIXEDLENGTH ;
|
|
|
|
// NTRaid:111762
|
|
// 06/13/00
|
|
hr = pParentCol->CommitColumnInfo();
|
|
}
|
|
}
|
|
}
|
|
SAFE_DELETE_PTR(pColumnName);
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get column info for a property of a class
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetPropertyColumnInfo( cRowColumnInfoMemMgr * pColumn, DBCOLUMNINFO ** pCol,CBSTR & pProperty,LONG &lFlavor)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
VARIANT vValue;
|
|
CIMTYPE propertyType;
|
|
CBSTR strWrite(L"write");
|
|
DBORDINAL lOrdinal = -1;
|
|
VariantInit(&vValue);
|
|
BSTR bstrPath ;
|
|
BSTR bstrProperty;
|
|
|
|
if((BSTR)pProperty == NULL)
|
|
{
|
|
//===========================================================================
|
|
// Get the next property
|
|
//===========================================================================
|
|
hr = m_pWbemClassDefinition->GetNextProperty((unsigned short **)&pProperty,(VARIANT *)&vValue, &propertyType,&lFlavor);
|
|
}
|
|
else
|
|
{
|
|
hr = m_pWbemClassDefinition->GetProperty(pProperty,(VARIANT *)&vValue, &propertyType, &lFlavor);
|
|
}
|
|
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
bstrProperty = Wmioledb_SysAllocString((WCHAR *)(BSTR)pProperty);
|
|
bstrPath = Wmioledb_SysAllocString(L"__PATH");
|
|
// Ignore the __PATH column if the rowset type to be dealt is a rowset for executing
|
|
// a method. This is because , __PATH property exists in __PARAMETERS object but the
|
|
// object obtained for output parameters does not contain this property
|
|
if(wbem_wcsicmp(bstrProperty , bstrPath) == 0 && m_bMethodRowset == TRUE &&
|
|
((CWbemMethodParameters *)m_pWbemClassParms)->m_pQuery != NULL &&
|
|
((CWbemMethodParameters *)m_pWbemClassParms)->m_pQuery->GetType() == METHOD_ROWSET )
|
|
{
|
|
pProperty.Clear();
|
|
VariantClear(&vValue);
|
|
hr = m_pWbemClassDefinition->GetNextProperty((unsigned short **)&pProperty,(VARIANT *)&vValue, &propertyType,&lFlavor);
|
|
}
|
|
|
|
SysFreeString(bstrPath);
|
|
SysFreeString(bstrProperty);
|
|
|
|
lOrdinal = pColumn->GetColOrdinal((WCHAR *)(BSTR)pProperty);
|
|
|
|
// if the column is already present in the col info info return
|
|
// This will happen when for row objects obtained from rowsets
|
|
if((DB_LORDINAL)lOrdinal < 0)
|
|
{
|
|
|
|
hr = pColumn->AddColumnNameToList(pProperty, pCol);
|
|
if( hr == S_OK )
|
|
{
|
|
|
|
//==================================================================
|
|
// We use ordinal numbers for our columns
|
|
//==================================================================
|
|
SetCommonDBCOLUMNINFO(pCol, pColumn->GetCurrentIndex());
|
|
|
|
// if the property is system property then it cannot be updated
|
|
if(lFlavor == WBEM_FLAVOR_ORIGIN_SYSTEM ||
|
|
m_pWbemClassDefinition->IsClassSchema())
|
|
{
|
|
SetColumnReadOnly(*pCol,TRUE);
|
|
}
|
|
else
|
|
{
|
|
hr = GetPropertyQualifier(pProperty,(BSTR)strWrite,vValue);
|
|
|
|
//if((hr == S_OK) && (VARIANT_TRUE == V_BOOL(&vValue)))
|
|
{
|
|
SetColumnReadOnly(*pCol,FALSE);
|
|
}
|
|
//else
|
|
{
|
|
// SetColumnReadOnly(*pCol,TRUE);
|
|
}
|
|
}
|
|
|
|
pColumn->SetCIMType(propertyType);
|
|
if((propertyType == CIM_OBJECT) || (propertyType == CIM_OBJECTARRAY))
|
|
{
|
|
if( propertyType == CIM_OBJECTARRAY)
|
|
{
|
|
propertyType = VT_ARRAY | VT_BSTR;
|
|
}
|
|
else
|
|
{
|
|
propertyType = CIM_STRING;
|
|
}
|
|
SetColumnTypeURL(*pCol);
|
|
}
|
|
|
|
hr = S_OK;
|
|
CDataMap DataMap;
|
|
DataMap.MapCIMTypeToOLEDBType(propertyType,(*pCol)->wType,(*pCol)->ulColumnSize,(*pCol)->dwFlags);
|
|
|
|
// NTRaid:111762
|
|
// 06/13/00
|
|
hr = pColumn->CommitColumnInfo();
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//**********************************************************************************************************************
|
|
//
|
|
// PUBLIC FUNCTIONS
|
|
//
|
|
//**********************************************************************************************************************
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to initialize the DBCOLUMNDESC structure for various types of column
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::SetColumns( const DBORDINAL cColumnDescs, const DBCOLUMNDESC rgColumnDescs[])
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if( S_OK == (hr = m_pWbemClassDefinition->ValidClass())){
|
|
|
|
for( DBORDINAL i = 0; i < cColumnDescs && SUCCEEDED(hr); i++ ) { //for each column
|
|
|
|
// switch(ParseQualifiedNameToGetColumnType(rgColumnDescs[i]->pwszTypeName)){
|
|
switch(ParseQualifiedNameToGetColumnType(rgColumnDescs[i].dbcid.uName.pwszName)){
|
|
|
|
case WMI_CLASS_QUALIFIER:
|
|
hr = SetWMIClassQualifier(&rgColumnDescs[i]);
|
|
break;
|
|
|
|
case WMI_PROPERTY_QUALIFIER:
|
|
hr = SetWMIPropertyQualifier(&rgColumnDescs[i]);
|
|
break;
|
|
|
|
case WMI_PROPERTY:
|
|
hr = SetWMIProperty(&rgColumnDescs[i]);
|
|
break;
|
|
|
|
default:
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to create a new table ( which maps to a new class)
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::CreateTable( DBORDINAL cColumnDescs, const DBCOLUMNDESC rgColumnDescs[],
|
|
ULONG cPropertySets, DBPROPSET rgPropertySets[])
|
|
{
|
|
HRESULT hr ;
|
|
BSTR strSuperClass = Wmioledb_SysAllocString(NULL);
|
|
|
|
// If the class already exists then return error
|
|
if( S_OK == (hr = m_pWbemClassDefinition->ValidClass()))
|
|
{
|
|
hr = DB_E_DUPLICATETABLEID;
|
|
}
|
|
else
|
|
{
|
|
|
|
hr = m_pWbemClassDefinition->CreateClass();
|
|
if( S_OK == hr ){
|
|
hr = SetColumns(cColumnDescs, rgColumnDescs);
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
hr = m_pWbemClassDefinition->SaveClass();
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Funtion to add a table ( which maps to a class)
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::DropTable()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if( S_OK == (hr = m_pWbemClassDefinition->ValidClass())){
|
|
hr = m_pWbemClassDefinition->DeleteClass();
|
|
if( hr == S_OK)
|
|
{
|
|
hr = m_pWbemClassDefinition->SaveClass(FALSE);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Funtion to add a column( which maps to property/qualifier)
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::AddColumn(const DBCOLUMNDESC* prgColDesc, DBID** pColumnID) //Add a column to current ClassObject definition or instance
|
|
{
|
|
HRESULT hr ;
|
|
|
|
if( S_OK == (hr = m_pWbemClassDefinition->ValidClass())){
|
|
hr = SetColumns(1, prgColDesc);
|
|
if( hr == S_OK)
|
|
{
|
|
hr = m_pWbemClassDefinition->SaveClass(FALSE);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Funtion to drop a column( which maps to property/qualifier)
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::DropColumn(const DBID* pColumnID) //Drop a column from current ClassObject definition or instance
|
|
{
|
|
HRESULT hr ;
|
|
WCHAR * pwcsClass = NULL;
|
|
WCHAR * pwcsQualifier = NULL;
|
|
WCHAR * pwcsProperty = NULL;
|
|
CBSTR strColumnName(pColumnID->uName.pwszName);
|
|
|
|
if( S_OK == (hr = m_pWbemClassDefinition->ValidClass())){
|
|
|
|
switch(ParseQualifiedNameToGetColumnType((WCHAR*)pColumnID->uName.pwszName)){
|
|
|
|
case WMI_CLASS_QUALIFIER:
|
|
if( ParseQualifiedName((WCHAR*)pColumnID->uName.pwszName,pwcsClass,pwcsQualifier) ){
|
|
hr = m_pWbemClassDefinition->DeleteClassQualifier(pwcsQualifier);
|
|
}
|
|
break;
|
|
|
|
case WMI_PROPERTY_QUALIFIER:
|
|
if( ParseQualifiedName((WCHAR*)pColumnID->uName.pwszName,pwcsProperty,pwcsQualifier) ){
|
|
hr = m_pWbemClassDefinition->DeletePropertyQualifier(pwcsProperty,pwcsQualifier);
|
|
}
|
|
break;
|
|
|
|
case WMI_PROPERTY:
|
|
hr = m_pWbemClassDefinition->DeleteProperty((BSTR)strColumnName);
|
|
break;
|
|
|
|
default:
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If everthing is fine then save the changes to WMI
|
|
if( hr == S_OK)
|
|
{
|
|
hr = m_pWbemClassDefinition->SaveClass(FALSE);
|
|
}
|
|
|
|
SAFE_DELETE_PTR(pwcsClass);
|
|
SAFE_DELETE_PTR(pwcsQualifier);
|
|
SAFE_DELETE_PTR(pwcsProperty);
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get the count of the number of columns
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetColumnCount( DBCOUNTITEM & cTotalColumns,DBCOUNTITEM & cParentColumns,DBCOUNTITEM &cNestedCols)
|
|
{
|
|
HRESULT hr;
|
|
|
|
cTotalColumns = 0L;
|
|
cParentColumns = 0L;
|
|
cNestedCols = 0L;
|
|
|
|
if( S_OK == (hr = m_pWbemClassDefinition->ValidClass())){
|
|
|
|
int nCnt = 1;
|
|
|
|
//========================================================================
|
|
// If we are dealing with class qualifiers, then add one column which
|
|
// will contain the rowset of class qualifiers.
|
|
//========================================================================
|
|
if( m_pWbemClassDefinition->GetFlags() & CLASS_QUALIFIERS ){
|
|
cTotalColumns++;
|
|
cNestedCols++;
|
|
}
|
|
//========================================================================
|
|
// if we are dealing with property qualifiers, then we will need to add
|
|
// on a property qualifier for each property column
|
|
//========================================================================
|
|
if( m_pWbemClassDefinition->GetFlags() & PROPERTY_QUALIFIERS ){
|
|
nCnt = 2;
|
|
}
|
|
//========================================================================
|
|
// Now, get the number of properties for this class
|
|
//========================================================================
|
|
ULONG ulProperties = 0, ulSysPropCount = 0;
|
|
hr= m_pWbemClassDefinition->TotalPropertiesInClass(ulProperties,ulSysPropCount);
|
|
// NTRaid : 142133 & 141923
|
|
// 07/12/00
|
|
if(hr == S_FALSE)
|
|
{
|
|
cTotalColumns = 0;
|
|
cParentColumns = 0;
|
|
cNestedCols = 0;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
|
|
// Ignore the __PATH column if the rowset type to be dealt is a rowset for executing
|
|
// a method. This is because , __PATH property exists in __PARAMETERS object but the
|
|
// object obtained for output parameters does not contain this property
|
|
// So if the rowset to be constructed is to represent output parameters of a method
|
|
// execution , decrement the number of system properties
|
|
if(m_bMethodRowset == TRUE && ((CWbemMethodParameters *)m_pWbemClassParms)->m_pQuery != NULL &&
|
|
((CWbemMethodParameters *)m_pWbemClassParms)->m_pQuery->GetType() == METHOD_ROWSET && ulSysPropCount> 0)
|
|
{
|
|
ulSysPropCount--;
|
|
}
|
|
|
|
if( hr == S_OK ){
|
|
|
|
cParentColumns = cTotalColumns + ulSysPropCount + ulProperties;
|
|
cTotalColumns += ulSysPropCount + ulProperties * nCnt;
|
|
|
|
cTotalColumns++; // Adding for the first bookmark column
|
|
|
|
// If property is included in the rowset
|
|
if( nCnt>1){
|
|
cNestedCols += ulProperties;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Gets column information for the class
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetColumnInfoForParentColumns(cRowColumnInfoMemMgr * pParentCol)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LONG lFlavour = 0;
|
|
INSTANCELISTTYPE objListType = NORMAL;
|
|
|
|
if( S_OK == (hr = m_pWbemClassDefinition->ValidClass())){
|
|
|
|
if(m_pWbemCommandManager)
|
|
{
|
|
objListType = m_pWbemCommandManager->GetObjListType();
|
|
}
|
|
else
|
|
if(m_pWbemCollectionManager)
|
|
{
|
|
objListType = m_pWbemCollectionManager->GetObjListType();
|
|
}
|
|
switch(objListType)
|
|
{
|
|
case NORMAL:
|
|
{
|
|
|
|
if( S_OK == (hr = m_pWbemClassDefinition->BeginPropertyEnumeration()))
|
|
{
|
|
|
|
pParentCol->ResetColumns();
|
|
//====================================================================
|
|
// get the column info for class qualifiers
|
|
//====================================================================
|
|
if( m_pWbemClassDefinition->GetFlags() & CLASS_QUALIFIERS ){
|
|
hr = GetQualifiedNameColumnInfo(pParentCol,pParentCol->CurrentColInfo(),m_pWbemClassParms->GetClassName());
|
|
}
|
|
if( hr == S_OK ){
|
|
|
|
CBSTR pProperty;
|
|
//=================================================================
|
|
// Go through all of the columns we have allocated
|
|
//=================================================================
|
|
while(TRUE){
|
|
|
|
// CBSTR pProperty;
|
|
hr = GetPropertyColumnInfo(pParentCol,pParentCol->CurrentColInfo(),pProperty,lFlavour);
|
|
if( hr!= S_OK ){
|
|
break;
|
|
}
|
|
|
|
//=============================================================
|
|
// if we are supposed to support property qualifiers
|
|
//=============================================================
|
|
if( m_pWbemClassDefinition->GetFlags() & PROPERTY_QUALIFIERS && (lFlavour != WBEM_FLAVOR_ORIGIN_SYSTEM )){
|
|
hr = GetQualifiedNameColumnInfo(pParentCol,pParentCol->CurrentColInfo(),pProperty);
|
|
}
|
|
pProperty.Clear();
|
|
pProperty.Unbind();
|
|
}
|
|
|
|
if( hr == WBEM_S_NO_MORE_DATA ){
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
m_pWbemClassDefinition->EndPropertyEnumeration();
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case MIXED:
|
|
case SCOPE:
|
|
case CONTAINER:
|
|
{
|
|
if( m_pWbemClassDefinition->GetFlags() & CLASS_QUALIFIERS ){
|
|
hr = GetQualifiedNameColumnInfo(pParentCol,pParentCol->CurrentColInfo(),m_pWbemClassParms->GetClassName());
|
|
}
|
|
/* CBSTR pProperty(L"__PATH");
|
|
hr = GetPropertyColumnInfo(pParentCol,pParentCol->CurrentColInfo(),pProperty,lFlavour);
|
|
*/ hr = GetPropertyColumnInfoForMixedRowsets(pParentCol,pParentCol->CurrentColInfo());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::ResetInstances()
|
|
{
|
|
return m_paWbemClassInstances->Reset();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::ResetInstancesToNewPosition(DBROWOFFSET lRowOffset) // Start getting at new position
|
|
{
|
|
return m_paWbemClassInstances->ResetRelPosition(lRowOffset);
|
|
// return m_paWbemClassInstances->ResetInstancesToNewPosition(lRowOffset);
|
|
return S_OK;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::ResetPropQualiferToNewPosition(CWbemClassWrapper *pInst,DBROWOFFSET lRowOffset,BSTR strPropertyName)
|
|
{
|
|
return pInst->SetQualifierRelPos(lRowOffset,strPropertyName);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::ResetClassQualiferToNewPosition(CWbemClassWrapper *pInst,DBROWOFFSET lRowOffset)
|
|
{
|
|
return pInst->SetQualifierRelPos(lRowOffset);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Method to get the properties values and put it into the local buffer
|
|
// In the code the code if(WBEM_FLAG_DEEP != lFlags) check if
|
|
// all instances of child class is obtained or not. This will enable us to check if enumerator is to be
|
|
// used or not. If this is true , then the col info need not be in the same order as that of the
|
|
// enumerator, So properties has to be obtained in the order of the column information
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetProperties(CRowDataMemMgr * pRow,CWbemClassWrapper * pClass,cRowColumnInfoMemMgr *pColInfoMgr)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LONG lFlags = 0;
|
|
|
|
// Get the flags of the class
|
|
lFlags = pClass->GetQueryFlags();
|
|
|
|
// Property Enumerator is not used if Deep flag is set or
|
|
// if the query executed results in heterogenous object , in which case
|
|
// only __PATH is fetched
|
|
|
|
|
|
CVARIANT vValue ,vChapter;
|
|
LONG lFlavor = 0;
|
|
CBSTR pProperty;
|
|
BSTR bstProperty = NULL;
|
|
BYTE * pData = NULL;
|
|
CIMTYPE lType = 0;
|
|
CDataMap map;
|
|
DBORDINAL lIndex = 1;
|
|
DBCOUNTITEM cCols = 0;
|
|
|
|
// IF class Qualifiers are requested updated the qualifier
|
|
if(pClass->GetFlags() & CLASS_QUALIFIERS) {
|
|
|
|
vChapter.SetLONG(/*m_pWbemClassDefinition->GetNewHChapter()*/ 0);
|
|
|
|
|
|
if( S_OK != (hr = pRow->CommitColumnToRowData(vChapter,VT_UI4))){
|
|
}
|
|
lIndex++;
|
|
}
|
|
|
|
cCols = pColInfoMgr->GetTotalNumberOfColumns();
|
|
bstProperty = Wmioledb_SysAllocString(pColInfoMgr->ColumnName(lIndex));
|
|
|
|
while (lIndex < (ULONG_PTR)cCols)
|
|
{
|
|
// Get the specified property
|
|
if(pColInfoMgr->ColumnType(lIndex) != DBTYPE_HCHAPTER)
|
|
{
|
|
if (SysReAllocString(&bstProperty, pColInfoMgr->ColumnName(lIndex)))
|
|
{
|
|
hr = pClass->GetProperty(bstProperty,(VARIANT *)&vValue, &lType, &lFlavor);
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( FAILED(hr) ){
|
|
break;
|
|
}
|
|
|
|
if(( lType != vValue.GetType() && VT_NULL != vValue.GetType() && VT_EMPTY != vValue.GetType()) &&
|
|
lType != (CIM_FLAG_ARRAY | CIM_DATETIME ))
|
|
{
|
|
map.ConvertVariantType((VARIANT &)vValue ,(VARIANT &)vValue,lType);
|
|
}
|
|
else
|
|
if((vValue.GetType() == VT_UNKNOWN) || (vValue.GetType() == CIM_OBJECTARRAY) || (vValue.GetType() == CIM_OBJECT) )
|
|
{
|
|
GetEmbededObjects((CWbemClassInstanceWrapper *)pClass,bstProperty ,vValue);
|
|
}
|
|
//=======================================================================
|
|
// Set the data into the row
|
|
//=======================================================================
|
|
if( S_OK != (hr = pRow->CommitColumnToRowData(vValue,(DBTYPE)lType))){
|
|
break;
|
|
}
|
|
lIndex++;
|
|
|
|
//======================================================================================
|
|
// This is where we Get Property Qualifiers if the property is not a system property
|
|
//=======================================================================================
|
|
if( pClass->GetFlags() & PROPERTY_QUALIFIERS && lFlavor != WBEM_FLAVOR_ORIGIN_SYSTEM) {
|
|
|
|
vChapter.SetLONG(/*m_pWbemClassDefinition->GetNewHChapter()*/ 0);
|
|
|
|
if( S_OK != (hr = pRow->CommitColumnToRowData(vChapter,VT_UI4))){
|
|
break;
|
|
}
|
|
lIndex++;
|
|
}
|
|
|
|
vValue.Clear();
|
|
}
|
|
SysFreeString(bstProperty);
|
|
|
|
hr = hr == WBEM_S_NO_MORE_DATA ? S_OK : hr;
|
|
return hr;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get the next instance
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetNextInstance(CWbemClassWrapper *&pInst,CBSTR &strKey , BOOL bFetchBack)
|
|
{
|
|
HRESULT hr = WBEM_S_NO_MORE_DATA;
|
|
CWbemClassInstanceWrapper *pInstTemp = NULL;
|
|
|
|
|
|
if( bFetchBack == FALSE)
|
|
{
|
|
hr = m_paWbemClassInstances->NextInstance(strKey, &pInstTemp);
|
|
}
|
|
else
|
|
{
|
|
hr = m_paWbemClassInstances->PrevInstance(strKey, pInstTemp);
|
|
}
|
|
|
|
if(hr == S_OK)
|
|
{
|
|
pInst = (CWbemClassWrapper *)pInstTemp;
|
|
}
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//==========================================================================================================================
|
|
// Functin to get data for a particular instance
|
|
//==========================================================================================================================
|
|
HRESULT CWmiOleDBMap::GetDataForInstance(CRowDataMemMgr * pRow,CWbemClassWrapper *pInst,cRowColumnInfoMemMgr *pColInfoMgr)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if( pInst != NULL ){
|
|
|
|
//========================================================
|
|
// Now, get the properties
|
|
//========================================================
|
|
hr = GetProperties(pRow,(CWbemClassWrapper*)pInst,pColInfoMgr);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//==========================================================================================================================
|
|
// Functin to get data for a particular Schema instance
|
|
//==========================================================================================================================
|
|
HRESULT CWmiOleDBMap::GetDataForSchemaInstance(CRowDataMemMgr * pRow,CWbemClassWrapper *pPtr,cRowColumnInfoMemMgr *pColInfoMgr)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
CWbemSchemaClassInstanceWrapper * pClass = (CWbemSchemaClassInstanceWrapper * ) pPtr;
|
|
|
|
if( pClass != NULL ){
|
|
|
|
CVARIANT vValue;
|
|
LONG lFlavor;
|
|
CBSTR pProperty;
|
|
BYTE * pData = NULL;
|
|
CIMTYPE lType = 0;
|
|
CDataMap map;
|
|
DBORDINAL lIndex = 1;
|
|
DBLENGTH cCols = 0;
|
|
|
|
hr = S_OK;
|
|
cCols = pColInfoMgr->GetTotalNumberOfColumns();
|
|
|
|
while ( ( S_OK == hr) && (lIndex < cCols)){
|
|
|
|
hr = pClass->GetSchemaProperty((WCHAR *)pColInfoMgr->ColumnName(lIndex),(VARIANT*)vValue, &lType, &lFlavor);
|
|
if( hr == WBEM_S_NO_MORE_DATA ){
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
if( lType != vValue.GetType() && VT_NULL != vValue.GetType() && VT_EMPTY != vValue.GetType()){
|
|
map.ConvertVariantType((VARIANT &)vValue ,(VARIANT &)vValue,lType);
|
|
}
|
|
|
|
//=======================================================================
|
|
// Set the data into the row
|
|
//=======================================================================
|
|
if( S_OK != (hr = pRow->CommitColumnToRowData(vValue,(DBTYPE)lType))){
|
|
break;
|
|
}
|
|
lIndex++;
|
|
|
|
VariantClear(&vValue);
|
|
|
|
}
|
|
}
|
|
|
|
if( hr == WBEM_S_NO_MORE_DATA)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//==========================================================================================================================
|
|
// Function to get next property qualifer
|
|
//==========================================================================================================================
|
|
HRESULT CWmiOleDBMap::GetNextPropertyQualifier(CWbemClassWrapper *pInst,BSTR strPropName,BSTR &strQualifier,BOOL bFetchBack)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
CVARIANT vValue;
|
|
LONG lType = 0;
|
|
LONG lFlavor = 0;
|
|
CVARIANT var;
|
|
|
|
|
|
if( S_OK == (hr = pInst->ValidClass()))
|
|
{
|
|
if(bFetchBack == FALSE)
|
|
{
|
|
hr = pInst->GetNextPropertyQualifier(strPropName,&strQualifier,(VARIANT *)&vValue, &lType,&lFlavor);
|
|
}
|
|
else
|
|
{
|
|
hr = pInst->GetPrevPropertyQualifier(strPropName,&strQualifier,(VARIANT *)&vValue, &lType,&lFlavor);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
//==========================================================================================================================
|
|
// Function to get data for property qualifer
|
|
//==========================================================================================================================
|
|
HRESULT CWmiOleDBMap::GetDataForPropertyQualifier(CRowDataMemMgr * pRow,CWbemClassWrapper *pInst,BSTR strPropName, BSTR strQualifier, cRowColumnInfoMemMgr *pColInfoMgr)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
CVARIANT vValue;
|
|
LONG lType = 0;
|
|
LONG lFlavor = 0;
|
|
CVARIANT var;
|
|
|
|
|
|
if(SUCCEEDED(hr = pInst->ValidClass()))
|
|
{
|
|
|
|
hr = pInst->GetPropertyQualifier(strPropName,strQualifier,(VARIANT *)&vValue, &lType,&lFlavor);
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
hr = CommitRowDataForQualifier(pRow,strQualifier,vValue,lType,lFlavor);
|
|
}
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//==========================================================================================================================
|
|
// Function to get next class qualifer
|
|
//==========================================================================================================================
|
|
HRESULT CWmiOleDBMap::GetNextClassQualifier(CWbemClassWrapper *pInst,BSTR &strQualifier,BOOL bFetchBack)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
CVARIANT vValue;
|
|
LONG lType = 0;
|
|
LONG lFlavor = 0;
|
|
CVARIANT var;
|
|
|
|
|
|
if( SUCCEEDED (hr = pInst->ValidClass()))
|
|
{
|
|
if( bFetchBack == FALSE)
|
|
{
|
|
hr = pInst->GetNextClassQualifier(&strQualifier,(VARIANT *)&vValue, &lType,&lFlavor);
|
|
}
|
|
else
|
|
{
|
|
hr = pInst->GetPrevClassQualifier(&strQualifier,(VARIANT *)&vValue, &lType,&lFlavor);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
//==========================================================================================================================
|
|
// Function to get data for class qualifer
|
|
//==========================================================================================================================
|
|
HRESULT CWmiOleDBMap::GetDataForClassQualifier(CRowDataMemMgr * pRow,CWbemClassWrapper *pInst, BSTR strQualifier, cRowColumnInfoMemMgr *pColInfoMgr)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
CVARIANT vValue;
|
|
LONG lType = 0;
|
|
LONG lFlavor = 0;
|
|
CVARIANT var;
|
|
|
|
|
|
if(SUCCEEDED(hr = pInst->ValidClass()))
|
|
{
|
|
|
|
hr = pInst->GetClassQualifier(strQualifier,(VARIANT *)&vValue, &lType,&lFlavor);
|
|
if( hr == S_OK )
|
|
{
|
|
hr = CommitRowDataForQualifier(pRow,strQualifier,vValue,lType,lFlavor);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL CWmiOleDBMap::IsPropQualiferIncluded()
|
|
{
|
|
BOOL bRet = FALSE;
|
|
|
|
if( m_pWbemClassDefinition->GetFlags() & PROPERTY_QUALIFIERS )
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get the column info for the Property Qualifiers
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetNextPropertyQualifier( CWbemClassWrapper *pInst,BSTR &strPropName,CVARIANT &vValue,LONG &lType)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
/*
|
|
LONG lFlavor;
|
|
|
|
//===========================================================================
|
|
// Get the next property qualifier
|
|
//===========================================================================
|
|
hr = pInst->GetNextPropertyQualifier((unsigned short **)&strPropName,(VARIANT *)&vValue, &lType,&lFlavor);
|
|
|
|
return hr;
|
|
}
|
|
*/
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get the property qualifer
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetPropertyQualifier(BSTR strPropName, BSTR strQualifierName ,VARIANT &vValue)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
LONG lFlavor;
|
|
CIMTYPE QualifierDataType;
|
|
|
|
if( SUCCEEDED(hr = m_pWbemClassDefinition->ValidClass())){
|
|
|
|
if(SUCCEEDED (hr = m_pWbemClassDefinition->BeginPropertyQualifierEnumeration(strPropName)))
|
|
{
|
|
// call this function to get a specific property
|
|
hr = m_pWbemClassDefinition->GetPropertyQualifier(strQualifierName,(VARIANT *)&vValue, &QualifierDataType,&lFlavor);
|
|
m_pWbemClassDefinition->EndPropertyQualifierEnumeration();
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// set a particular column's as readonly property
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWmiOleDBMap::SetColumnReadOnly(DBCOLUMNINFO * pCol, BOOL bReadOnly)
|
|
{
|
|
if(bReadOnly == FALSE)
|
|
{
|
|
pCol->dwFlags |= DBCOLUMNFLAGS_WRITE;
|
|
}
|
|
else
|
|
{
|
|
pCol->dwFlags &= ~(DBCOLUMNFLAGS_WRITE);
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Delete a particular instance
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::DeleteInstance(CWbemClassWrapper * pClass )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CWbemClassInstanceWrapper *pTemp = (CWbemClassInstanceWrapper *) pClass;
|
|
hr = m_paWbemClassInstances->DeleteInstance(pTemp);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// update a instance
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::UpdateInstance(CWbemClassWrapper *pInst,BOOL bNewInst)
|
|
{
|
|
CWbemClassInstanceWrapper *pTemp = (CWbemClassInstanceWrapper *) pInst;
|
|
return m_paWbemClassInstances->UpdateInstance(pTemp,bNewInst);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Add new instance
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::AddNewInstance(CWbemClassWrapper ** ppClass )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
// NTRaid:111794
|
|
// 06/07/00
|
|
CWbemClassInstanceWrapper *pNewInst = NULL ;
|
|
hr = m_paWbemClassInstances->AddNewInstance((CWbemClassWrapper *)m_pWbemClassDefinition ,&pNewInst);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
*ppClass = pNewInst;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Set navigation flags for enumerator
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWmiOleDBMap::SetNavigationFlags(DWORD dwFlags)
|
|
{
|
|
m_pWbemClassParms->SetEnumeratorFlags(dwFlags);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Set navigation flags for enumerator
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWmiOleDBMap::SetQueryFlags(DWORD dwFlags)
|
|
{
|
|
m_pWbemClassParms->SetQueryFlags(dwFlags);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Refresh a particular instance
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::RefreshInstance(CWbemClassWrapper * pInstance )
|
|
{
|
|
return ((CWbemClassInstanceWrapper *)pInstance)->RefreshInstance();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get a particular property of the instance
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetProperty(CWbemClassWrapper *pInst,BSTR pProperty, BYTE *& pData,DBTYPE &dwType ,DBLENGTH & dwSize, DWORD &dwFlags )
|
|
{
|
|
CVARIANT varValue;
|
|
CIMTYPE cType = 0;
|
|
LONG lFlavor = 0;
|
|
CDataMap map;
|
|
HRESULT hr = 0;
|
|
DBTYPE dbType = 0;
|
|
|
|
|
|
hr = pInst->GetProperty(pProperty, &varValue, (LONG *)&cType ,&lFlavor );
|
|
if( hr == S_OK)
|
|
{
|
|
dbType = (DBTYPE)varValue.GetType();
|
|
// NTRaid 135384
|
|
if(cType == CIM_DATETIME || cType == CIM_IUNKNOWN)
|
|
{
|
|
dbType = (DBTYPE)cType;
|
|
}
|
|
else
|
|
// If the property is an embeded instance
|
|
if( dbType == VT_UNKNOWN || dbType == CIM_OBJECTARRAY || dbType == CIM_OBJECT)
|
|
{
|
|
hr = GetEmbededObjects((CWbemClassInstanceWrapper *)pInst,pProperty,varValue);
|
|
dbType = varValue.GetType();
|
|
}
|
|
|
|
// return value of this function will be the status
|
|
if(SUCCEEDED(hr = map.AllocateAndMapCIMTypeToOLEDBType(varValue,pData,dbType,dwSize, dwFlags)))
|
|
{
|
|
dwType = dbType;
|
|
if((cType == (CIM_DATETIME | CIM_FLAG_ARRAY)) || (cType == (DBTYPE_DBTIMESTAMP | CIM_FLAG_ARRAY)) )
|
|
{
|
|
dwType = (DBTYPE)cType;
|
|
}
|
|
else
|
|
if(cType == CIM_IUNKNOWN)
|
|
{
|
|
dwType = DBTYPE_IUNKNOWN;
|
|
}
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get the instance pointerd by the path
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassWrapper * CWmiOleDBMap::GetInstance(BSTR strPath)
|
|
{
|
|
CWbemClassWrapper *pInst = NULL;
|
|
pInst = m_pWbemClassDefinition->GetInstance(strPath);
|
|
|
|
// Add the instance to the list so that this get released when class is destructed
|
|
if(pInst != NULL)
|
|
{
|
|
m_paWbemClassInstances->AddInstance((CWbemClassInstanceWrapper *)pInst);
|
|
}
|
|
|
|
return pInst;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get Embeded objects and generate URLS for every embeded instance and put it into SAFEARRATS of URLS
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::GetEmbededObjects(CWbemClassInstanceWrapper * pClass,BSTR strProperty,CVARIANT &vValue)
|
|
{
|
|
CVARIANT vTemp;
|
|
HRESULT hr = S_OK;
|
|
CWbemClassInstanceWrapper * pNewInst = NULL;
|
|
IWbemClassObject * pClassObject = NULL;
|
|
CBSTR strKey;
|
|
SAFEARRAY * pArray;
|
|
SAFEARRAY * pArrayOut;
|
|
LONG rgIndices[1];
|
|
IUnknown * pUnk = NULL;
|
|
void * p = NULL;
|
|
SAFEARRAYBOUND rgsabound[1];
|
|
LONG lBound = 0 , uBound = 0;
|
|
|
|
VariantCopy(&vTemp, vValue);
|
|
vValue.Clear();
|
|
|
|
try
|
|
{
|
|
pNewInst = new CWbemClassInstanceWrapper(m_pWbemClassParms);
|
|
}
|
|
catch(...)
|
|
{
|
|
SAFE_DELETE_PTR(pNewInst);
|
|
throw;
|
|
}
|
|
if(pNewInst == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
if(vTemp.GetType() & VT_ARRAY)
|
|
{
|
|
pArray = (SAFEARRAY *)vTemp;
|
|
|
|
hr = SafeArrayGetLBound(pArray,1,&lBound);
|
|
hr = SafeArrayGetUBound(pArray,1,&uBound);
|
|
|
|
rgsabound[0].lLbound = lBound;
|
|
rgsabound[0].cElements = uBound - lBound + 1; // This is because the bounds includes both the bounds
|
|
pArrayOut = SafeArrayCreate(VT_BSTR, 1, rgsabound);
|
|
|
|
for( int nIndex = lBound ; nIndex <= uBound ; nIndex++)
|
|
{
|
|
strKey.Clear();
|
|
rgIndices[0] = nIndex;
|
|
hr = SafeArrayGetElement(pArray,&rgIndices[0],(void *)&pUnk);
|
|
|
|
hr = pUnk->QueryInterface(IID_IWbemClassObject , (void **)&pClassObject);
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
pNewInst->SetClass(pClassObject);
|
|
hr = pNewInst->GetKey(strKey);
|
|
|
|
pUnk->Release();
|
|
pClassObject->Release();
|
|
|
|
GenerateURL(pClass,strProperty,nIndex, strKey);
|
|
|
|
hr = SafeArrayPutElement(pArrayOut,&rgIndices[0],(void *)strKey);
|
|
}
|
|
}
|
|
// If the elements in the array is not equal to zero
|
|
if(SUCCEEDED(hr) && (uBound - lBound + 1 != 0))
|
|
{
|
|
vValue.SetArray(pArrayOut,VT_ARRAY|VT_BSTR);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = vTemp.GetUnknown()->QueryInterface(IID_IWbemClassObject , (void **)&pClassObject);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
pNewInst->SetClass(pClassObject);
|
|
hr = pNewInst->GetKey(strKey);
|
|
pClassObject->Release();
|
|
GenerateURL(pClass,strProperty,-1, strKey);
|
|
vValue.SetStr(strKey);
|
|
}
|
|
}
|
|
SAFE_DELETE_PTR(pNewInst);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Generate URL for an instance , Used for embeded instance
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWmiOleDBMap::GenerateURL(CWbemClassInstanceWrapper * pClass,BSTR strProperty,ULONG nIndex,CBSTR &strIn)
|
|
{
|
|
// NTRaid: 136446
|
|
// 07/05/00
|
|
CURLParser urlParser;
|
|
BSTR bstrURL = NULL;
|
|
|
|
if((strIn == NULL) || (SysStringLen(strIn) == 0))
|
|
{
|
|
pClass->GetKey(strIn);
|
|
}
|
|
|
|
urlParser.SetPath(strIn);
|
|
urlParser.SetEmbededInstInfo(strProperty,nIndex);
|
|
urlParser.GetURL(bstrURL);
|
|
|
|
strIn.Clear();
|
|
strIn.SetStr((LPWSTR)bstrURL);
|
|
|
|
SysFreeString(bstrURL);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get embeded instance
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassWrapper *CWmiOleDBMap::GetEmbededInstance(BSTR strPath,BSTR strProperty,int nIndex)
|
|
{
|
|
CWbemClassInstanceWrapper * pParentInst = NULL;
|
|
CWbemClassInstanceWrapper * pInstance = NULL;
|
|
IWbemClassObject *pObject = NULL;
|
|
IUnknown *pUnk = NULL;
|
|
CVARIANT vValue;
|
|
LONG lType;
|
|
LONG lFlavor;
|
|
HRESULT hr = S_OK;
|
|
|
|
pParentInst = (CWbemClassInstanceWrapper *)m_pWbemClassDefinition->GetInstance(strPath);
|
|
|
|
if(pParentInst)
|
|
{
|
|
hr = pParentInst->GetProperty(strProperty,(VARIANT *)&vValue, &lType, &lFlavor);
|
|
|
|
if(hr == S_OK && (vValue.GetType() == VT_UNKNOWN || vValue.GetType() == CIM_OBJECTARRAY ))
|
|
{
|
|
if( nIndex < 0 && vValue.GetType() == VT_UNKNOWN)
|
|
{
|
|
hr = vValue.GetUnknown()->QueryInterface(IID_IWbemClassObject,(void **)&pObject);
|
|
}
|
|
else
|
|
if( nIndex >= 0 && vValue.GetType() == CIM_OBJECTARRAY)
|
|
{
|
|
hr = SafeArrayGetElement(vValue,(long *)&nIndex,(void *)&pUnk);
|
|
if( hr == S_OK)
|
|
{
|
|
hr = pUnk->QueryInterface(IID_IWbemClassObject,(void **)&pObject);
|
|
pUnk->Release();
|
|
}
|
|
}
|
|
if(hr == S_OK)
|
|
{
|
|
try
|
|
{
|
|
pInstance = new CWbemClassInstanceWrapper(m_pWbemClassParms);
|
|
}
|
|
catch(...)
|
|
{
|
|
SAFE_DELETE_PTR(pInstance);
|
|
throw;
|
|
}
|
|
if(pInstance == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
pInstance->SetClass(pObject);
|
|
|
|
// Add the instance to the list so that this get released when class is destructed
|
|
m_paWbemClassInstances->AddInstance((CWbemClassInstanceWrapper *)pInstance);
|
|
}
|
|
}
|
|
}
|
|
SAFE_RELEASE_PTR(pObject);
|
|
SAFE_DELETE_PTR(pParentInst);
|
|
}
|
|
|
|
return pInstance;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Check if a particular property is a system property
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL CWmiOleDBMap::IsSystemProperty(BSTR strProperty)
|
|
{
|
|
LONG lFlavour = 0;
|
|
BOOL bRet = FALSE;
|
|
if( S_OK == m_pWbemClassDefinition->GetProperty(strProperty,NULL,NULL,&lFlavour) &&
|
|
(lFlavour == WBEM_FLAVOR_ORIGIN_SYSTEM))
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
return bRet;
|
|
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get default value from the DBCOLUMNDESC for a particular property
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWmiOleDBMap::GetDefaultValue(const DBCOLUMNDESC * prgColDesc, VARIANT & varDefault)
|
|
{
|
|
ULONG lIndex = 0,lColPropIndex = 0 , lPropType = 0;
|
|
BOOL bDefault = FALSE;
|
|
DBTYPE lType ;
|
|
BSTR strDate;
|
|
BOOL bDateTime = FALSE;
|
|
VARIANT *pDefaultData;
|
|
CDataMap map;
|
|
|
|
|
|
memset(&varDefault,0,sizeof(VARIANT));
|
|
|
|
// search for the DBPROP_COL_DEFAULT property in DBPROPSET_COLUMN in the property sets
|
|
if(prgColDesc->cPropertySets > 0)
|
|
{
|
|
for ( lIndex = 0 ; lIndex < prgColDesc->cPropertySets;lIndex++)
|
|
{
|
|
if(prgColDesc->rgPropertySets[lIndex].guidPropertySet == DBPROPSET_COLUMN)
|
|
for( lColPropIndex = 0; lColPropIndex < prgColDesc->rgPropertySets[lIndex].cProperties ; lColPropIndex++)
|
|
{
|
|
if(prgColDesc->rgPropertySets[lIndex].rgProperties[lColPropIndex].dwPropertyID == DBPROP_COL_DEFAULT)
|
|
{
|
|
pDefaultData = &prgColDesc->rgPropertySets[lIndex].rgProperties[lColPropIndex].vValue;
|
|
lType = prgColDesc->wType;
|
|
|
|
switch(lType)
|
|
{
|
|
case DBTYPE_DBTIMESTAMP :
|
|
map.ConvertOledbDateToCIMType(pDefaultData,strDate);
|
|
bDateTime = TRUE;
|
|
break;
|
|
|
|
case DBTYPE_DBDATE :
|
|
map.ConvertVariantDateToCIMType(pDefaultData->pdate,strDate);
|
|
bDateTime = TRUE;
|
|
break;
|
|
|
|
case DBTYPE_DBTIME :
|
|
bDateTime = TRUE;
|
|
break;
|
|
|
|
default:
|
|
VariantCopy(&varDefault,pDefaultData);
|
|
|
|
}
|
|
if(bDateTime == TRUE)
|
|
{
|
|
varDefault.vt = VT_BSTR;
|
|
varDefault.bstrVal = strDate;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
lPropType = ParseQualifiedNameToGetColumnType(prgColDesc->dbcid.uName.pwszName);
|
|
lType = prgColDesc->wType;
|
|
|
|
// If there is no default and if it is a qualilfier then
|
|
if( bDefault == FALSE && (lPropType == WMI_CLASS_QUALIFIER || lPropType == WMI_PROPERTY_QUALIFIER))
|
|
{
|
|
memset(&varDefault,0,sizeof(VARIANT));
|
|
switch(lType)
|
|
{
|
|
case DBTYPE_I1:
|
|
case DBTYPE_UI1:
|
|
case DBTYPE_I2:
|
|
case DBTYPE_UI2:
|
|
case DBTYPE_I4:
|
|
case DBTYPE_UI4:
|
|
case DBTYPE_I8:
|
|
case DBTYPE_UI8:
|
|
case DBTYPE_R4:
|
|
case DBTYPE_R8:
|
|
case DBTYPE_WSTR:
|
|
case DBTYPE_STR:
|
|
case DBTYPE_IDISPATCH :
|
|
varDefault.vt = (SHORT)lType;
|
|
break;
|
|
|
|
case DBTYPE_BSTR:
|
|
varDefault.vt = VT_BSTR;
|
|
varDefault.bstrVal = SysAllocString(L"");
|
|
break;
|
|
|
|
case DBTYPE_BOOL:
|
|
varDefault.vt = VT_BOOL;
|
|
varDefault.boolVal = VARIANT_TRUE;
|
|
break;
|
|
|
|
case DBTYPE_DBTIMESTAMP:
|
|
varDefault.vt = VT_DATE;
|
|
break;
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Commit the row data for qualifier rowset
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::CommitRowDataForQualifier(CRowDataMemMgr * pRow,BSTR strQualifier,CVARIANT &vValue, ULONG lType, ULONG lFlavor)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CVARIANT var;
|
|
|
|
var.SetStr(strQualifier);
|
|
hr = pRow->CommitColumnToRowData(var,DBTYPE_BSTR);
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
var.Clear();
|
|
var.SetLONG(vValue.GetType());
|
|
hr = pRow->CommitColumnToRowData(var,DBTYPE_UI4);
|
|
}
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
hr = pRow->CommitColumnToRowData(vValue,DBTYPE_VARIANT);
|
|
}
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
var.Clear();
|
|
var.SetLONG(lFlavor);
|
|
hr = pRow->CommitColumnToRowData(var,DBTYPE_BSTR);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to release a qualifer
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWmiOleDBMap::ReleaseQualifier(CWbemClassWrapper *pInst,BSTR strProperty)
|
|
{
|
|
if( strProperty == NULL)
|
|
{
|
|
pInst->ReleaseClassQualifier();
|
|
}
|
|
else
|
|
{
|
|
pInst->ReleasePropertyQualifier(strProperty);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
HRESULT CWmiOleDBMap::SetQualifier(CWbemClassWrapper *pInst,BSTR bstrColName,BSTR bstrQualifier ,VARIANT *pvarData,LONG lFlavor)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(bstrColName == NULL)
|
|
{
|
|
hr = pInst->SetClassQualifier(bstrQualifier,pvarData,lFlavor);
|
|
}
|
|
else
|
|
{
|
|
hr = pInst->SetPropertyQualifier(bstrColName,bstrQualifier,pvarData,lFlavor);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Funtion to add a index qualifier for a property
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::AddIndex(const DBID* pColumnID)
|
|
{
|
|
HRESULT hr ;
|
|
CBSTR strColumnName(pColumnID->uName.pwszName);
|
|
CBSTR strIndexQualifier((WCHAR *)strIndex);
|
|
VARIANT varIndexValue;
|
|
VariantInit(&varIndexValue);
|
|
|
|
varIndexValue.vt = VT_BOOL;
|
|
varIndexValue.boolVal = VARIANT_TRUE;
|
|
|
|
|
|
if( S_OK == (hr = m_pWbemClassDefinition->ValidClass())){
|
|
|
|
//===================================================================================
|
|
// If the passed columnID is a property then add a index qualifier to the property
|
|
//===================================================================================
|
|
if(WMI_PROPERTY == ParseQualifiedNameToGetColumnType((WCHAR*)pColumnID->uName.pwszName))
|
|
{
|
|
hr = SetQualifier(m_pWbemClassDefinition,strColumnName,strIndexQualifier ,&varIndexValue,0);
|
|
}
|
|
else
|
|
{
|
|
hr = DB_E_BADCOLUMNID;
|
|
}
|
|
}
|
|
|
|
//=================================================================
|
|
// If everthing is fine then save the changes to WMI
|
|
//=================================================================
|
|
if( hr == S_OK)
|
|
{
|
|
hr = m_pWbemClassDefinition->SaveClass(FALSE);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Funtion to delete a index qualifier as mentioned in pIndexID
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::DropIndex(const DBID* pIndexID)
|
|
{
|
|
HRESULT hr ;
|
|
CBSTR strColumnName(pIndexID->uName.pwszName);
|
|
WCHAR *pStrIndex = NULL;
|
|
WCHAR * pwcsQualifier = NULL;
|
|
WCHAR * pwcsProperty = NULL;
|
|
|
|
try
|
|
{
|
|
pStrIndex = new WCHAR [wcslen(strIndex) + 1];
|
|
}
|
|
catch(...)
|
|
{
|
|
SAFE_DELETE_ARRAY(pStrIndex);
|
|
throw;
|
|
}
|
|
|
|
if(pStrIndex == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
wcscpy(pStrIndex,(WCHAR *)strIndex);
|
|
|
|
_wcsupr(pStrIndex);
|
|
|
|
|
|
if( S_OK == (hr = m_pWbemClassDefinition->ValidClass())){
|
|
|
|
if(WMI_PROPERTY_QUALIFIER == ParseQualifiedNameToGetColumnType((WCHAR*)pIndexID->uName.pwszName))
|
|
{
|
|
if( ParseQualifiedName((WCHAR*)pIndexID->uName.pwszName,pwcsProperty,pwcsQualifier))
|
|
{
|
|
_wcsupr(pwcsQualifier);
|
|
//=================================================================
|
|
// If the qualifer name is "Index" then delete the index
|
|
//=================================================================
|
|
if(wbem_wcsicmp(pStrIndex,pwcsQualifier) == 0)
|
|
hr = m_pWbemClassDefinition->DeletePropertyQualifier(pwcsProperty,pwcsQualifier);
|
|
else
|
|
hr = E_INVALIDARG; // the index ID passed is invalid
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG; // passed index is not a valid index
|
|
}
|
|
}
|
|
// free the memory
|
|
SAFE_DELETE_ARRAY(pStrIndex);
|
|
SAFE_DELETE_ARRAY(pwcsProperty);
|
|
SAFE_DELETE_ARRAY(pwcsQualifier);
|
|
|
|
//=================================================================
|
|
// If everthing is fine then save the changes to WMI
|
|
//=================================================================
|
|
if(SUCCEEDED( hr))
|
|
{
|
|
hr = m_pWbemClassDefinition->SaveClass(FALSE);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Converts the OLEDB COLUMN properties to appropriate WMI properties/flavors
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::SetColumnProperties(const DBCOLUMNDESC * prgColDesc)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
CBSTR bstrProperty(prgColDesc->dbcid.uName.pwszName);
|
|
CDataMap map;
|
|
LONG lType = 0;
|
|
BOOL bIsColProperty = FALSE;
|
|
|
|
//==================================================================================
|
|
// Ok, we already know we have a valid class here so just check if we have a valid
|
|
// property
|
|
//==================================================================================
|
|
if( SUCCEEDED(hr = ValidProperty(prgColDesc)))
|
|
{
|
|
switch(ParseQualifiedNameToGetColumnType(prgColDesc->dbcid.uName.pwszName))
|
|
{
|
|
|
|
case WMI_CLASS_QUALIFIER:
|
|
hr = SetWMIClassQualifier(prgColDesc,FALSE);
|
|
break;
|
|
|
|
case WMI_PROPERTY_QUALIFIER:
|
|
hr = SetWMIPropertyQualifier(prgColDesc,FALSE);
|
|
break;
|
|
|
|
case WMI_PROPERTY:
|
|
bIsColProperty = TRUE;
|
|
break;
|
|
|
|
default:
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
|
|
// If the column passed is a property , then add qualifiers for the different
|
|
// column properties
|
|
if( bIsColProperty == TRUE)
|
|
{
|
|
//==========================================================================
|
|
// Go through the DBPROPSETS and the DBPROPS in them to see if they
|
|
// happen to match some of the standard qualifiers we have mapped to them
|
|
//==========================================================================
|
|
|
|
for( ULONG i = 0; i < prgColDesc->cPropertySets; i++ )
|
|
{
|
|
|
|
for ( ULONG j = 0; j < prgColDesc->rgPropertySets[i].cProperties; j++ )
|
|
{
|
|
|
|
CVARIANT Value,Qualifier;
|
|
LONG lFlavor;
|
|
|
|
//==================================================================
|
|
// See if we have a match, if we do, save it to WMI
|
|
//==================================================================
|
|
hr = MapDBPROPToStdPropertyQualifier(prgColDesc->rgPropertySets[i].rgProperties[j],Qualifier,Value, lFlavor);
|
|
if( hr == S_OK)
|
|
{
|
|
|
|
hr = m_pWbemClassDefinition->SetPropertyQualifier((BSTR)bstrProperty,Qualifier,Value,0);
|
|
if( FAILED(hr))
|
|
{
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
hr = m_pWbemClassDefinition->SaveClass(FALSE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get class name of an instance
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
WCHAR * CWmiOleDBMap::GetClassName()
|
|
{
|
|
WCHAR *pRet = NULL;
|
|
//================================================================
|
|
// if this class is opened on command by executing query then
|
|
// return NULL as the class name
|
|
//================================================================
|
|
if(!(m_pWbemCommandManager || m_pWbemCollectionManager))
|
|
{
|
|
pRet = m_pWbemClassParms->GetClassName();
|
|
}
|
|
|
|
return pRet;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to delete a quallifier
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::DeleteQualifier(CWbemClassWrapper *pInst,
|
|
BSTR strQualifierName,
|
|
BOOL bClassQualifier ,
|
|
BSTR strPropertyName )
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if(bClassQualifier)
|
|
{
|
|
hr = pInst->DeletePropertyQualifier(strPropertyName,strQualifierName);
|
|
}
|
|
else
|
|
{
|
|
hr = ((CWbemClassDefinitionWrapper *)pInst)->DeleteClassQualifier(strPropertyName);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to remove an object from a container
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::UnlinkObjectFromContainer(BSTR strContainerObj,BSTR strObject)
|
|
{
|
|
return m_pWbemClassParms->RemoveObjectFromContainer(strContainerObj,strObject);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to add an object to a container
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::LinkObjectFromContainer(BSTR strContainerObj,BSTR strObject)
|
|
{
|
|
return m_pWbemClassParms->AddObjectFromContainer(strContainerObj,strObject);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to copy an existing instance to another scope
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWmiOleDBMap::CloneAndAddNewObjectInScope(BSTR strObj, BSTR strScope,WCHAR *& pstrNewPath)
|
|
{
|
|
HRESULT hr = DB_E_NOTFOUND;
|
|
CWbemClassWrapper *pInstance = GetInstance(strScope);
|
|
|
|
if(pInstance)
|
|
{
|
|
hr = m_pWbemClassParms->CloneAndAddNewObjectInScope(pInstance,strObj,pstrNewPath);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CWmiOleDBMap::GetPropertyColumnInfoForMixedRowsets( cRowColumnInfoMemMgr * pColumn, DBCOLUMNINFO ** pCol)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBORDINAL lOrdinal = -1;
|
|
|
|
|
|
BSTR bstrProperty = Wmioledb_SysAllocString(L"__PATH");
|
|
lOrdinal = pColumn->GetColOrdinal((WCHAR *)L"__PATH");
|
|
|
|
// if the column is already present in the col info info return
|
|
// This will happen when for row objects obtained from rowsets
|
|
if((DB_LORDINAL)lOrdinal < 0)
|
|
{
|
|
|
|
hr = pColumn->AddColumnNameToList(bstrProperty, pCol);
|
|
SysFreeString(bstrProperty);
|
|
if( hr == S_OK )
|
|
{
|
|
//==================================================================
|
|
// We use ordinal numbers for our columns
|
|
//==================================================================
|
|
SetCommonDBCOLUMNINFO(pCol, pColumn->GetCurrentIndex());
|
|
SetColumnReadOnly(*pCol,TRUE);
|
|
|
|
pColumn->SetCIMType(VT_BSTR);
|
|
|
|
|
|
(*pCol)->wType = VT_BSTR;
|
|
(*pCol)->ulColumnSize = ~0;
|
|
(*pCol)->dwFlags = 0;
|
|
|
|
hr = S_OK;
|
|
// NTRaid:111762
|
|
// 06/13/00
|
|
hr = pColumn->CommitColumnInfo();
|
|
}
|
|
}
|
|
return hr;
|
|
|
|
}
|
|
|
|
INSTANCELISTTYPE CWmiOleDBMap::GetObjListType()
|
|
{
|
|
INSTANCELISTTYPE qType = NORMAL;
|
|
if(m_pWbemCommandManager)
|
|
{
|
|
qType = m_pWbemCommandManager->GetObjListType();
|
|
}
|
|
else
|
|
if(m_pWbemCollectionManager)
|
|
{
|
|
qType = m_pWbemCollectionManager->GetObjListType();
|
|
}
|
|
return qType;
|
|
}
|