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

////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Microsoft WMI OLE DB Provider
//
// (C) Copyright 1999-2000 Microsoft Corporation. All Rights Reserved.
//
//	Schema.cpp	-	Schema related class implementation
////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "headers.h"
#include "schema.h"
#include "enumerat.h"

extern const WCHAR szWQL[] = L"WQL";
extern const WCHAR szWQL2[] = L"WQL2";


#define TABLENAMEMAX 255
//Bug No: NTRaid 126631
// 06/13/00
#define NUMBER_OF_SCHEMAS	8
enum guiddata
{
	data1_DBSCHEMA_CATALOGS             = 0xc8b52211,
	data1_DBSCHEMA_PROVIDER_TYPES       = 0xc8b5222c,
    data1_DBSCHEMA_COLUMNS              = 0xc8b52214,
    data1_DBSCHEMA_TABLES               = 0xc8b52229,
    data1_DBSCHEMA_PRIMARY_KEYS         = 0xc8b522c5,
	data1_DBSCHEMA_TABLES_INFO          = 0xc8b522e0,
    data1_DBSCHEMA_PROCEDURES           = 0xc8b52224,
    data1_DBSCHEMA_PROCEDURE_PARAMETERS = 0xc8b522b8,
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////

CIMTypeInfo g_ProviderTypeDetails[] = {
    { L"CIM_EMPTY",     0,                  0,                  0},
    { L"CIM_SINT8",     DBTYPE_I1,          sizeof(BYTE),       0},
    { L"CIM_UINT8",     DBTYPE_UI1,         sizeof(BYTE),       1},
    { L"CIM_SINT16",    DBTYPE_I2,          sizeof(short),      0},
    { L"CIM_UINT16",    DBTYPE_UI2,         sizeof(short),      1},
    { L"CIM_SINT32",    DBTYPE_I4,          sizeof(long),       0},
    { L"CIM_UINT32",    DBTYPE_UI4,         sizeof(long),       1},
    { L"CIM_SINT64",    DBTYPE_I8,          sizeof(__int64),    0},
    { L"CIM_UINT64",    DBTYPE_UI8,         sizeof(__int64),    1},
    { L"CIM_REAL32",    DBTYPE_R4,          sizeof(long),       0},
    { L"CIM_REAL64",    DBTYPE_R8,          sizeof(__int64),    0},
    { L"CIM_BOOLEAN",   DBTYPE_BOOL,        sizeof(short),      0},
    { L"CIM_STRING",    DBTYPE_BSTR,        ~0,                 0},
    { L"CIM_DATETIME",  DBTYPE_DBTIMESTAMP, sizeof(DBTIMESTAMP),0},
//    { L"CIM_REFERENCE", 0,                  0,                  0},
    { L"CIM_CHAR16",    DBTYPE_UI2,         sizeof(short),      1}
//    { L"CIM_OBJECT",    DBTYPE_IUNKNOWN,    sizeof(BSTR),       0},
//    { L"CIM_FLAG_ARRAY",0,                  0,                  0}
};

SchemaRowsetDefinition g_SourcesRowsetColumns[] = { {L"SOURCES_NAME",       CIM_STRING}, 
                                                    {L"SOURCES_PARSENAME",  CIM_STRING}, 
                                                    {L"SOURCES_DESCRIPTION",CIM_STRING},
                                                    {L"SOURCES_TYPE",       CIM_UINT16},
                                                    {L"SOURCES_ISPARENT",   CIM_BOOLEAN}};


SchemaRowsetDefinition g_ProviderTypes[] = { {L"TYPE_NAME",         CIM_STRING}, 
                                             {L"DATA_TYPE",         CIM_UINT16}, 
                                             {L"COLUMN_SIZE",       CIM_UINT32}, 
                                             {L"LITERAL_PREFIX",    CIM_STRING},
                                             {L"LITERAL_SUFFIX",    CIM_STRING},
                                             {L"CREATE_PARAMS",     CIM_STRING},
                                             {L"IS_NULLABLE",       CIM_BOOLEAN},
                                             {L"CASE_SENSITIVE",    CIM_BOOLEAN},
                                             {L"SEARCHABLE"    ,    CIM_UINT32},
                                             {L"UNSIGNED_ATTRIBUTE",CIM_BOOLEAN},
                                             {L"FIXED_PREC_SCALE",  CIM_BOOLEAN},
                                             {L"AUTO_UNIQUE_VALUE", CIM_BOOLEAN},
                                             {L"LOCAL_TYPE_NAME",   CIM_STRING},
                                             {L"MINIMUM_SCALE",     CIM_SINT16},
                                             {L"MAXIMUM_SCALE",     CIM_SINT16},
                                             {L"GUID",              DBTYPE_GUID},
                                             {L"TYPELIB",           CIM_STRING},
                                             {L"VERSION",           CIM_STRING},
                                             {L"IS_LONG",           CIM_BOOLEAN},
                                             {L"BEST_MATCH",        CIM_BOOLEAN},
                                             {L"IS_FIXEDLENGTH",    CIM_BOOLEAN} };

SchemaRowsetDefinition g_CatalogRowsetColumns[] = {{L"CATALOG_NAME",       CIM_STRING},
                                                    {L"SOURCES_DESCRIPTION", CIM_STRING} };

SchemaRowsetDefinition g_Tables[] =  {  {L"TABLE_CATALOG",   CIM_STRING},
                                        {L"TABLE_SCHEMA",    CIM_STRING},
                                        {L"TABLE_NAME",      CIM_STRING},
                                        {L"TABLE_TYPE",      CIM_STRING},
                                        {L"TABLE_GUID",      DBTYPE_GUID},
                                        {L"DESCRIPTION",     CIM_STRING},
                                        {L"TABLE_PROPID",    CIM_UINT32},
                                        {L"DATE_CREATED",    DBTYPE_DATE},
                                        {L"DATE_MODIFIED",   DBTYPE_DATE}};


SchemaRowsetDefinition g_TablesInfo[] =  {  {L"TABLE_CATALOG",  CIM_STRING},
                                        {L"TABLE_SCHEMA",       CIM_STRING},
                                        {L"TABLE_NAME",         CIM_STRING},
                                        {L"TABLE_TYPE",         CIM_STRING},
                                        {L"TABLE_GUID",         DBTYPE_GUID},
                                        {L"BOOKMARKS",          CIM_BOOLEAN},
                                        {L"BOOKMARK_TYPE",      CIM_UINT32},
                                        {L"BOOKMARK_DATATYPE",      CIM_UINT16},
                                        {L"BOOKMARK_MAXIMUM_LENGTH",CIM_UINT32},
                                        {L"BOOKMARK_INFORMATION",   CIM_UINT32},
                                        {L"TABLE_VERSION",          CIM_SINT64},
                                        {L"CARDINALITY",            CIM_UINT64},
                                        {L"DESCRIPTION",            CIM_STRING},
                                        {L"TABLE_PROPID",           CIM_UINT32}};


SchemaRowsetDefinition g_ColumnsRowsetColumns[] = { {L"TABLE_CATALOG",              CIM_STRING},
                                                    {L"TABLE_SCHEMA",               CIM_STRING}, 
                                                    {L"TABLE_NAME",                 CIM_STRING}, 
                                                    {L"COLUMN_NAME",                CIM_STRING}, 
                                                    {L"COLUMN_GUID",                DBTYPE_GUID}, 
                                                    {L"COLUMN_PROPID",              CIM_UINT32}, 
                                                    {L"COLUMN_POSITION",            CIM_UINT32}, 
                                                    {L"COLUMN_HASDEFAULT",          CIM_BOOLEAN}, 
                                                    {L"COLUMN_DEFAULT",             CIM_STRING}, 
                                                    {L"COLUMN_FLAGS",               CIM_UINT32}, 
                                                    {L"IS_NULLABLE",                CIM_BOOLEAN}, 
                                                    {L"DATA_TYPE",                  CIM_UINT16}, 
                                                    {L"TYPE_GUID",                  DBTYPE_GUID}, 
                                                    {L"CHARACTER_MAXIMUM_LENGTH",   CIM_UINT32}, 
                                                    {L"CHARACTER_OCTET_LENGTH",     CIM_UINT32}, 
                                                    {L"NUMERIC_PRECISION",          CIM_UINT16}, 
                                                    {L"NUMERIC_SCALE",              CIM_SINT16}, 
                                                    {L"DATETIME_PRECISION",         CIM_UINT32}, 
                                                    {L"CHARACTER_SET_CATALOG",      CIM_STRING}, 
                                                    {L"CHARACTER_SET_SCHEMA",       CIM_STRING}, 
                                                    {L"CHARACTER_SET_NAME",         CIM_STRING}, 
                                                    {L"COLLATION_CATALOG",          CIM_STRING}, 
                                                    {L"COLLATION_SCHEMA",           CIM_STRING}, 
                                                    {L"COLLATION_NAME",             CIM_STRING}, 
                                                    {L"DOMAIN_CATALOG",             CIM_STRING}, 
                                                    {L"DOMAIN_SCHEMA",              CIM_STRING}, 
                                                    {L"DOMAIN_NAME",                CIM_STRING}, 
                                                    {L"DESCRIPTION",                CIM_STRING}};


SchemaRowsetDefinition g_PrimaryKeysColumns[] =  {  {L"TABLE_CATALOG",   CIM_STRING},
                                                    {L"TABLE_SCHEMA",    CIM_STRING},
                                                    {L"TABLE_NAME",      CIM_STRING},
                                                    {L"COLUMN_NAME",     CIM_STRING},
                                                    {L"COLUMN_GUID",     DBTYPE_GUID},
                                                    {L"COLUMN_PROPID",   CIM_UINT32},
                                                    {L"ORDINAL",         CIM_UINT32},
                                                    {L"PK_NAME",         CIM_STRING}};
        
SchemaRowsetDefinition g_Procedures[] = {{L"PROCEDURE_CATALOG",     CIM_STRING},
                                         {L"PROCEDURE_SCHEMA",      CIM_STRING},
                                         {L"PROCEDURE_NAME",        CIM_STRING}, 
                                         {L"PROCEDURE_TYPE",        CIM_SINT16}, 
                                         {L"PROCEDURE_DEFINITION",  CIM_STRING}, 
                                         {L"DESCRIPTION",           CIM_STRING}, 
                                         {L"DATE_CREATED",          DBTYPE_DATE}, 
                                         {L"DATE_MODIFIED",          DBTYPE_DATE}}; 


SchemaRowsetDefinition g_ProcedureParameters[] = {{L"PROCEDURE_CATALOG",     CIM_STRING},
                                                  {L"PROCEDURE_SCHEMA",      CIM_STRING},
                                                  {L"PROCEDURE_NAME",        CIM_STRING}, 
                                                  {L"PARAMETER_NAME",        CIM_STRING}, 
                                                  {L"ORDINAL_POSITION",      CIM_UINT16}, 
                                                  {L"PARAMETER_TYPE",        CIM_UINT16}, 
                                                  {L"PARAMETER_HASDEFAULT",  CIM_BOOLEAN}, 
                                                  {L"PARAMETER_DEFAULT",     CIM_STRING}, 
                                                  {L"IS_NULLABLE",           CIM_BOOLEAN}, 
                                                  {L"DATATYPE",              CIM_UINT16}, 
                                                  {L"CHARACTER_MAXIMUM_LENGTH",CIM_UINT32}, 
                                                  {L"CHARACTER_OCTECT_LENGTH", CIM_UINT32}, 
                                                  {L"NUMERIC_PRECISION",       CIM_UINT16}, 
                                                  {L"NUMERIC_SCALE",           CIM_SINT16}, 
                                                  {L"DESCRIPTION",             CIM_STRING}, 
                                                  {L"TYPE_NAME",               CIM_STRING}, 
                                                  {L"LOCAL_TYPE_NAME",         CIM_STRING}};

SchemaRowsetDefinition g_ProcedureColumns[] = {{L"PROCEDURE_CATALOG",     CIM_STRING},
                                               {L"PROCEDURE_SCHEMA",      CIM_STRING},
                                               {L"PROCEDURE_NAME",        CIM_STRING}, 
                                               {L"COLUMN_NAME",           CIM_STRING},
                                               {L"COLUMN_GUID",           DBTYPE_GUID},
                                               {L"COLUMN_PROPID",         CIM_UINT32},
                                               {L"ROWSET_NUMBER",         CIM_UINT32},
                                               {L"ORDINAL_POSITION",      CIM_UINT32},
                                               {L"IS_NULLABLE",           CIM_BOOLEAN},
                                               {L"DATA_TYPE",             CIM_UINT16},
                                               {L"TYPE_GUID",             DBTYPE_GUID},
                                               {L"CHARACTER_MAXIMUM_LENGTH", CIM_UINT32},
                                               {L"CHARACTER_OCTECT_LENGTH",  CIM_UINT32},
                                               {L"NUMERIC_PRECISION",        CIM_UINT16},
                                               {L"NUMERIC_SCALE",            CIM_SINT16},
                                               {L"DESCRIPTION",              CIM_STRING}};


////////////////////////////////////////////////////////////////////////////////////////////////////////////
//**********************************************************************************************************
//
//  CLASS:  CSCHEMA
//
//**********************************************************************************************************
////////////////////////////////////////////////////////////////////////////////////////////////////////////
CSchema::CSchema(LPUNKNOWN pUnkOuter, int nTableId,PCDBSESSION pObj) : 
            CRowset(pUnkOuter,pObj)	
{
	m_nTableId = nTableId;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
CSchema::~CSchema()
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Sets the rowset property corresponding to the requested interface if the requested interface is available
// on a read-only rowset.
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CSchema::SetReadOnlyProperty( CUtilProp*	pRowsetProps,REFIID riid )
{
	HRESULT hr = S_OK;
	
	if (riid == IID_IRowsetChange || riid == IID_IRowsetUpdate	|| riid == IID_IRowsetResynch)
		hr = (E_NOINTERFACE);

	return hr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Initialize a schema rowset
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CSchema::FInit(    ULONG	    cPropertySets, 	    DBPROPSET rgPropertySets[],	
                                REFIID	    riid,		        IUnknown	*pUnkOuter,			
                                IUnknown		**ppIRowset,    WCHAR * wcsSpecificTable )
{
	HRESULT					hr = S_OK;
	HRESULT					hrProp = S_OK;
	DWORD					dwStatus = 0;
	PWSTR					pwszBuff = NULL;
	LONG					cCursorRows = 0;
	WCHAR					strTableName[TABLENAMEMAX];

	memset(strTableName,0,TABLENAMEMAX * sizeof(WCHAR));

	if( SUCCEEDED(hr =GetTableName(strTableName)))
	{
	   //==========================================================================
		// Set the Rowset Properties 
		//==========================================================================
		hr = InitRowset(m_nTableId, cPropertySets,rgPropertySets,strTableName,0,wcsSpecificTable);
		if(SUCCEEDED(hr))
		{

			//==========================================================================
			// If the consumer asks for IID_IUnknown, IID_IAccessor, 
			// IID_IColumnsInfo, or IID_IRowsetInfo, we do not need to 
			//==========================================================================
			if ( riid != IID_IRowset &&	riid != IID_IColumnsInfo && riid != IID_IAccessor && riid != IID_IRowsetInfo 
				&& riid !=  IID_IUnknown && riid != IID_IMultipleResults ){
				hr = SetReadOnlyProperty(m_pUtilProp,riid);
			}

			if(SUCCEEDED(hr))
			{
				//==========================================================================
				// Execute the schema command to produce the rowset.
				//==========================================================================

				if (SUCCEEDED(hr)){

					if (hr == DB_E_ERRORSOCCURRED && cPropertySets > 0){
						m_pUtilProp->SetPropertiesArgChk(cPropertySets, rgPropertySets);
					}
				}


				if (DB_S_ERRORSOCCURRED == hr){

					hrProp = DB_S_ERRORSOCCURRED;
					if (cPropertySets > 0)
					{
						m_pUtilProp->SetPropertiesArgChk(cPropertySets, rgPropertySets);
					}
				}

				//==========================================================================
				// Get the requested interfaceS
				//==========================================================================
				hr = QueryInterface(riid, (LPVOID*)ppIRowset);
				
			}	// if (Succeeded(hr))
		
		}	// If(succeeded(hr) after initializing the rowset
	
	}	// if a valid tablename


	hr =  (hr == S_OK) ? hrProp : hr;
	hr = hr != S_OK ? g_pCError->PostHResult(hr, &IID_IDBSchemaRowset) : hr;
	return hr;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CSchema::GetTableName(WCHAR *pTableName)
{
	HRESULT hr = S_OK;

	if(pTableName != NULL)
	{
		switch(m_nTableId)
		{
            case PROCEDURES_ROWSET:
				wcscpy(pTableName,PROCEDURES);
                break;

            case PROCEDURE_PARAMETERS_ROWSET:
				wcscpy(pTableName,PROCEDURE_PARAMETERS);
                break;

			case SOURCES_ROWSET:
				wcscpy(pTableName,NAMESPACE);
				break;

			case PROVIDER_TYPES_ROWSET:
				wcscpy(pTableName,PROVIDER_TYPES);
				break;

			case CATALOGS_ROWSET:
				wcscpy(pTableName,CATALOGS);
				break;

			case COLUMNS_ROWSET:
				wcscpy(pTableName,COLUMNS);
				break;

			case TABLES_ROWSET:
				wcscpy(pTableName,TABLES);
				break;

			case PRIMARY_KEYS_ROWSET:
				wcscpy(pTableName,PRIMARY_KEYS);
				break;

			case TABLES_INFO_ROWSET:
				wcscpy(pTableName,TABLESINFO);
				break;

			default:
				hr = E_FAIL;

		};
	}
	else
	{
		hr = E_FAIL;
	}
	return hr;

}
/*
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Increments a reference count for the object.
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_(ULONG) CImpIDBSchemaRowset::AddRef(void)
{
    DEBUGCODE(InterlockedIncrement((long*)&m_cRef));
	return m_pCDBSession->AddRef();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Decrement the object's reference count and deletes the object when the new reference count is zero.
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_(ULONG) CImpIDBSchemaRowset::Release(void)
{
    DEBUGCODE(InterlockedDecrement((long*)&m_cRef));
	return m_pCDBSession->Release();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Returns a pointer to a specified interface. Callers use QueryInterface to determine which interfaces the 
// called object supports. 
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CImpIDBSchemaRowset::QueryInterface( REFIID riid, LPVOID *	ppv	)	
{
	return m_pCDBSession->QueryInterface(riid, ppv);
}

*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//**********************************************************************************************************
//
//  CLASS CImpIDBSchemaRowset
//
//**********************************************************************************************************
////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Instantiate a rowset with schema information.
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CImpIDBSchemaRowset::GetRowset( IUnknown *pUnkOuter, REFGUID rguidSchema, ULONG cRestrictions,
                                        	 const VARIANT rgRestrictions[], REFIID riid,ULONG cProperties,
                                             DBPROPSET rgProperties[], IUnknown **ppIRowset	)
{
	HRESULT hr;
	CSchema *pCSchema = NULL;
    WCHAR * wcsSpecificTable = NULL;

    //========================================================
	// Serialize access to this object.
    //========================================================

	CAutoBlock cab(m_pCDBSession->GetCriticalSection());


	CError::ClearErrorInfo();

    //========================================================
	// Assign in case of error.
    //========================================================
	if (ppIRowset)
    {
		*ppIRowset = NULL;
    }
    //========================================================
	// Check per spec.
    //========================================================
    if (ppIRowset == NULL	|| (cRestrictions && rgRestrictions == NULL)	|| (cProperties   && rgProperties   == NULL) )
    {
		g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
    }
    else
    {
        //========================================================
	    // The outer object must explicitly ask for IUnknown
        //========================================================
	    if (pUnkOuter != NULL && riid != IID_IUnknown)
        {
		    g_pCError->PostHResult((DB_E_NOAGGREGATION), &IID_IDBSchemaRowset);
	    }
        else{
            //========================================================
	        // Assume that all the pre-defined OLEDB guids differ 
            // only by the first DWORD, Data1. We have to make a 
            // table of constants, since the compiler can't 
	        // have non-constants in case statements.
            //========================================================

	        switch ( rguidSchema.Data1 )
            {

                //===================================================
                //  methods - the list of methods for a table
                //===================================================
                case data1_DBSCHEMA_PROCEDURES:

                    if (cRestrictions > CRESTRICTIONS_DBSCHEMA_PROCEDURES)
                    {
				        g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
                    }
                    else
                    {
                        //====================================================================
                        //  The specific table name is located in the 3rd restriction
                        //====================================================================
                        if( cRestrictions > 1  && rgRestrictions[1].vt != VT_EMPTY)
                        {
                            wcsSpecificTable = V_BSTR(&rgRestrictions[1]);
                        }
			            pCSchema = new CSchema_Procedures(pUnkOuter,m_pCDBSession);
                    }
                    break;

                //===================================================
                //  methods - the list of parameters for a method
                //===================================================
                case data1_DBSCHEMA_PROCEDURE_PARAMETERS:
                    if (cRestrictions > CRESTRICTIONS_DBSCHEMA_PROCEDURE_PARAMETERS)
                    {
				        g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
                    }
                    else
                    {
                        //====================================================================
                        //  The specific table name is located in the 3rd restriction
                        //====================================================================
                        if( cRestrictions > 1 && rgRestrictions[1].vt != VT_EMPTY)
                        {
                            wcsSpecificTable = V_BSTR(&rgRestrictions[1]);
                        }
			            pCSchema = new CSchema_Procedure_Parameters(pUnkOuter,m_pCDBSession);
                    }
                    break;

                //===================================================
                //  catalogs
                //===================================================
                case data1_DBSCHEMA_CATALOGS:

                    if (cRestrictions > CRESTRICTIONS_DBSCHEMA_CATALOGS)
                    {
				        g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
                    }
                    else
                        {
			            pCSchema = new CSchema_Catalogs(pUnkOuter,m_pCDBSession);
                    }
			        break;

                //===================================================
                //  provider types
                //===================================================
		        case data1_DBSCHEMA_PROVIDER_TYPES:
                    if (cRestrictions > CRESTRICTIONS_DBSCHEMA_PROVIDER_TYPES){
				        g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
                    }
                    else{
			            pCSchema = new CSchema_Provider_Types(pUnkOuter,m_pCDBSession);
                    }
			        break;

                //===================================================
                //  columns
                //===================================================
                case data1_DBSCHEMA_COLUMNS:
                    if (cRestrictions > CRESTRICTIONS_DBSCHEMA_COLUMNS)
                    {
				        g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
                    }
                    else
                    {
                        //====================================================================
                        //  The specific table name is located in the 3rd restriction
                        //====================================================================
                        if( cRestrictions > 2 && rgRestrictions[2].vt != VT_EMPTY)
                        {
                            wcsSpecificTable = V_BSTR(&rgRestrictions[2]);
                        }
			            pCSchema = new CSchema_Columns(pUnkOuter,m_pCDBSession);
                    }
			        break;


                //===================================================
                //  tables
                //===================================================
                case data1_DBSCHEMA_TABLES:
                    if (cRestrictions > CRESTRICTIONS_DBSCHEMA_TABLES)
                    {
				       g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
                    }
                    else
                    {
                        //====================================================================
                        //  The specific table name is located in the 3rd restriction
                        //====================================================================
                        if( cRestrictions > 2 && rgRestrictions[2].vt != VT_EMPTY)
                        {
                            wcsSpecificTable = V_BSTR(&rgRestrictions[2]);
                        }
			            pCSchema = new CSchema_Tables(pUnkOuter,m_pCDBSession);
                    }
			        break;

                //===================================================
                //  primary keys
                //===================================================
                case data1_DBSCHEMA_PRIMARY_KEYS:
                    if (cRestrictions > CRESTRICTIONS_DBSCHEMA_TABLES_INFO)
                    {
				       g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
                    }
                    else
                    {
                        //====================================================================
                        //  The specific table name is located in the 2nd restriction
                        //====================================================================
                        if( cRestrictions > 1 && rgRestrictions[1].vt != VT_EMPTY)
                        {
                            wcsSpecificTable = V_BSTR(&rgRestrictions[1]);
                        }
			            pCSchema = new CSchema_Primary_Keys(pUnkOuter,m_pCDBSession);
                    }
			        break;

                //===================================================
                //  tables info
                //===================================================
                case data1_DBSCHEMA_TABLES_INFO:
                    if (cRestrictions > CRESTRICTIONS_DBSCHEMA_TABLES_INFO)
                    {
				       g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
                    }
                    else
                    {
                        //====================================================================
                        //  The specific table name is located in the 3rd restriction
                        //====================================================================
                        if( cRestrictions > 2 && rgRestrictions[2].vt != VT_EMPTY)
                        {
                            wcsSpecificTable = V_BSTR(&rgRestrictions[2]);
                        }
			            pCSchema = new CSchema_Tables_Info(pUnkOuter,m_pCDBSession);
                    }
			        break;


		        default:
                    //===================================================
			        // check for provider-specific schema rowsets
                    //===================================================
			        return g_pCError->PostHResult(E_INVALIDARG, &IID_IDBSchemaRowset);
			        break;
	        }
            //===================================================
	        // At this point, pCSchema contains the uninitialized 
            // object, derived from CSchema
            //===================================================
	        if (!pCSchema)
            {
		        g_pCError->PostHResult((E_OUTOFMEMORY), &IID_IDBSchemaRowset);
	        }
        }
    }
    //===================================================
	// Initialize.  Creates the rowset.
    //===================================================
    if( pCSchema )
    {
    	hr = pCSchema->FInit(cProperties, rgProperties, riid, pUnkOuter, ppIRowset,wcsSpecificTable);
        if( S_OK == hr )
        {
            (*ppIRowset)->AddRef();
        }

        //===================================================
    	// Release our reference.
        //===================================================
    	pCSchema->Release();
    }
	else
	{
		hr = E_OUTOFMEMORY;
	}

	return hr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Return an array of guids for supported schemas.
//
//Bug No: NTRaid 126631
// 06/13/00
////////////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CImpIDBSchemaRowset::GetSchemas( ULONG *pcSchemas, GUID **ppSchemas, ULONG **prgRestrictionSupport	)
{
	GUID	*pSchemas;
	ULONG	*pRestrictionSupport;
	ULONG	cSchemas;

    //===================================================
	// Serialize access to this object.
    //===================================================
//	m_pCDBSession->GetCriticalSection();

	g_pCError->ClearErrorInfo();

	if (pcSchemas)
		*pcSchemas = 0;
	if (ppSchemas)
		*ppSchemas = NULL;
	if (prgRestrictionSupport)
		*prgRestrictionSupport = NULL;

    //===================================================
	// Check per spec.
    //===================================================
    if (pcSchemas == NULL || ppSchemas == NULL || prgRestrictionSupport == NULL)
    {
		return g_pCError->PostHResult((E_INVALIDARG), &IID_IDBSchemaRowset);
	}

	cSchemas = NUMBER_OF_SCHEMAS;
	pSchemas = (GUID*) g_pIMalloc->Alloc(sizeof(GUID) * cSchemas);
	if (NULL == pSchemas)
    {
		return g_pCError->PostHResult((E_OUTOFMEMORY),&IID_IDBSchemaRowset);
	}
	pRestrictionSupport = (ULONG*)g_pIMalloc->Alloc(sizeof(ULONG) * cSchemas);
	
	if (NULL == pRestrictionSupport)
    {
		g_pIMalloc->Free(pSchemas);
		return g_pCError->PostHResult((E_OUTOFMEMORY),&IID_IDBSchemaRowset);
	}

	*ppSchemas  = pSchemas;
	*pSchemas++ = DBSCHEMA_CATALOGS;
	*pSchemas++ = DBSCHEMA_PROVIDER_TYPES;
	*pSchemas++ = DBSCHEMA_COLUMNS;
	*pSchemas++ = DBSCHEMA_TABLES;
	*pSchemas++ = DBSCHEMA_PRIMARY_KEYS;
	*pSchemas++ = DBSCHEMA_TABLES_INFO;
	*pSchemas++ = DBSCHEMA_PROCEDURES;
	*pSchemas++ = DBSCHEMA_PROCEDURE_PARAMETERS;


	if( prgRestrictionSupport != NULL)
	{
		*prgRestrictionSupport = pRestrictionSupport;
		*pRestrictionSupport++ = eSup_CATALOGS;
		*pRestrictionSupport++ = eSup_PROVIDER_TYPES;
		*pRestrictionSupport++ = eSup_COLUMNS;
		*pRestrictionSupport++ = eSup_TABLES;
		*pRestrictionSupport++ = eSup_PRIMARY_KEYS;
		*pRestrictionSupport++ = eSup_TABLES_INFO;
		*pRestrictionSupport++ = eSup_PROCEDURES;
		*pRestrictionSupport++ = eSup_PROCEDURE_PARAMETERS;
	}

    //===================================================
	// Set the number of schemas we have recorded.
    //===================================================
	*pcSchemas = cSchemas;
	return S_OK;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//***********************************************************************************************************
//
//      Class Schema definition 
//
//***********************************************************************************************************
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaClassDefinitionWrapper::CWbemSchemaClassDefinitionWrapper(CWbemClassParameters * p) : 
                    CWbemClassDefinitionWrapper(p)
{
    m_nSchemaClassIndex = 0;
    m_nMaxColumns		= 0;
	m_bSchema			= TRUE;

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaClassDefinitionWrapper::~CWbemSchemaClassDefinitionWrapper()
{
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaClassDefinitionWrapper::ValidClass( )
{
    return S_OK;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaClassDefinitionWrapper::TotalPropertiesInClass(ULONG & ulPropCount, ULONG & ulSysPropCount )
{
    ulPropCount = m_nMaxColumns;
    ulSysPropCount = 0;
    return S_OK;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaClassDefinitionWrapper::BeginPropertyEnumeration()
{
    m_nSchemaClassIndex = 0;
    return S_OK;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaClassDefinitionWrapper::EndPropertyEnumeration()
{
    m_nSchemaClassIndex = 0;
    return S_OK;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
// return failed, because we don't support the property qualifier enumeration
HRESULT CWbemSchemaClassDefinitionWrapper::BeginPropertyQualifierEnumeration(BSTR strPropName)
{
    return WBEM_S_NO_MORE_DATA;
}

//////////////////////////////////////////////////////////////////////////////////////////////////
//************************************************************************************************
//
//  Deal with a Schema class instance
//
//************************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaClassInstanceWrapper::CWbemSchemaClassInstanceWrapper( CWbemClassParameters * p ): CWbemClassInstanceWrapper(p)
{
    m_uCurrentIndex = 0;
    m_nMaxColumns = 0;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaClassInstanceWrapper::~CWbemSchemaClassInstanceWrapper( )
{
}


//////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaClassInstanceWrapper::GetClassProperty(WCHAR * wcsProperty, VARIANT * v, CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr;

    BSTR bProp;
	bProp = Wmioledb_SysAllocString(wcsProperty);
    hr = GetProperty(bProp,v,pType,plFlavor);
    SysFreeString(bProp);
    return hr;
}

//////////////////////////////////////////////////////////////////////////////////////////////////
void CWbemSchemaClassInstanceWrapper::AddToKeyList(WCHAR *& pwcsKeyList, WCHAR * wcsKey )
{
    WCHAR * pTmp = NULL;

    if( !pwcsKeyList ){
        pwcsKeyList = new WCHAR[wcslen(wcsKey) + 1];
        wcscpy(pwcsKeyList,wcsKey);
    }
    else{
        pTmp = new WCHAR[wcslen(pwcsKeyList) + wcslen(wcsKey) + 10];
        swprintf(pTmp,L"%s,%s",pwcsKeyList,wcsKey);
        SAFE_DELETE_PTR(pwcsKeyList);
        pwcsKeyList = pTmp;
    }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//***********************************************************************************************************
//      Class Schema Instance List
//***********************************************************************************************************
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaInstanceList::CWbemSchemaInstanceList(CWbemClassParameters * p) : CWbemInstanceList(p)
{
    m_ulMaxRow = 0;
    m_fGotThemAll = FALSE;
    m_pSpecificClass = NULL;
    m_pwcsSpecificClass = NULL;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaInstanceList::CWbemSchemaInstanceList(CWbemClassParameters * p,WCHAR * pSpecific) : CWbemInstanceList(p)
{
    m_pSpecificClass = NULL;
    m_ulMaxRow = 0;
    m_fGotThemAll = FALSE;
    m_pwcsSpecificClass = pSpecific;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaInstanceList::~CWbemSchemaInstanceList()
{
    ResetTheSpecificClass();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaInstanceList::ResetTheSpecificClass()
{
    m_fGotThemAll = FALSE;
    SAFE_RELEASE_PTR(m_pSpecificClass);
    return S_OK;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaInstanceList::GetTheSpecificClass()
{
    HRESULT hr = WBEM_S_NO_MORE_DATA;
    if( !m_fGotThemAll )
    {
        hr = (m_pParms->GetServicesPtr())->GetObject(m_pwcsSpecificClass, 0, NULL, &m_pSpecificClass, NULL);
        m_fGotThemAll = TRUE;
    }
    return hr;
}
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
//
//  Classes for the Sources schema rowset
//
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaSourcesClassDefinitionWrapper::CWbemSchemaSourcesClassDefinitionWrapper(CWbemClassParameters * p) : CWbemSchemaClassDefinitionWrapper(p)
{
    
    m_nMaxColumns = sizeof(g_SourcesRowsetColumns)/sizeof(SchemaRowsetDefinition);
}

//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaSourcesClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr = S_OK;

    //===============================================================================
    //  See if we got all of the column info
    //===============================================================================
    if( m_nSchemaClassIndex == m_nMaxColumns )
    {
        return WBEM_S_NO_MORE_DATA;
    }

    //===============================================================================
    //  Get the column name and data type
    //===============================================================================
    *pType = g_SourcesRowsetColumns[m_nSchemaClassIndex].Type;
    *pProperty = Wmioledb_SysAllocString(g_SourcesRowsetColumns[m_nSchemaClassIndex].wcsColumnName);

    m_nSchemaClassIndex++;

    return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaSourcesInstanceWrapper::GetSchemaProperty( WCHAR * pProperty, VARIANT * v,CIMTYPE * pType , LONG * plFlavor)
{

    HRESULT hr = S_OK;

   ((CVARIANT*)v)->Clear();
   *plFlavor = 0;
    int i = 0;

    //=============================================================
    // SOURCES_NAME
    //=============================================================
   
    if( _wcsicmp(pProperty,g_SourcesRowsetColumns[0].wcsColumnName) == 0 )
    {
        hr = GetClassProperty(L"Name",v,pType,plFlavor);
    }
    //=============================================================
    // SOURCES_PARSENAME
    //=============================================================
    else if( _wcsicmp(pProperty,g_SourcesRowsetColumns[1].wcsColumnName) == 0 )
    {
       hr = GetClassProperty(L"__PATH",v,pType,plFlavor);
    }
    else
    { 
       //=============================================================
       //  Initialize the common stuff for these last column types
       //=============================================================
       *plFlavor = 0;

       //=============================================================
       // SOURCES_DESCRIPTION
       //=============================================================
       if( _wcsicmp(pProperty,g_SourcesRowsetColumns[2].wcsColumnName) == 0 ){
            *pType = CIM_STRING;
            ((CVARIANT*)v)->SetStr(L"N/A");
       }            
       //=============================================================
       // SOURCES_TYPE
       //=============================================================
       else if( _wcsicmp(pProperty,g_SourcesRowsetColumns[3].wcsColumnName) == 0 ){
            *pType = CIM_UINT16;
            ((CVARIANT*)v)->SetShort(DBSOURCETYPE_DATASOURCE);
       }
       //=============================================================
       // SOURCES_ISPARENT
       //=============================================================
       else if( _wcsicmp(pProperty,g_SourcesRowsetColumns[4].wcsColumnName) == 0 ){
            *pType = CIM_BOOLEAN;
            ((CVARIANT*)v)->SetBool(VARIANT_FALSE);
       }
       else{
           hr = E_INVALIDARG;
       }
    }

    return MapWbemErrorToOLEDBError(hr);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaSourcesInstanceList::Reset()
{
    HRESULT hr = E_UNEXPECTED;
    LONG lFlags = WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY;

    //============================================================
    //  Send off the query for "Select Name from __Namespace
    //============================================================
    if( m_ppEnum )
    {
        hr = m_ppEnum->Reset();
        ReleaseAllInstances();
    }
    else
    {
         hr = (m_pParms->GetServicesPtr())->ExecQuery(CBSTR((WCHAR *)szWQL),CBSTR(L"select * from __Namespace"), WBEM_FLAG_FORWARD_ONLY,m_pParms->m_pConnection->GetContext(),&m_ppEnum);
    }
	m_lCurrentPos = 0;

    return MapWbemErrorToOLEDBError(hr);
}

//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
//
//  Classes for the Provider Types schema rowset
//
//////////////////////////////////////////////////////////////////////////////////////////////
//********************************************************************************************
CWbemSchemaProviderTypesClassDefinitionWrapper::CWbemSchemaProviderTypesClassDefinitionWrapper(CWbemClassParameters * p) : CWbemSchemaClassDefinitionWrapper(p) 
{
    
    m_nMaxColumns = sizeof(g_ProviderTypes)/sizeof(SchemaRowsetDefinition);
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProviderTypesClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr = S_OK;

    //===============================================================================
    //  See if we got all of the column info
    //===============================================================================
    if( m_nSchemaClassIndex == m_nMaxColumns )
    {
        return WBEM_S_NO_MORE_DATA;
    }

    //===============================================================================
    //  Get the column name and data type
    //===============================================================================
    *pType = g_ProviderTypes[m_nSchemaClassIndex].Type;
    *pProperty = Wmioledb_SysAllocString(g_ProviderTypes[m_nSchemaClassIndex].wcsColumnName);
    m_nSchemaClassIndex++;

    return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProviderTypesInstanceWrapper::ResetInstanceFromKey(CBSTR Key)
{
    return S_OK;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProviderTypesInstanceWrapper::RefreshInstance()
{
    return S_OK;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
WCHAR *  CWbemSchemaProviderTypesInstanceWrapper::GetClassName()
{
     return L"PROVIDER_TYPES";
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProviderTypesInstanceWrapper::GetSchemaProperty( WCHAR * pProperty, VARIANT * vVar,CIMTYPE * pType , LONG * plFlavor)
{
    HRESULT hr = S_OK;

   ((CVARIANT*)vVar)->Clear();
   *plFlavor = 0;

    ULONG_PTR i = GetPos();

    //=============================================================
    // TYPE_NAME 
    //=============================================================
    if( _wcsicmp(pProperty,g_ProviderTypes[0].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
        ((CVARIANT*)vVar)->SetStr(g_ProviderTypeDetails[i].wcsTypeName);
    }
    //=============================================================
    // DATA_TYPE
    //=============================================================
    else if( _wcsicmp(pProperty,g_ProviderTypes[1].wcsColumnName) == 0 ){
        *pType = CIM_UINT16;
        ((CVARIANT*)vVar)->SetShort(g_ProviderTypeDetails[i].DataType);
    }
    //=============================================================
    // COLUMN_SIZE
    //=============================================================
    else if( _wcsicmp(pProperty,g_ProviderTypes[2].wcsColumnName) == 0 ){
        *pType = CIM_SINT32;
        ((CVARIANT*)vVar)->SetLONG(g_ProviderTypeDetails[i].ColumnSize);
    }
    //=============================================================
    // LITERAL_PREFIX, LITERAL_SUFFIX, CREATE_PARAMS
    //=============================================================
    else if(( _wcsicmp(pProperty,g_ProviderTypes[3].wcsColumnName) == 0 ) ||
            ( _wcsicmp(pProperty,g_ProviderTypes[4].wcsColumnName) == 0 ) ||
            ( _wcsicmp(pProperty,g_ProviderTypes[5].wcsColumnName) == 0 ) ){
        *pType = CIM_STRING;
        ((CVARIANT*)vVar)->SetStr(L"");
    }
    //=============================================================
    // IS_NULLABLE,CASE_SENSITIVE
    //=============================================================
    else if(( _wcsicmp(pProperty,g_ProviderTypes[6].wcsColumnName) == 0 ) ||
            ( _wcsicmp(pProperty,g_ProviderTypes[7].wcsColumnName) == 0 ) ){
        *pType = CIM_BOOLEAN;
        ((CVARIANT*)vVar)->SetBool(VARIANT_FALSE);
    }
    //=============================================================
    // SEARCHABLE
    //=============================================================
    else if( _wcsicmp(pProperty,g_ProviderTypes[8].wcsColumnName) == 0 ){
        *pType = CIM_UINT32;
        ((CVARIANT*)vVar)->SetLONG(0);
    }
    //=============================================================
    // UNSIGNED_ATTRIBUTE
    //=============================================================
    else if( _wcsicmp(pProperty,g_ProviderTypes[9].wcsColumnName) == 0 ){
        *pType = CIM_BOOLEAN;
        ((CVARIANT*)vVar)->SetShort((short)g_ProviderTypeDetails[i].UnsignedAttribute);
    }
    //=============================================================
    // FIXED_PREC_SCALE, AUTO_UNIQUE_VALUE
    //=============================================================
    else if(( _wcsicmp(pProperty,g_ProviderTypes[10].wcsColumnName) == 0 ) ||
            ( _wcsicmp(pProperty,g_ProviderTypes[11].wcsColumnName) == 0 ) ){
        *pType = CIM_BOOLEAN;
        ((CVARIANT*)vVar)->SetBool(VARIANT_FALSE);
    }
    //=============================================================
    // LOCAL_TYPE_NAME
    //=============================================================
    else if( _wcsicmp(pProperty,g_ProviderTypes[12].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
        ((CVARIANT*)vVar)->SetStr(L"");
    }
    //=============================================================
    // MINIMUM_SCALE, MAXIMUM_SCALE
    //=============================================================
    else if(( _wcsicmp(pProperty,g_ProviderTypes[13].wcsColumnName) == 0 ) || 
            ( _wcsicmp(pProperty,g_ProviderTypes[14].wcsColumnName) == 0 )){
        *pType = CIM_SINT16;
        ((CVARIANT*)vVar)->SetShort(0);
    }
    //=============================================================
    // GUID
    //=============================================================
    else if( _wcsicmp(pProperty,g_ProviderTypes[15].wcsColumnName) == 0 ){
        *pType = DBTYPE_GUID;
		((CVARIANT*)vVar)->Clear();
    }
    //=============================================================
    // TYPELIB
    //=============================================================
    else if( _wcsicmp(pProperty,g_ProviderTypes[16].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
        ((CVARIANT*)vVar)->SetStr(L"");
    }
    //=============================================================
    // VERSION
    //=============================================================
    else if( _wcsicmp(pProperty,g_ProviderTypes[17].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
        ((CVARIANT*)vVar)->SetStr(L"");
    }
        //=============================================================
        // IS_LONG for CIM_STRING which will be BSTR
        //=============================================================
		else if( ( _wcsicmp(pProperty,g_ProviderTypes[18].wcsColumnName) == 0 ) &&
			g_ProviderTypeDetails[i].DataType == DBTYPE_BSTR)
		{
            *pType = CIM_BOOLEAN;
            ((CVARIANT*)vVar)->SetBool(TRUE);
		}
        //=============================================================
        // IS_FIXEDLENGTH for CIM_STRING be FALSE
        //=============================================================
		else if( ( _wcsicmp(pProperty,g_ProviderTypes[20].wcsColumnName) == 0 ) &&
			g_ProviderTypeDetails[i].DataType == DBTYPE_BSTR)
		{
            *pType = CIM_BOOLEAN;
            ((CVARIANT*)vVar)->SetBool(FALSE);
		}
        //=============================================================
        // IS_FIXEDLENGTH for all types apart from CIM_STRING TRUE
        //=============================================================
		else if( ( _wcsicmp(pProperty,g_ProviderTypes[20].wcsColumnName) == 0 ) &&
			g_ProviderTypeDetails[i].DataType != DBTYPE_BSTR )
		{
            *pType = CIM_BOOLEAN;
            ((CVARIANT*)vVar)->SetBool(TRUE);
		}
        //=============================================================
        // IS_LONG, BEST_MATCH
        //=============================================================
        else if(( _wcsicmp(pProperty,g_ProviderTypes[18].wcsColumnName) == 0 ) ||
                ( _wcsicmp(pProperty,g_ProviderTypes[19].wcsColumnName) == 0 ) ) {
            *pType = CIM_BOOLEAN;
            ((CVARIANT*)vVar)->SetBool(FALSE);
        }
/*		//=============================================================
    // IS_LONG, BEST_MATCH, IS_FIXEDLENGTH
    //=============================================================
    else if(( _wcsicmp(pProperty,g_ProviderTypes[18].wcsColumnName) == 0 ) ||
            ( _wcsicmp(pProperty,g_ProviderTypes[19].wcsColumnName) == 0 ) ||
            ( _wcsicmp(pProperty,g_ProviderTypes[20].wcsColumnName) == 0 )) {
        *pType = CIM_BOOLEAN;
        ((CVARIANT*)vVar)->SetBool(VARIANT_FALSE);
    }
	*/
    //=============================================================
    // INVALID_ARG
    //=============================================================
    else{
        hr = E_INVALIDARG;
    }
    return MapWbemErrorToOLEDBError(hr);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProviderTypesInstanceWrapper::GetKey(CBSTR & Key)
{
    HRESULT hr = S_OK;

    Key.SetStr(g_ProviderTypeDetails[GetPos()].wcsTypeName);
    return hr;    
}
//////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProviderTypesInstanceList::Reset()
{
    HRESULT hr = E_UNEXPECTED;
    LONG lFlags = WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY;

    //============================================================
    //  Send off the query for "Select Name from __Namespace
    //============================================================
    if( m_ppEnum ){
        hr = m_ppEnum->Reset();
        ReleaseAllInstances();
    }
    else
    {
        m_ulMaxRow = sizeof(g_ProviderTypeDetails)/sizeof(CIMTypeInfo);
        hr = S_OK;  // hardcoded rowset
    }
	m_lCurrentPos = 0;

    return MapWbemErrorToOLEDBError(hr);
}

////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProviderTypesInstanceList::NextInstance( CBSTR & Key, CWbemClassInstanceWrapper ** pInst  )
{
    HRESULT hr = E_FAIL;

    if( m_lCurrentPos < m_ulMaxRow )
    { 
		*pInst = new CWbemSchemaProviderTypesInstanceWrapper(m_pParms);
		// NTRaid:136533
		// 07/05/00
		if(*pInst)
		{
			(*pInst)->SetPos(++m_lCurrentPos);
			AddInstance(*pInst);
			(*pInst)->GetKey(Key);
			hr = S_OK;
		}
		else
		{
			hr = E_OUTOFMEMORY;
		}
    }
    else
    {
        hr = WBEM_S_NO_MORE_DATA;
    }

    return hr;
}

//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
//
//  Classes for the Catalogs schema rowset
//
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaCatalogsClassDefinitionWrapper::CWbemSchemaCatalogsClassDefinitionWrapper(CWbemClassParameters * p) : CWbemSchemaClassDefinitionWrapper(p) 
{
    m_nMaxColumns = sizeof(g_CatalogRowsetColumns)/sizeof(SchemaRowsetDefinition);
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaCatalogsClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr = S_OK;

    //===============================================================================
    //  See if we got all of the column info
    //===============================================================================
    if( m_nSchemaClassIndex == m_nMaxColumns )
    {
        return WBEM_S_NO_MORE_DATA;
    }

    *pType = g_CatalogRowsetColumns[m_nSchemaClassIndex].Type;
    *pProperty = Wmioledb_SysAllocString(g_CatalogRowsetColumns[m_nSchemaClassIndex].wcsColumnName);
    m_nSchemaClassIndex++;

    return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaCatalogsInstanceWrapper::GetSchemaProperty( WCHAR * pProperty, VARIANT * v,CIMTYPE * pType , LONG * plFlavor)
{
    HRESULT hr = S_OK;

   ((CVARIANT*)v)->Clear();
   *plFlavor = 0;

   //=============================================================
   // CATALOG_NAME
   //=============================================================
   if( _wcsicmp(pProperty,g_CatalogRowsetColumns[0].wcsColumnName) == 0 ){
        hr = m_pClass->Get(CBSTR(L"Name"),0,(VARIANT *)v,pType,plFlavor);
   }
   //=============================================================
    // SOURCES_DESCRIPTION
   //=============================================================
   else if( _wcsicmp(pProperty,g_CatalogRowsetColumns[1].wcsColumnName) == 0 ){

       *plFlavor = 0;
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(L"N/A");
   }            
   return MapWbemErrorToOLEDBError(hr);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaCatalogsInstanceList::Reset()
{
    HRESULT hr = E_UNEXPECTED;
    LONG lFlags = WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY;

    //============================================================
    //  Send off the query for "Select Name from __Namespace
    //============================================================
    if( m_ppEnum )
    {
        hr = m_ppEnum->Reset();
        ReleaseAllInstances();
    }
    else
    {
        hr = (m_pParms->GetServicesPtr())->ExecQuery(CBSTR((WCHAR *)szWQL),CBSTR(L"select * from __Namespace"),  WBEM_FLAG_FORWARD_ONLY,m_pParms->m_pConnection->GetContext(),&m_ppEnum);
    }
	m_lCurrentPos = 0;

    return MapWbemErrorToOLEDBError(hr);
}
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
//
//  Classes for the COlumns schema rowset
//
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaColumnsClassDefinitionWrapper::CWbemSchemaColumnsClassDefinitionWrapper(CWbemClassParameters * p) : CWbemSchemaClassDefinitionWrapper(p) 
{
    
    m_nMaxColumns = sizeof(g_ColumnsRowsetColumns)/sizeof(SchemaRowsetDefinition);
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaColumnsClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr = S_OK;

    //===============================================================================
    //  See if we got all of the column info
    //===============================================================================
    if( m_nSchemaClassIndex == m_nMaxColumns )
    {
        return WBEM_S_NO_MORE_DATA;
    }

    *pType = g_ColumnsRowsetColumns[m_nSchemaClassIndex].Type;
    *pProperty = Wmioledb_SysAllocString(g_ColumnsRowsetColumns[m_nSchemaClassIndex].wcsColumnName);

    m_nSchemaClassIndex++;

    return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaColumnsInstanceWrapper::GetSchemaProperty( WCHAR * pProperty, VARIANT * v,CIMTYPE * pType , LONG * plFlavor)
{
   HRESULT hr = S_OK;

   ((CVARIANT*)v)->Clear();
   *plFlavor = 0;

   //=============================================================
   // TABLE_CATALOG
   //=============================================================
   if( wcscmp(pProperty,g_ColumnsRowsetColumns[0].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(m_pParms->m_pConnection->GetNamespace());
   }
   //=============================================================
    // TABLE_SCHEMA
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[1].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
   }            
   //=============================================================
    // TABLE_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[2].wcsColumnName) == 0 ){

       ((CVARIANT*)v)->SetStr(m_pParms->m_pwcsParentClassName);
   }            
   //=============================================================
    // COLUMN_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[3].wcsColumnName) == 0 ){
       *pType = CIM_STRING;

		DBCOLUMNINFO * pCol = m_pColumns->GetColInfo(m_uCurrentIndex);
        ((CVARIANT*)v)->SetStr(pCol->pwszName);
   }            
   //=============================================================
    // COLUMN_GUID
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[4].wcsColumnName) == 0 ){
        *pType = DBTYPE_GUID;
   }
   //=============================================================
    // COLUMN_PROPID
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[5].wcsColumnName) == 0 ){
        *pType = CIM_UINT32;
   }
   //=============================================================
    // ORDINAL_POSITION
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[6].wcsColumnName) == 0 ){
        *pType = CIM_UINT32;
		DBCOLUMNINFO * pCol = m_pColumns->GetColInfo(m_uCurrentIndex);
        ((CVARIANT*)v)->SetLONG((LONG)pCol->iOrdinal);
   }
   //=============================================================
    // COLUMN_HASDEFAULT
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[7].wcsColumnName) == 0 ){
        *pType = CIM_BOOLEAN;
		((CVARIANT*)v)->SetBool(VARIANT_FALSE);
   }
   //=============================================================
    // COLUMN_DEFAULT
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[8].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
    // COLUMN_FLAGS
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[9].wcsColumnName) == 0 ){
        *pType = CIM_UINT32;

		DBCOLUMNINFO * pCol = m_pColumns->GetColInfo(m_uCurrentIndex);
		((CVARIANT*)v)->SetLONG(pCol->dwFlags);
   }
   //=============================================================
    // IS_NULLABLE
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[10].wcsColumnName) == 0 ){
        *pType = CIM_BOOLEAN;
        ((CVARIANT*)v)->SetBool(VARIANT_TRUE);
   }
   //=============================================================
    // DATA_TYPE
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[11].wcsColumnName) == 0 ){
        *pType = CIM_UINT16;

		DBCOLUMNINFO * pCol = m_pColumns->GetColInfo(m_uCurrentIndex);
		((CVARIANT*)v)->SetLONG(pCol->wType);
   }
   //=============================================================
    // TYPE_GUID
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[12].wcsColumnName) == 0 ){
        *pType = DBTYPE_GUID;
   }
   //=============================================================
    // CHARACTER_MAXIMUM_LENGTH
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[13].wcsColumnName) == 0 )
   {
        *pType = CIM_UINT32;  
   }
   //=============================================================
    // CHARACTER_OCTET_LENGTH
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[14].wcsColumnName) == 0 ){
        *pType = CIM_UINT32;
   }
   //=============================================================
    // NUMERIC_PRECISION
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[15].wcsColumnName) == 0 ){
        *pType = CIM_UINT16;
		DBCOLUMNINFO * pCol = m_pColumns->GetColInfo(m_uCurrentIndex);
        ((CVARIANT*)v)->SetShort(pCol->bPrecision);
   }
   //=============================================================
    // NUMERIC_SCALE
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[16].wcsColumnName) == 0 ){
        *pType = CIM_SINT16;

		DBCOLUMNINFO * pCol = m_pColumns->GetColInfo(m_uCurrentIndex);
        ((CVARIANT*)v)->SetShort(pCol->bScale);
   }
   //=============================================================
   // DATETIME_PRECISION
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[17].wcsColumnName) == 0 ){
        *pType = CIM_UINT32;
   }
   //=============================================================
   // CHARACTER_SET_CATALOG
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[18].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
   // CHARACTER_SET_SCHEMA
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[19].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
   // CHARACTER_SET_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[20].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
   // COLLATION_CATALOG
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[21].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
   // COLLATION_SCHEMA
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[22].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
   // COLLATION_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[23].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
   // DOMAIN_CATALOG
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[24].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
   // DOMAIN_SCHEMA
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[25].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
   // DOMAIN_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[26].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   //=============================================================
   // DESCRIPTION
   //=============================================================
   else if( _wcsicmp(pProperty,g_ColumnsRowsetColumns[27].wcsColumnName) == 0 ){
        *pType = CIM_STRING;
   }
   

    return MapWbemErrorToOLEDBError(hr);
}
//////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaColumnsInstanceWrapper::GetKey(CBSTR & Key)
{
    HRESULT hr = S_OK;


    if( m_pColumns )
    {
        //============================================================
        // the key is the combo of the table name and column name
        //============================================================
    	DBCOLUMNINFO * pCol = m_pColumns->GetColInfo(m_uCurrentIndex);
        if( pCol )
        {

            WCHAR * p = new WCHAR [wcslen(pCol->pwszName) + wcslen(m_pParms->m_pwcsParentClassName) + 4 ];
            if( p )
            {
                swprintf(p, L"%s:%s", m_pParms->m_pwcsParentClassName,pCol->pwszName);
                Key.SetStr(p);
                delete p;  
            }
        }
    }
    return hr;    
}

