windows-xp/Source/XPSP1/NT/admin/wmi/wbem/adapters/oledb/wmioledbmap.cpp

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