/////////////////////////////////////////////////////////////////////////////////// // // 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; }