///////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaColumnsInstanceList::Reset()
{
    HRESULT hr = E_UNEXPECTED;
    //============================================================
    //  If we are working with just one class, then get the one
    //  class, otherwise enumerate all
    //============================================================
    if( m_pwcsSpecificClass)
    {
        hr = ResetTheSpecificClass();
    }
    else
    {

        LONG lFlags = WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY;

        //============================================================
        //  Send off the query for "Select Name from __Namespace
        //============================================================
        if( m_ppEnum )
        {
            hr = m_ppEnum->Reset();
            ReleaseAllInstances();
        }
        else
        {
            hr = (m_pParms->GetServicesPtr())->CreateClassEnum(NULL,  WBEM_FLAG_FORWARD_ONLY,m_pParms->m_pConnection->GetContext(),&m_ppEnum);
        }
    }
	m_lCurrentPos = 0;

    return MapWbemErrorToOLEDBError(hr);
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaColumnsInstanceList::GetColumnInformation(CWbemClassInstanceWrapper * p )
{
    HRESULT hr = E_FAIL;
    DBCOUNTITEM cTotalCols, cCols, cNestedCols;

    FreeColumns();

    CWmiOleDBMap Map;
    if(SUCCEEDED(hr = Map.FInit(m_pParms->m_dwFlags,p->GetClassName(),m_pParms->m_pConnection)))
	{
		hr = Map.GetColumnCount(cTotalCols,cCols,cNestedCols);
		if( S_OK == hr ){
			if( S_OK == (hr = m_Columns.AllocColumnNameList(cTotalCols))){

				//===============================================================================
				//  Allocate the DBCOLUMNINFO structs to match the number of columns
				//===============================================================================
				if( S_OK == (hr = m_Columns.AllocColumnInfoList(cTotalCols))){

					hr = Map.GetColumnInfoForParentColumns(&m_Columns);
					if( hr == S_OK ){
						//==============================================================
						// Increment past the bookmark column
						//==============================================================
						m_lColumnIndex = 1;
						((CWbemSchemaColumnsInstanceWrapper*)p)->SetColumnsPtr(&m_Columns);
						((CWbemSchemaColumnsInstanceWrapper*)p)->SetIndex(m_lColumnIndex);
					}
				}
			}
		}
	}

    return hr;
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaColumnsInstanceList::NextInstance( CBSTR & Key, CWbemClassInstanceWrapper ** pInst  )
{
    HRESULT hr = E_FAIL;
    long ulTotal;

    ulTotal = (LONG)m_Columns.GetTotalNumberOfColumns();
    m_lColumnIndex++;

    if( m_lColumnIndex  >= ulTotal )
    {
        //================================================================
        //  If we are working with a specific class, then use it, other
        //  wise, enumerate the next one
        //================================================================
        if( !m_pwcsSpecificClass)
        {
            hr = CWbemInstanceList::NextInstance(Key,pInst);
            if( S_OK == hr )
            {
                CVARIANT v;
                CIMTYPE Type;
                LONG lFlavor;
                if( S_OK == (hr = ((CWbemSchemaColumnsInstanceWrapper*)*pInst)->GetClassProperty(L"__CLASS",&v,&Type,&lFlavor)))
                {
                    //  Now, save it in Parameters for the generated ones
                    m_pParms->SetParentClassName(v.GetStr());

                    hr = GetColumnInformation(*pInst);
                    if( S_OK == hr )
                    {
                        //==========================================
                        // We don't want to display the bookmark
                        // column.
                        //==========================================
                        ulTotal = (LONG)m_Columns.GetTotalNumberOfColumns();

                        if( m_lColumnIndex == ulTotal )
                        {
                            hr = NextInstance(Key,pInst);
                        }
                   }
                   hr = ((CWbemSchemaColumnsInstanceWrapper*)*pInst)->GetKey(Key);
                }
            }        
        }
        else
        {
            hr = GetTheSpecificClass();
            if( S_OK == hr )
            {
                *pInst = (CWbemSchemaClassInstanceWrapper *) new CWbemSchemaColumnsInstanceWrapper(m_pParms);
                if( *pInst )
                {
                    ((CWbemSchemaColumnsInstanceWrapper*)*pInst)->SetClass(m_pSpecificClass);

                    CVARIANT v;
                    CIMTYPE Type;
                    LONG lFlavor;
 
                    if( S_OK == (hr = ((CWbemSchemaColumnsInstanceWrapper*)*pInst)->GetClassProperty(L"__CLASS",&v,&Type,&lFlavor)))
                    {

                        m_pParms->SetParentClassName(v.GetStr());
                        if( SUCCEEDED(hr))
                        {
                            hr = GetColumnInformation(*pInst);
                            ulTotal = (LONG)m_Columns.GetTotalNumberOfColumns();
                            //===================================================================
                            //  This class does't have any columns
                            //===================================================================
                            if( m_lColumnIndex == ulTotal )
                            {
                                hr = WBEM_S_NO_MORE_DATA;
                            }

                            if( S_OK == hr)
                            {
                                hr = ((CWbemSchemaColumnsInstanceWrapper*)*pInst)->GetKey(Key);
            			        (*pInst)->SetPos(++m_lCurrentPos);
                                ((CWbemSchemaColumnsInstanceWrapper*)*pInst)->SetColumnsPtr(&m_Columns);
                                ((CWbemSchemaColumnsInstanceWrapper*)*pInst)->SetIndex(m_lColumnIndex);
			                    AddInstance(*pInst);
                            }
                        }
                    }
                }
            }

        }
    }
    else
    {
        *pInst = (CWbemSchemaClassInstanceWrapper *) new CWbemSchemaColumnsInstanceWrapper(m_pParms);
        if( *pInst )
        {
			(*pInst)->SetPos(++m_lCurrentPos);
            ((CWbemSchemaColumnsInstanceWrapper*)*pInst)->SetColumnsPtr(&m_Columns);
            ((CWbemSchemaColumnsInstanceWrapper*)*pInst)->SetIndex(m_lColumnIndex);
			(*pInst)->GetKey(Key);
			AddInstance(*pInst);
            hr = S_OK;
        }
    }
    return hr;
}
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
//
//  Classes for the Tables schema rowset
//
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaTablesClassDefinitionWrapper::CWbemSchemaTablesClassDefinitionWrapper(CWbemClassParameters * p) : CWbemSchemaClassDefinitionWrapper(p) 
{
    
    m_nMaxColumns = sizeof(g_Tables)/sizeof(SchemaRowsetDefinition);
}

//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaTablesClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr = S_OK;

    //===============================================================================
    //  See if we got all of the column info
    //===============================================================================
    if( m_nSchemaClassIndex == m_nMaxColumns )
    {
        return WBEM_S_NO_MORE_DATA;
    }

    *pType = g_Tables[m_nSchemaClassIndex].Type;
    *pProperty = Wmioledb_SysAllocString(g_Tables[m_nSchemaClassIndex].wcsColumnName);
    m_nSchemaClassIndex++;

    return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaTablesInstanceWrapper::GetSchemaProperty( WCHAR * pProperty, VARIANT * v,CIMTYPE * pType , LONG * plFlavor)
{
   HRESULT hr = S_OK;

   ((CVARIANT*)v)->Clear();
   *plFlavor = 0;
  
   //=============================================================
   // TABLE_CATALOG
   //=============================================================
   if( _wcsicmp(pProperty,g_Tables[0].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(m_pParms->m_pConnection->GetNamespace());
   }
   //=============================================================
   // TABLE_SCHEMA
   //=============================================================
   else if( _wcsicmp(pProperty,g_Tables[1].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
   }            
   //=============================================================
   // TABLE_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_Tables[2].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       hr = GetClassProperty(L"__CLASS",v,pType,plFlavor);
   }            
   //=============================================================
   // TABLE_TYPE
   //   This is either "TABLE" or "SYSTEM TABLE"
   //=============================================================
   else if( _wcsicmp(pProperty,g_Tables[3].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       CVARIANT Var;
       hr = GetClassProperty(L"__CLASS",&Var,pType,plFlavor);
       if( S_OK == hr ){
            WCHAR * p = NULL;
			p = Var.GetStr();
			// NTRaid:136462 & 136466
			// 07/05/00
			if(p != NULL || VT_BSTR != Var.GetType())
			{
				if( wcsncmp( p, L"__",2) == 0 ){
					((CVARIANT*)v)->SetStr(L"SYSTEM TABLE");
				}
				else{
					((CVARIANT*)v)->SetStr(L"TABLE");
				}
			}
			else
			{
				hr = E_UNEXPECTED; 
			}
       }
   }            
   //=============================================================
   // TABLE_GUID
   //=============================================================
   else if( _wcsicmp(pProperty,g_Tables[4].wcsColumnName) == 0 ){
       *pType = DBTYPE_GUID;
   }            
   //=============================================================
   // TABLE_DESCRIPTION
   //=============================================================
   else if( _wcsicmp(pProperty,g_Tables[5].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       hr = GetClassQualifier(L"Description",v,pType,plFlavor);
   }            
   //=============================================================
   // TABLE_PROPID
   //=============================================================
   else if( _wcsicmp(pProperty,g_Tables[6].wcsColumnName) == 0 ){
       *pType = CIM_UINT32;
   }
   //=============================================================
   // DATE_CREATED, DATE_MODIFIED
   //=============================================================
   else if( _wcsicmp(pProperty,g_Tables[7].wcsColumnName) == 0 ){
       *pType = DBTYPE_DATE;
   }

    return MapWbemErrorToOLEDBError(hr);
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaTablesInstanceList::NextInstance( CBSTR & Key, CWbemClassInstanceWrapper ** pInst  )
{
    HRESULT hr = S_OK;

    if( !m_pwcsSpecificClass )
    {
        return CWbemInstanceList::NextInstance(Key,pInst);
    }
        
    hr = GetTheSpecificClass();
    if( S_OK == hr )
    {
        *pInst = (CWbemSchemaTablesInstanceWrapper *) new CWbemSchemaTablesInstanceWrapper(m_pParms);
		// NTRaid:136526 , 136530
		// 07/05/00
		if(*pInst)
		{
			(*pInst)->SetClass(m_pSpecificClass);
			(*pInst)->SetPos(++m_lCurrentPos);
			AddInstance(*pInst);
			(*pInst)->GetKey(Key);
		}
		else
		{
			hr = E_OUTOFMEMORY;
		}
    }
    return hr;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaTablesInstanceList::Reset()
{
    HRESULT hr = E_UNEXPECTED;

    if( m_pwcsSpecificClass)
    {
        hr = ResetTheSpecificClass();
    }
    else
    {
        LONG lFlags = WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY;

        //============================================================
        //  Send off the query for "Select Name from __Namespace
        //============================================================
        if( m_ppEnum )
        {
            hr = m_ppEnum->Reset();
            ReleaseAllInstances();
        }
        else
        {
            hr = (m_pParms->GetServicesPtr())->CreateClassEnum(NULL,  WBEM_FLAG_FORWARD_ONLY,m_pParms->m_pConnection->GetContext(),&m_ppEnum);
        }
    }
	m_lCurrentPos = 0;

    return MapWbemErrorToOLEDBError(hr);
}

//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
//
//  Classes for the Primary Keys schema rowset
//
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaPrimaryKeysClassDefinitionWrapper::CWbemSchemaPrimaryKeysClassDefinitionWrapper(CWbemClassParameters * p) : CWbemSchemaClassDefinitionWrapper(p)
{
   
    m_nMaxColumns = sizeof(g_PrimaryKeysColumns)/sizeof(SchemaRowsetDefinition);
}
//////////////////////////////////////////////////////////////////////////////////////////////

HRESULT CWbemSchemaPrimaryKeysClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr = S_OK;

    //===============================================================================
    //  See if we got all of the column info
    //===============================================================================
    if( m_nSchemaClassIndex == m_nMaxColumns )
    {
        return WBEM_S_NO_MORE_DATA;
    }

    *pType = g_PrimaryKeysColumns[m_nSchemaClassIndex].Type;
    *pProperty = Wmioledb_SysAllocString(g_PrimaryKeysColumns[m_nSchemaClassIndex].wcsColumnName);
    m_nSchemaClassIndex++;

    return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaPrimaryKeysInstanceWrapper::GetSchemaProperty( WCHAR * pProperty, VARIANT * v,CIMTYPE * pType , LONG * plFlavor)
{
   HRESULT hr = S_OK;

   ((CVARIANT*)v)->Clear();
   *plFlavor = 0;
 
   //=============================================================
   // TABLE_CATALOG
   //=============================================================
   if( _wcsicmp(pProperty,g_PrimaryKeysColumns[0].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(m_pParms->m_pConnection->GetNamespace());
   }
   //=============================================================
   // TABLE_SCHEMA
   //=============================================================
   else if( _wcsicmp(pProperty,g_PrimaryKeysColumns[1].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
   }            
   //=============================================================
   // TABLE_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_PrimaryKeysColumns[2].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       hr = GetClassProperty(L"__CLASS",v,pType,plFlavor);
   }            
   //=============================================================
   // COLUMN_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_PrimaryKeysColumns[3].wcsColumnName) == 0 ){
        
        *pType = CIM_STRING;

    	LONG lFlavor = 0, lType = 0;
        CBSTR bstrPropQual(L"key");
        WCHAR * pList = NULL;

        if( S_OK == (hr = BeginPropertyEnumeration())){

            CBSTR bstrProperty;
            CVARIANT vValue;
  
            while( S_OK == (hr = GetNextProperty((BSTR*)&bstrProperty,(VARIANT *)&vValue, &lType, &lFlavor))){
                CVARIANT vKey;

                hr = CWbemClassWrapper::GetPropertyQualifier(bstrProperty,bstrPropQual,(VARIANT *)&vKey,&lType,&lFlavor);
                if( S_OK == hr ){
                    //===========================================================
                    //  Ok, we found a key, so start adding it.  There could be
                    //  multiple keys, so we still 
                    //===========================================================
                    AddToKeyList(pList,(WCHAR *)bstrProperty);
                }
            }
        }

        if ( WBEM_S_NO_MORE_DATA == hr ){
            hr = S_OK;
        }
        ((CVARIANT*)v)->SetStr(pList);
        SAFE_DELETE_PTR(pList);

	    EndPropertyEnumeration();
    }            
   //=============================================================
   // COLUMN_GUID
   //=============================================================
   else if( _wcsicmp(pProperty,g_PrimaryKeysColumns[4].wcsColumnName) == 0 ){
       *pType = DBTYPE_GUID;
   }            
   //=============================================================
   // COLUMN_PROPID
   //=============================================================
   else if( _wcsicmp(pProperty,g_PrimaryKeysColumns[5].wcsColumnName) == 0 ){
       *pType = CIM_UINT32;
   }            
   //=============================================================
   // ORDINAL
   //=============================================================
   else if( _wcsicmp(pProperty,g_PrimaryKeysColumns[6].wcsColumnName) == 0 ){
       *pType = CIM_UINT32;
   }
   //=============================================================
   // PK_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_PrimaryKeysColumns[7].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
   }

    return MapWbemErrorToOLEDBError(hr);
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaPrimaryKeysInstanceList::NextInstance( CBSTR & Key, CWbemClassInstanceWrapper ** pInst  )
{
    HRESULT hr = S_OK;

    if( !m_pwcsSpecificClass )
    {
        return CWbemInstanceList::NextInstance(Key,pInst);
    }
        
    hr = GetTheSpecificClass();
    if( S_OK == hr )
    {
        *pInst = (CWbemSchemaPrimaryKeysInstanceWrapper *) new CWbemSchemaPrimaryKeysInstanceWrapper(m_pParms);
		// NTRaid:136519 , 136522
		// 07/05/00
		if(*pInst)
		{
			(*pInst)->SetClass(m_pSpecificClass);
			(*pInst)->SetPos(++m_lCurrentPos);
			AddInstance(*pInst);
			(*pInst)->GetKey(Key);
		}
		else
		{
			hr = E_OUTOFMEMORY;
		}
    }
    return hr;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaPrimaryKeysInstanceList::Reset()
{
    HRESULT hr = E_UNEXPECTED;

    if( m_pwcsSpecificClass)
    {
        hr = ResetTheSpecificClass();
    }
    else
    {
        LONG lFlags = WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY;

        //============================================================
        //  Send off the query for "Select Name from __Namespace
        //============================================================
        if( m_ppEnum )
        {
            hr = m_ppEnum->Reset();
            ReleaseAllInstances();
        }
        else
        {
            hr = (m_pParms->GetServicesPtr())->CreateClassEnum(NULL,  WBEM_FLAG_FORWARD_ONLY,m_pParms->m_pConnection->GetContext(),&m_ppEnum);
        }
    }
	m_lCurrentPos = 0;

    return MapWbemErrorToOLEDBError(hr);
}

//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
//
//  Classes for the Tables Info schema rowset
//
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaTablesInfoClassDefinitionWrapper::CWbemSchemaTablesInfoClassDefinitionWrapper(CWbemClassParameters * p) : CWbemSchemaClassDefinitionWrapper(p) 
{
    
    m_nMaxColumns = sizeof(g_TablesInfo)/sizeof(SchemaRowsetDefinition);
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaTablesInfoClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr = S_OK;

    //===============================================================================
    //  See if we got all of the column info
    //===============================================================================
    if( m_nSchemaClassIndex == m_nMaxColumns )
    {
        return WBEM_S_NO_MORE_DATA;
    }

    *pType = g_TablesInfo[m_nSchemaClassIndex].Type;
    *pProperty = Wmioledb_SysAllocString(g_TablesInfo[m_nSchemaClassIndex].wcsColumnName);
    m_nSchemaClassIndex++;

    return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaTablesInfoInstanceWrapper::GetSchemaProperty( WCHAR * pProperty, VARIANT * v,CIMTYPE * pType , LONG * plFlavor)
{
   HRESULT hr = S_OK;

   ((CVARIANT*)v)->Clear();
   *plFlavor = 0;

  
   //=============================================================
   // TABLE_CATALOG
   //=============================================================
   if( _wcsicmp(pProperty,g_TablesInfo[0].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(m_pParms->m_pConnection->GetNamespace());
   }
   //=============================================================
   // TABLE_SCHEMA
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[1].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
   }            
   //=============================================================
   // TABLE_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[2].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       hr = GetClassProperty(L"__CLASS",v,pType,plFlavor);
   }            
   //=============================================================
   // TABLE_TYPE
   //   This is either "TABLE" or "SYSTEM TABLE"
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[3].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       CVARIANT Var;
       hr = GetClassProperty(L"__CLASS",&Var,pType,plFlavor);
	   // NT Raid 136462
	   // 07/12/00
       if( S_OK == hr ){
          WCHAR * p = Var.GetStr();
          if (p != NULL){
             if( wcsncmp( p, L"__",2) == 0 ){
                 ((CVARIANT*)v)->SetStr(L"SYSTEM TABLE");
			 }
             else{
                 ((CVARIANT*)v)->SetStr(L"TABLE");
			 }
          }
		  else{
			  hr = E_UNEXPECTED;
		  }
       }
   }            
   //=============================================================
   // TABLE_GUID
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[4].wcsColumnName) == 0 ){
       *pType = DBTYPE_GUID;
   }            
   //=============================================================
   // BOOKMARKS
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[5].wcsColumnName) == 0 ){
       *pType = CIM_BOOLEAN;
       ((CVARIANT*)v)->SetBool(TRUE);
   }            
   //=============================================================
   // BOOKMARK_TYPE
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[6].wcsColumnName) == 0 ){
       *pType = CIM_SINT32;
       ((CVARIANT*)v)->SetLONG(DBPROPVAL_BMK_NUMERIC);
   }            
   //=============================================================
   // BOOKMARK_DATATYPE
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[7].wcsColumnName) == 0 ){
       *pType = CIM_UINT16;
       ((CVARIANT*)v)->SetShort(DBTYPE_UI4);

   }            
   //=============================================================
   // BOOKMARK_MAXIMUM_LENGTH
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[8].wcsColumnName) == 0 )
   {
       *pType = CIM_UINT32;
       ((CVARIANT*)v)->SetLONG(sizeof(ULONG));
   }            
   //=============================================================
   // BOOKMARK_INFORMATION
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[9].wcsColumnName) == 0 ){
       *pType = CIM_UINT32;
   }            
   //=============================================================
   // BOOKMARK_TABLE_VERSION
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[10].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
   }            
   //=============================================================
   // CARDINALITY
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[11].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
   }            
   //=============================================================
   // DESCRIPTION
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[12].wcsColumnName) == 0 ){
       *pType = CIM_STRING;
       hr = GetClassQualifier(L"Description",v,pType,plFlavor);
   }            
   //=============================================================
   // TABLE_PROPID
   //=============================================================
   else if( _wcsicmp(pProperty,g_TablesInfo[13].wcsColumnName) == 0 ){
       *pType = CIM_UINT32;
   }
    return MapWbemErrorToOLEDBError(hr);
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaTablesInfoInstanceList::NextInstance( CBSTR & Key, CWbemClassInstanceWrapper ** pInst  )
{
    HRESULT hr = S_OK;

    if( !m_pwcsSpecificClass )
    {
        return CWbemInstanceList::NextInstance(Key,pInst);
    }
        
    hr = GetTheSpecificClass();
    if( S_OK == hr )
    {
        *pInst = (CWbemSchemaTablesInfoInstanceWrapper *) new CWbemSchemaTablesInfoInstanceWrapper(m_pParms);
		// NTRaid:136512 , 136514
		// 07/05/00
		if(*pInst)
		{
			(*pInst)->SetClass(m_pSpecificClass);
			(*pInst)->SetPos(++m_lCurrentPos);
			AddInstance(*pInst);
			(*pInst)->GetKey(Key);
		}
		else
		{
			hr = E_OUTOFMEMORY;
		}
    }
    return hr;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaTablesInfoInstanceList::Reset()
{
    HRESULT hr = E_UNEXPECTED;
    if( m_pwcsSpecificClass)
    {
        hr = ResetTheSpecificClass();
    }
    else
    {
        LONG lFlags = WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY;

        //============================================================
        //  Send off the query for "Select Name from __Namespace
        //============================================================
        if( m_ppEnum )
        {
            hr = m_ppEnum->Reset();
            ReleaseAllInstances();
        }
        else
        {
            hr = (m_pParms->GetServicesPtr())->CreateClassEnum(NULL,  WBEM_FLAG_FORWARD_ONLY,m_pParms->m_pConnection->GetContext(),&m_ppEnum);
        }
    }
	m_lCurrentPos = 0;

    return MapWbemErrorToOLEDBError(hr);
}

//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
//
//  Classes for the Procedures schema rowset
//
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaProceduresClassDefinitionWrapper::CWbemSchemaProceduresClassDefinitionWrapper(CWbemClassParameters * p) : CWbemSchemaClassDefinitionWrapper(p) 
{
   
   m_nMaxColumns = sizeof(g_Procedures)/sizeof(SchemaRowsetDefinition);
}

//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr = S_OK;

    //===============================================================================
    //  See if we got all of the column info
    //===============================================================================
    if( m_nSchemaClassIndex == m_nMaxColumns )
    {
        return WBEM_S_NO_MORE_DATA;
    }

    *pType = g_Procedures[m_nSchemaClassIndex].Type;
    *pProperty = Wmioledb_SysAllocString(g_Procedures[m_nSchemaClassIndex].wcsColumnName);
    m_nSchemaClassIndex++;

    return hr;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresInstanceWrapper::GetKey(CBSTR & Key)
{
    HRESULT hr = S_OK;

    //===========================================================
    //  The key is going to the be the class name.method name
    //===========================================================
    CVARIANT v;
    CIMTYPE Type;
    LONG lFlavor;

    hr = GetClassProperty(L"__CLASS",&v,&Type,&lFlavor);
    if( SUCCEEDED(hr))
    {
        WCHAR * p = new WCHAR [wcslen(v.GetStr()) + wcslen(m_bstrCurrentMethodName) + 4 ];
        if( p )
        {
            swprintf(p, L"%s:%s", v.GetStr(),m_bstrCurrentMethodName);
            Key.SetStr(p);
            delete p;  
        }
    }
    
    return hr;    
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresInstanceWrapper::GetSchemaProperty( WCHAR * pProperty, VARIANT * v,CIMTYPE * pType , LONG * plFlavor)
{
    HRESULT hr = S_OK;

   ((CVARIANT*)v)->Clear();
   *plFlavor = 0;
   //=============================================================
   // PROCEDURE_CATALOG
   //=============================================================
   if( _wcsicmp(pProperty,g_Procedures[0].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(m_pParms->m_pConnection->GetNamespace());
   }
   //=============================================================
   // PROCEDURE_SCHEMA
   //=============================================================
   else if( _wcsicmp(pProperty,g_Procedures[1].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
       hr = GetClassProperty(L"__CLASS",v,pType,plFlavor);
   }            
   //=============================================================
   // PROCEDURE_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_Procedures[2].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(m_bstrCurrentMethodName);

   }            
   //=============================================================
   // PROCEDURE_TYPE
   //=============================================================
   else if( _wcsicmp(pProperty,g_Procedures[3].wcsColumnName) == 0 )
   {
       *pType = CIM_SINT16;
       //=========================================================
       //
       //  If there is an output class, then the type is
       //       DB_PT_FUNCTION
       //  If there is not an output class, then the type is
       //       DB_PT_PROCEDURE
       //=========================================================
       if( m_pOutClass )
       {
           ((CVARIANT*)v)->SetShort(DB_PT_FUNCTION);
       }
       else
       {
           ((CVARIANT*)v)->SetShort(DB_PT_PROCEDURE);
       }
   }            
   //=============================================================
   // PROCEDURE_DEFINITION
   //=============================================================
   else if( _wcsicmp(pProperty,g_Procedures[4].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
   }            
   //=============================================================
   // PROCEDURE_DESCRIPTION
   //=============================================================
   else if( _wcsicmp(pProperty,g_Procedures[5].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
   }            
   //=============================================================
   // DATE_CREATED
   //=============================================================
   else if( _wcsicmp(pProperty,g_Procedures[6].wcsColumnName) == 0 )
   {
       *pType = DBTYPE_DATE;

   }            
   //=============================================================
   // DATE_MODIFIED
   //=============================================================
   else if( _wcsicmp(pProperty,g_Procedures[7].wcsColumnName) == 0 )
   {
       *pType = DBTYPE_DATE;
   }            

    return MapWbemErrorToOLEDBError(hr);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CWbemSchemaProceduresInstanceList::ResetMethodPtrs()
{
    m_bstrCurrentMethodName.Clear();
    SAFE_RELEASE_PTR(m_pCurrentMethodInClass);
    SAFE_RELEASE_PTR(m_pCurrentMethodOutClass);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresInstanceList::Reset()
{
    HRESULT hr = E_UNEXPECTED;
    if( m_pwcsSpecificClass)
    {
        hr = ResetTheSpecificClass();
    }
    else
    {
        LONG lFlags = WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY;

        //============================================================
        //  Send off the query for "Select Name from __Namespace
        //============================================================
        if( m_ppEnum )
        {
            hr = m_ppEnum->Reset();
            ReleaseAllInstances();
        }
        else
        {
            hr = (m_pParms->GetServicesPtr())->CreateClassEnum(NULL,  WBEM_FLAG_FORWARD_ONLY,m_pParms->m_pConnection->GetContext(),&m_ppEnum);
        }
    }
	m_lCurrentPos = 0;
    m_fContinueWithSameClass = FALSE;
    SAFE_RELEASE_PTR(m_pCurrentMethodClass);

    return MapWbemErrorToOLEDBError(hr);
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresInstanceList::GetTheNextClassThatHasMethods()
{
    HRESULT hr = S_OK;

    //==================================================================
    //  Does the existing class have methods in it?
    //==================================================================
    while( S_OK == hr )
    {
        //==============================================================
        //  It does, then set all the current info and return so we
        //  can process the columns
        //==============================================================
		unsigned long u = 0L;

        if( !m_fContinueWithSameClass )
        {
            if( !m_pwcsSpecificClass )
            {
                SAFE_RELEASE_PTR(m_pCurrentMethodClass);
                hr = m_ppEnum->Next(0,1,&m_pCurrentMethodClass,&u);
                if( SUCCEEDED(hr))
                {
                    hr = m_pCurrentMethodClass->BeginMethodEnumeration(0);
                }
            }
        }

        if( SUCCEEDED(hr))
        {   
            ResetMethodPtrs();

            hr = m_pCurrentMethodClass->NextMethod(0,(BSTR*)&m_bstrCurrentMethodName,&m_pCurrentMethodInClass,&m_pCurrentMethodOutClass);
            if( hr == S_OK )
            {
                m_fContinueWithSameClass = TRUE;
                break;
            }
            else
            {   
                if( hr == WBEM_S_NO_MORE_DATA )
                {
                    if( !m_pwcsSpecificClass )
                    {
                        hr = S_OK;  // continue on to the next one
                    }
                    // otherwise,we know there isn't another one.
                }
                m_pCurrentMethodClass->EndEnumeration();
                m_fContinueWithSameClass = FALSE;
            }
            //==============================================================
            //  It doesn't, so, keep looping through the classes until we
            //  find another class that has methods, or we are done with all
            //  the classes
            //==============================================================
        }
        else
        {
            break;
        }
    }

    return hr;
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresInstanceList::GetSpecificNextInstance()
{
    HRESULT hr = GetTheSpecificClass();
    if( S_OK == hr )
    {
        m_pCurrentMethodClass = m_pSpecificClass;
        m_pSpecificClass = NULL; // will be released with the m_pCurrentMethodClass
        ResetMethodPtrs();
        m_fContinueWithSameClass = TRUE;
        hr = m_pCurrentMethodClass->BeginMethodEnumeration(0);
    }
    //==================================================================
    //  We know there are no more classes, but there might be more
    //  methods, so go on to process the rest of the methods
    //==================================================================
    if( hr == WBEM_S_NO_MORE_DATA )
    {
        hr = S_OK;
    }
    return hr;
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresInstanceList::NextInstance( CBSTR & Key, CWbemClassInstanceWrapper ** pInst  )
{
    HRESULT hr = S_OK;

    if( m_pwcsSpecificClass )
    {
        hr = GetSpecificNextInstance();
    }
    if( S_OK == hr )
    {
        hr = GetTheNextClassThatHasMethods();
        if( S_OK == hr)
        {
            *pInst = new CWbemSchemaProceduresInstanceWrapper(m_pParms);
			// NTRaid:136455
			// 07/05/00
			if(*pInst)
			{
 				(*pInst)->SetPos(++m_lCurrentPos);
   				((CWbemSchemaProceduresInstanceWrapper*)(*pInst))->SetMethodName((LPWSTR)m_bstrCurrentMethodName);
   				((CWbemSchemaProceduresInstanceWrapper*)(*pInst))->SetInputClass(m_pCurrentMethodInClass);
   				((CWbemSchemaProceduresInstanceWrapper*)(*pInst))->SetOutputClass(m_pCurrentMethodOutClass);
   				(*pInst)->SetClass(m_pCurrentMethodClass);
				AddInstance(*pInst);
				(*pInst)->GetKey(Key);
				hr = S_OK;
			}
			else
			{
				hr = E_OUTOFMEMORY;
			}
        }
    }
    return hr;
}
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
//
//  Classes for the Procedure Parameters schema rowset
//
//********************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////////
CWbemSchemaProceduresParametersClassDefinitionWrapper::CWbemSchemaProceduresParametersClassDefinitionWrapper(CWbemClassParameters * p) : CWbemSchemaClassDefinitionWrapper(p) 
{
   
   m_nMaxColumns = sizeof(g_ProcedureParameters)/sizeof(SchemaRowsetDefinition);
}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresParametersClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
{
    HRESULT hr = S_OK;

    //===============================================================================
    //  See if we got all of the column info
    //===============================================================================
    if( m_nSchemaClassIndex == m_nMaxColumns )
    {
        return WBEM_S_NO_MORE_DATA;
    }

    *pType = g_ProcedureParameters[m_nSchemaClassIndex].Type;
    *pProperty = Wmioledb_SysAllocString(g_ProcedureParameters[m_nSchemaClassIndex].wcsColumnName);
    m_nSchemaClassIndex++;

    return hr;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresParametersInstanceWrapper::GetKey(CBSTR & Key)
{
    HRESULT hr = S_OK;

    //===========================================================
    //  The key is going to the be the class name.method name
    //===========================================================
    CVARIANT v;
    CIMTYPE Type;
    LONG lFlavor;

    hr = GetClassProperty(L"__CLASS",&v,&Type,&lFlavor);
    if( SUCCEEDED(hr))
    {
        WCHAR * p = new WCHAR [wcslen(v.GetStr()) + wcslen(m_bstrCurrentMethodName) + wcslen(m_bstrPropertyName)+ 4 ];
        if( p )
        {
            swprintf(p, L"%s:%s:%s", v.GetStr(),m_bstrCurrentMethodName,m_bstrPropertyName);
            Key.SetStr(p);
            delete p;  
        }
    }
    
    return hr;    
}

//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresParametersInstanceWrapper::GetPropertyQualifier(WCHAR * wcsQualifier,VARIANT * v)
{
    LONG lType;
    long lFlavor;
    HRESULT hr = S_OK;

    IWbemClassObject * pTmp = m_pClass;

    if( m_pInClass )
    {
        m_pClass = m_pInClass;
    }
    else
    {
        m_pClass = m_pOutClass;
    }

    hr = CWbemClassWrapper::GetPropertyQualifier(m_bstrPropertyName,CBSTR(wcsQualifier),v,&lType,&lFlavor);

    m_pClass = pTmp;

    return hr;

}
//////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresParametersInstanceWrapper::GetSchemaProperty( WCHAR * pProperty, VARIANT * v,CIMTYPE * pType , LONG * plFlavor)
{
    HRESULT hr = S_OK;

   ((CVARIANT*)v)->Clear();
   *plFlavor = 0;

   //=============================================================
   // PROCEDURE_CATALOG
   //=============================================================
   if( _wcsicmp(pProperty,g_ProcedureParameters[0].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(m_pParms->m_pConnection->GetNamespace());
   }
   //=============================================================
   // PROCEDURE_SCHEMA
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[1].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
       hr = GetClassProperty(L"__CLASS",v,pType,plFlavor);
   }            
   //=============================================================
   // PROCEDURE_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[2].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(m_bstrCurrentMethodName);
   }          
   //=============================================================
   // PARAMETER_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[3].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
       ((CVARIANT*)v)->SetStr(m_bstrPropertyName);
   }          
   //=============================================================
   // ORDINAL_POSITION
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[4].wcsColumnName) == 0 )
   {
       *pType = CIM_UINT16;
       ((CVARIANT*)v)->SetShort(m_nOrdinal);
   }          
   //=============================================================
   // PARAMETER_TYPE
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[5].wcsColumnName) == 0 )
   {
       *pType = CIM_UINT16;
       CVARIANT vIn, vOut;

       GetPropertyQualifier(L"IN",vIn);
       GetPropertyQualifier(L"OUT",vOut);

       if( vIn.GetType() != VT_EMPTY && vOut.GetType() != VT_EMPTY )
       {
           if( vIn.GetBool() == TRUE && vOut.GetBool() == TRUE )
           {
              ((CVARIANT*)v)->SetShort(DBPARAMTYPE_INPUTOUTPUT);
           }
       }
       else if( vOut.GetType() != VT_EMPTY && vOut.GetBool() == TRUE )
       {
          ((CVARIANT*)v)->SetShort(DBPARAMTYPE_OUTPUT);
       }
       else if( vIn.GetType() != VT_EMPTY && vIn.GetBool() == TRUE )
       {
          ((CVARIANT*)v)->SetShort(DBPARAMTYPE_INPUT);
       }
   }          
   //=============================================================
   // PARAMETER_HASDEFAULT
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[6].wcsColumnName) == 0 )
   {
       *pType = CIM_BOOLEAN;

       CVARIANT vVar;

       hr = GetPropertyQualifier(CBSTR(L"Optional"),(VARIANT *)&vVar);
       if( SUCCEEDED(hr))
       {
           ((CVARIANT*)v)->SetBool(vVar.GetBool());
       }
   }          
   //=============================================================
   // PARAMETER_DEFAULT
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[7].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
   }          
   //=============================================================
   // IS_NULLABLE
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[8].wcsColumnName) == 0 )
   {
       *pType = CIM_BOOLEAN;
       ((CVARIANT*)v)->SetBool(VARIANT_TRUE);
   }          
   //=============================================================
   // DATA_TYPE
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[9].wcsColumnName) == 0 )
   {
       *pType = CIM_UINT16;  
       CDataMap Map;
       WORD wType;
       DBLENGTH dwLength;
       DWORD dwFlags;

       hr = Map.MapCIMTypeToOLEDBType(m_vProperty.GetType(),wType,dwLength,dwFlags);
       if( SUCCEEDED(hr))
       {
            ((CVARIANT*)v)->SetShort(wType);
       }
   }          
   //=============================================================
   // CHARACTER_MAXIMUM_LENGTH
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[10].wcsColumnName) == 0 )
   {
        *pType = CIM_UINT32;  
        if( m_vProperty.GetType() == CIM_STRING )
        {
            ((CVARIANT*)v)->SetLONG(~0);
        }
   }          
   //=============================================================
   // CHARACTER_OCTET_LENGTH
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[11].wcsColumnName) == 0 )
   {
       *pType = CIM_UINT32;  
        if( m_vProperty.GetType() == CIM_STRING )
        {
            ((CVARIANT*)v)->SetLONG(~0);
        }
   }          
   //=============================================================
   // NUMERIC_PRECISION
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[12].wcsColumnName) == 0 )
   {
       *pType = CIM_UINT16;
   }          
   //=============================================================
   // NUMERIC_SCALE
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[13].wcsColumnName) == 0 )
   {
       *pType = CIM_SINT16;
   }          
   //=============================================================
   // DESCRIPTION
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[14].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
   }          
   //=============================================================
   // TYPE_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[15].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
       CVARIANT vVar;

       hr = GetPropertyQualifier(CBSTR(L"CIMTYPE"),(VARIANT *)&vVar);
       if( SUCCEEDED(hr))
       {
           ((CVARIANT*)v)->SetStr(vVar.GetStr());
       }
   }          
   //=============================================================
   // LOCAL_TYPE_NAME
   //=============================================================
   else if( _wcsicmp(pProperty,g_ProcedureParameters[16].wcsColumnName) == 0 )
   {
       *pType = CIM_STRING;
   }          
   

    return MapWbemErrorToOLEDBError(hr);
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresParametersInstanceList::GetTheNextParameter()
{
    HRESULT hr = WBEM_S_NO_MORE_DATA;
    //===================================================================
    // Get the properties of the class 
    //===================================================================
    CIMTYPE Type = 0;
    LONG Flavor = 0;

    m_bstrPropertyName.Clear();
    m_vProperty.Clear();

    if( m_pCurrentMethodInClass )
    {
        hr = m_pCurrentMethodInClass->Next(0,(BSTR*)&m_bstrPropertyName,&m_vProperty,&Type,&Flavor);
    }
    
    if( hr == WBEM_S_NO_MORE_DATA )
    {
        SAFE_RELEASE_PTR(m_pCurrentMethodInClass );
        if( m_pCurrentMethodOutClass )
        {
            hr = m_pCurrentMethodOutClass->Next(0,(BSTR*)&m_bstrPropertyName,&m_vProperty,&Type,&Flavor);
        }
    }
    return hr;
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresParametersInstanceList::GetTheNextClassThatHasParameters()
{
    HRESULT hr = S_OK;

    //===================================================================================
    //  If we aren't working on the same class, then get the next class that has a method
    //===================================================================================
    m_nOrdinal = 0;

    while(hr == S_OK)
    {
        hr = GetTheNextClassThatHasMethods();
        if( SUCCEEDED(hr))
        {
            //===========================================================================
            //  Process the input parameters first
            //===========================================================================
            if( m_pCurrentMethodInClass )
            {
                hr = m_pCurrentMethodInClass->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY);
            }
            else if( m_pCurrentMethodOutClass )
            {
                hr = m_pCurrentMethodOutClass->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY);
            }

            if( SUCCEEDED(hr))
            {
                hr = GetTheNextParameter();
                if( SUCCEEDED(hr))
                {
                    m_fStillWorkingOnTheSameClass = TRUE;
                    break;
                }
            }
        }            
    }

    return hr;
}
////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWbemSchemaProceduresParametersInstanceList::NextInstance( CBSTR & Key, CWbemClassInstanceWrapper ** pInst  )
{
    HRESULT hr = S_OK;
    if( m_pwcsSpecificClass )
    {
        hr = GetSpecificNextInstance();
        m_fStillWorkingOnTheSameClass = TRUE; // We want to pick up the parameters 
    }
    if( S_OK == hr )
    {
        if( !m_fStillWorkingOnTheSameClass )
        {
            hr = GetTheNextClassThatHasParameters();
        }
        else
        {
            hr = GetTheNextParameter();
            if( S_OK != hr )
            {
                hr = GetTheNextClassThatHasParameters();
            }
        }
    }
    
    if( S_OK == hr)
    {
        *pInst = new CWbemSchemaProceduresParametersInstanceWrapper(m_pParms);
 		// NTRaid:136459
		// 07/05/00
		if(*pInst)
		{
 			(*pInst)->SetPos(++m_lCurrentPos);
   			((CWbemSchemaProceduresParametersInstanceWrapper*)(*pInst))->SetMethodName((LPWSTR)m_bstrCurrentMethodName);
   			((CWbemSchemaProceduresParametersInstanceWrapper*)(*pInst))->SetPropertyName((LPWSTR)m_bstrPropertyName);
   			((CWbemSchemaProceduresParametersInstanceWrapper*)(*pInst))->SetProperty(m_vProperty);
   			((CWbemSchemaProceduresParametersInstanceWrapper*)(*pInst))->SetOrdinal(++m_nOrdinal);
   			((CWbemSchemaProceduresInstanceWrapper*)(*pInst))->SetInputClass(m_pCurrentMethodInClass);
   			((CWbemSchemaProceduresInstanceWrapper*)(*pInst))->SetOutputClass(m_pCurrentMethodOutClass);

   			(*pInst)->SetClass(m_pCurrentMethodClass);
			AddInstance(*pInst);
    		((CWbemSchemaProceduresInstanceWrapper*)(*pInst))->GetKey(Key);
			hr = S_OK;
		}
		else
		{
			hr = E_OUTOFMEMORY;
		}
    }
    return hr;
}