windows-xp/Source/XPSP1/NT/inetsrv/query/icommand/qryspec.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1995 - 2000.
//
//  File:       qryspec.cxx
//
//  Contents:   ICommandTree implementation for OFS file stores
//
//  Classes:    CRootQuerySpec
//
//  Functions:  CheckForErrors
//              CheckForPriorTree
//
//  History:    30 Jun 1995   AlanW     Created
//              10-31-97      danleg    Added ICommandText & ICommandPrepare
//
//----------------------------------------------------------------------------

#include "pch.cxx"
#pragma hdrstop

#include <colinfo.hxx>
#include <parstree.hxx>
#include <hraccess.hxx>
#include <mparser.h>
#include <propglob.hxx>
#include <doquery.hxx>
#include "qryspec.hxx"

// Command object Interfaces that support Ole DB error objects
static const IID * apCommandErrorIFs[] =
{
        &IID_IAccessor,
        &IID_IColumnsInfo,
        &IID_ICommand,
        &IID_ICommandProperties,
        &IID_ICommandText,
        &IID_IConvertType,
        //&IID_IColumnsRowset,
        &IID_ICommandPrepare,
        &IID_ICommandTree,
        //&IID_ICommandWithParameters,
        &IID_IQuery,
        //&IID_ISupportErrorInfo,
        &IID_IServiceProperties
};
static const ULONG cCommandErrorIFs  = sizeof(apCommandErrorIFs)/sizeof(apCommandErrorIFs[0]);

// SQL defining global views.  These views are defined at the datasrc level, if one is present,
// or at the command level otherwise.
extern const LPWSTR s_pwszPredefinedViews =
    L"SET GLOBAL ON; "
    L"CREATE VIEW FILEINFO "
    L"       AS SELECT PATH, FILENAME, SIZE, WRITE, ATTRIB FROM SCOPE(); "
    L"CREATE VIEW FILEINFO_ABSTRACT     "
    L"       AS SELECT PATH, FILENAME, SIZE, WRITE, ATTRIB, CHARACTERIZATION FROM SCOPE(); "
    L"CREATE VIEW EXTENDED_FILEINFO     "
    L"       AS SELECT PATH, FILENAME, SIZE, WRITE, ATTRIB, DOCTITLE, DOCAUTHOR, DOCSUBJECT, DOCKEYWORDS, CHARACTERIZATION FROM SCOPE(); "
    L"CREATE VIEW WEBINFO "
    L"       AS SELECT VPATH, PATH, FILENAME, SIZE, WRITE, ATTRIB, CHARACTERIZATION, DOCTITLE FROM SCOPE(); "
    L"CREATE VIEW EXTENDED_WEBINFO "
    L"       AS SELECT VPATH, PATH, FILENAME, SIZE, CHARACTERIZATION, WRITE, DOCAUTHOR, DOCSUBJECT, DOCKEYWORDS, DOCTITLE FROM SCOPE(); "
    L"CREATE VIEW SSWebInfo "
    L"       AS SELECT URL, DOCTITLE, RANK, SIZE, WRITE FROM SCOPE(); "
    L"CREATE VIEW SSExtended_WebInfo "
    L"       AS SELECT URL, DOCTITLE, RANK, HITCOUNT, DOCAUTHOR, CHARACTERIZATION, SIZE, WRITE FROM SCOPE()";

//+-------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::CRootQuerySpec, public
//
//  Synopsis:   Constructor of a CRootQuerySpec
//
//  Arguments:  [pOuterUnk] - Outer unknown
//              [ppMyUnk]   - OUT:  filled in with pointer to non-delegated
//                            IUnknown on return
//
//  History:    08-Feb-96   KyleP    Added support for virtual paths
//
//--------------------------------------------------------------------------

CRootQuerySpec::CRootQuerySpec (IUnknown *          pOuterUnk,
                                IUnknown **         ppMyUnk,
                                CDBSession *        pSession)
        : _dwDepth(QUERY_SHALLOW),
          _pInternalQuery(0),
          _pQueryTree(0),
          _pColumnsInfo(0),
#pragma warning(disable : 4355) // 'this' in a constructor
         _impIUnknown(this),
         _aAccessors( (IUnknown *) (ICommand *)this ),
         _DBErrorObj( * ((IUnknown *) (ICommand *) this), _mtxCmd ),
#pragma warning(default : 4355)    // 'this' in a constructor
          _dwStatus(0),
          _guidCmdDialect(DBGUID_SQL),
          _fGenByOpenRowset(FALSE),
          _pwszSQLText(0),
          _RowsetProps( pSession ?
                        pSession->GetDataSrcPtr()->GetDSPropsPtr()->
                            GetValLong( CMDSProps::eid_DBPROPSET_DBINIT,
                                    CMDSProps::eid_DBPROPVAL_INIT_LCID ) :
                        0 ),
          _PropInfo()

{
    if (pOuterUnk)
        _pControllingUnknown = pOuterUnk;
    else
        _pControllingUnknown = (IUnknown * )&_impIUnknown;

    _DBErrorObj.SetInterfaceArray(cCommandErrorIFs, apCommandErrorIFs);

    if ( pSession )
    {
        _xSession.Set( pSession );
        _xSession->AddRef();

        _xpIPSession.Set( pSession->GetParserSession() );

        //
        // The above Set() doesn't AddRef. This will balance the XInterface<>
        // dtor Release
        //
        _xpIPSession->AddRef();
    }

    *ppMyUnk = ((IUnknown *)&_impIUnknown);
    (*ppMyUnk)->AddRef();
}

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::CRootQuerySpec, public
//
//  Synopsis:   Copy constructor
//
//  Arguments:  [src] -- Source query spec
//
//  History:    27 Jun 95   AlanW       Created
//              10 Jan 98   danleg      Replaced body with Assert
//
//----------------------------------------------------------------------------

CRootQuerySpec::CRootQuerySpec( CRootQuerySpec & src )
        : _dwDepth( src._dwDepth ),
          _pInternalQuery(0),
          _pQueryTree(0),
          _pColumnsInfo(0),
#pragma warning(disable : 4355) // 'this' in a constructor
         _impIUnknown(this),
         _aAccessors( (IUnknown *) (ICommand *)this ),
         _DBErrorObj( * ((IUnknown *) (ICommand *) this), _mtxCmd ),
#pragma warning(default : 4355)    // 'this' in a constructor
          _dwStatus(src._dwStatus),
          _guidCmdDialect(src._guidCmdDialect),
          _fGenByOpenRowset(src._fGenByOpenRowset),
          _pwszSQLText(0),
          _RowsetProps( src._RowsetProps ),
          _PropInfo()
{
    Win4Assert( !"CRootQuerySpec copy constructor not implemented.");
}

//+-------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::~CRootQuerySpec, private
//
//  Synopsis:   Destructor of a CRootQuerySpec
//
//--------------------------------------------------------------------------

CRootQuerySpec::~CRootQuerySpec()
{
    ReleaseInternalQuery();

    delete    _pColumnsInfo;
    delete    _pQueryTree;
    delete [] _pwszSQLText;
}


//+-------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::RealQueryInterface, public
//
//  Synopsis:   Get a reference to another interface on the cursor.  AddRef
//              is done in CImpIUnknown::QueryInterface
//
//  History:    10-31-97    danleg      Added ICommandText& ICommandPrepare
//
//--------------------------------------------------------------------------

//
// Hack #214: IID_ICommandProperties is intercepted by service layers, which
//            don't like us passing in the magic code to fetch hidden scope
//            properties.  But the controlling unknown doesn't recognize
//            IID_IKyleProp and sends it right to us.  Implementation is
//            identical to ICommandProperties.
//

extern GUID IID_IKyleProp;

SCODE CRootQuerySpec::RealQueryInterface(
    REFIID ifid,
    void * *ppiuk )
{
    SCODE sc = S_OK;

    TRY
    {
        // validate the param before any addrefs
        *ppiuk = 0;

        // note -- IID_IUnknown covered in QueryInterface

        if ( IID_ICommand == ifid )
        {
            *ppiuk = (void *) ((ICommand *) this);
        }
        else if (IID_ISupportErrorInfo == ifid)
        {
            *ppiuk = (void *) ((IUnknown *) (ISupportErrorInfo *) &_DBErrorObj);
        }
        else if ( IID_IAccessor == ifid )
        {
            *ppiuk = (void *) (IAccessor *) this;
        }
        else if ( IID_IColumnsInfo == ifid )
        {
           *ppiuk = (void *) (IColumnsInfo *) GetColumnsInfo();
        }
    // NTRAID#DB-NTBUG9-84306-2000/07/31-dlee OLE-DB spec variance in Indexing Service, some interfaces not implemented
    #if 0  
        else if ( IID_IRowsetInfo == ifid )
        {
            *ppiuk = (void *) (IRowsetInfo *) this;
        }
    #endif // 0
        else if ( IID_ICommandTree == ifid )
        {
            *ppiuk = (void *) (ICommandTree *) this;
        }
    // NTRAID#DB-NTBUG9-84306-2000/07/31-dlee OLE-DB spec variance in Indexing Service, some interfaces not implemented
    #if 0 
        else if ( IID_ICommandValidate == ifid )
        {
            *ppiuk = (void *) (ICommandValidate *) this;
        }
    #endif // 0
        else if ( IID_IQuery == ifid )
        {
            *ppiuk = (void *) (IQuery *) this;
        }
        else if ( IID_ICommandProperties == ifid || IID_IKyleProp == ifid )
        {
            *ppiuk = (void *) (ICommandProperties *) this;
        }
        else if ( IID_IServiceProperties == ifid )
        {
            *ppiuk = (void *) (IServiceProperties *) this;
        }
        else if ( IID_IConvertType == ifid )
        {
            *ppiuk = (void *) (IConvertType *) this;
        }
        else if ( IID_ICommandText == ifid )
        {
            // Create parser sesson object if deferred during construction
            if ( _xpIPSession.IsNull() )
                CreateParser();

            *ppiuk = (void *) (ICommandText *) this;
        }
        else if ( IID_ICommandPrepare == ifid )
        {
            *ppiuk = (void *) (ICommandPrepare *) this;
        }

        else
        {
            *ppiuk = 0;
            sc = E_NOINTERFACE;
        }
    }
    CATCH( CException, e )
    {
        vqDebugOut(( DEB_ERROR, "Exception %08x while doing QueryInterface \n",
                     e.GetErrorCode() ));
        sc = GetOleError(e);
    }
    END_CATCH

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::FindErrorNodes, public
//
//  Synopsis:   Find error nodes in a command tree
//
//  Arguments:  [pRoot]         -- DBCOMMANDTREE node at root of tree
//              [pcErrorNodes]  -- pointer where count of error nodes is ret'd
//
//  History:    27 Jun 95   AlanW       Created
//
//----------------------------------------------------------------------------

BOOL CheckForErrors( const CDbCmdTreeNode *pNode )
{
    if (pNode->GetError() != S_OK)
        return TRUE;
    else
        return FALSE;
}


SCODE CRootQuerySpec::FindErrorNodes(
    const DBCOMMANDTREE *  pRoot,
    ULONG *                pcErrorNodes,
    DBCOMMANDTREE ***      prgErrorNodes)
{
    SCODE sc = S_OK;

    ULONG cErrors = 0;
    XArrayOLE<DBCOMMANDTREE *> pErrorNodes;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        _FindTreeNodes( CDbCmdTreeNode::CastFromStruct(pRoot),
                        cErrors,
                        pErrorNodes,
                        CheckForErrors );

        *pcErrorNodes = cErrors;
        *prgErrorNodes = pErrorNodes.GetPointer();
        pErrorNodes.Acquire();
    }
    CATCH( CException, e )
    {
        sc = _DBErrorObj.PostHResult( e, IID_ICommandTree );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}


//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::_FindTreeNodes, private
//
//  Synopsis:   Find nodes in a command tree meeting some condition
//
//  Arguments:  [pRoot]         -- DBCOMMANDTREE node at root of tree
//              [rcMatchingNodes]  -- count of matching nodes returned
//              [prgMatchingNodes] -- pointer to array of nodes returned
//              [pfnCheckNode]  -- function which returns true if a tree
//                                 node matches desired condition.
//              [iDepth]        -- depth of tree; for detecting cycles
//
//  Notes:      In order to avoid looping endlessly over a tree with cycles,
//              this routine will bail out if the tree depth is greater
//              than 1000 or if the tree width is greater than 100,000.
//
//              We don't expect this routine to be called in situations
//              where it will return very large numbers of tree nodes,
//              so we grow the returned array only one element at a time.
//
//  History:    27 Jun 95   AlanW       Created
//
//----------------------------------------------------------------------------

const unsigned MAX_TREE_DEPTH = 1000;   // max tree depth
const unsigned MAX_TREE_WIDTH = 100000; // max tree width


void CRootQuerySpec::_FindTreeNodes(
    const CDbCmdTreeNode * pRoot,
    ULONG &                rcMatchingNodes,
    XArrayOLE<DBCOMMANDTREE *> & rpMatchingNodes,
    PFNCHECKTREENODE       pfnCheckNode,
    unsigned               iDepth)
{
    if (iDepth > MAX_TREE_DEPTH)
        THROW(CException(E_FAIL));

    unsigned iWidth = 0;

    while (pRoot)
    {
        if (pRoot->GetFirstChild())
            _FindTreeNodes( pRoot->GetFirstChild(),
                            rcMatchingNodes,
                            rpMatchingNodes,
                            pfnCheckNode,
                            iDepth+1);

        if (iWidth > MAX_TREE_WIDTH)
            THROW(CException(E_FAIL));

        if ((pfnCheckNode)(pRoot))
        {
            XArrayOLE<DBCOMMANDTREE *> pMatchTemp( rcMatchingNodes+1 );
            if (0 == pMatchTemp.GetPointer())
                THROW(CException(E_OUTOFMEMORY));

            if (rcMatchingNodes > 0)
            {
                Win4Assert(rpMatchingNodes.GetPointer() != 0);
                RtlCopyMemory(pMatchTemp.GetPointer(),
                              rpMatchingNodes.GetPointer(),
                              sizeof (DBCOMMANDTREE*) * rcMatchingNodes);
                CoTaskMemFree(rpMatchingNodes.Acquire());
            }
            (pMatchTemp.GetPointer())[rcMatchingNodes] = pRoot->CastToStruct();
            rcMatchingNodes++;

            rpMatchingNodes.Set( rcMatchingNodes, pMatchTemp.Acquire() );
        }

        pRoot = pRoot->GetNextSibling();
        iWidth++;
    }
    return;
}


//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::FreeCommandTree, public
//
//  Synopsis:   Free a command tree
//
//  Arguments:  [ppRoot]   -- DBCOMMANDTREE node at root of tree to be freed
//
//  History:    27 Jun 95   AlanW       Created
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::FreeCommandTree(
    DBCOMMANDTREE * *     ppRoot)
{
    SCODE sc = S_OK;

    if ( 0 == ppRoot )
        return E_INVALIDARG;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        CDbCmdTreeNode * pCmdTree = (CDbCmdTreeNode *)
                          CDbCmdTreeNode::CastFromStruct(*ppRoot);

        //
        //  If the user tries to delete our query tree, zero our pointer to it.
        //
        //  NOTE: Nothing prevents the user from freeing a subtree of
        //        our tree if they called SetCommandTree with fCopy FALSE.
        //

        // There is a proposed spec change on this.  According to the current spec,
        // if fCopy was FALSE we need to return DB_E_CANNOTFREE  here. (MDAC BUGG# 6386)
        if ( _dwStatus & CMD_OWNS_TREE )
        {
            THROW( CException(DB_E_CANNOTFREE) );
        }
        else
        {
            if ( pCmdTree == _pQueryTree )
            _pQueryTree = 0;

            delete pCmdTree;
            *ppRoot = 0;
        }
    }
    CATCH( CException, e )
    {
        sc = _DBErrorObj.PostHResult( e, IID_ICommandTree );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}


//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::GetCommandTree, public
//
//  Synopsis:   Get a copy of the command tree.
//
//  Arguments:  [ppRoot]  -- pointer to where DBCOMMANDTREE is returned
//
//  History:    27 Jun 95   AlanW       Created
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::GetCommandTree(
    DBCOMMANDTREE * *     ppRoot)
{
    if ( 0 == ppRoot )
        return _DBErrorObj.PostHResult( E_INVALIDARG, IID_ICommandTree );

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        //
        // Initialize return parameter
        //
        *ppRoot = 0;

        if ( 0 == _pQueryTree )
        {
            //
            // Build it if we have a command text
            //
            if ( IsCommandSet() )
            {
                sc = BuildTree( );

                // SET PROPERTYNAME ... query
                if ( DB_S_NORESULT == sc )
                    return S_OK;

                _dwStatus |= CMD_TREE_BUILT;
            }

            //
            // The command text didn't generate a tree  (i.e. it was
            // either a CREATE VIEW or SET PROPERTYNAME ) or a
            // command text wasn't set
            //
            if ( 0 == _pQueryTree )
            {
                return S_OK;
            }
        }

        XPtr<CDbCmdTreeNode> TreeCopy( _pQueryTree->Clone(TRUE) );
        if (0 == TreeCopy.GetPointer())
            THROW(CException(E_OUTOFMEMORY));

        *ppRoot = TreeCopy.GetPointer()->CastToStruct();
        TreeCopy.Acquire();
    }
    CATCH( CException, e )
    {
        sc = _DBErrorObj.PostHResult( e, IID_ICommandTree );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}


//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::SetCommandTree, public
//
//  Synopsis:   Set the command tree.
//
//  Arguments:  [ppRoot]   -- pointer to DBCOMMANDTREE to be set in command obj
//              [dwCommandReuse] -- indicates whether state is retained.
//              [fCopy]   -- if TRUE, a copy of ppRoot is made.  Otherwise,
//                           ownership of the command tree passes to the
//                           command object.
//
//  History:    27 Jun 95   AlanW       Created
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::SetCommandTree(
    DBCOMMANDTREE * *       ppRoot,
    DBCOMMANDREUSE          dwCommandReuse,
    BOOL                    fCopy)
{
    if ( HaveQuery() && _pInternalQuery->IsQueryActive() )
        return DB_E_OBJECTOPEN;

    if ( 0 == ppRoot )
        return E_INVALIDARG;

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        _CheckRootNode( *ppRoot );

        if ( 0 != _pQueryTree )
        {
            delete _pQueryTree;
            _pQueryTree = 0;
        }

        CDbCmdTreeNode const * pCmdTree = CDbCmdTreeNode::CastFromStruct(*ppRoot);

        if ( FALSE == fCopy )
        {
            _dwStatus |= CMD_OWNS_TREE;
            _pQueryTree = (CDbCmdTreeNode *)pCmdTree;
            *ppRoot = 0;
        }
        else
        {
            _pQueryTree = pCmdTree->Clone();

            //
            // If Clone() fails it cleans up after itself and returns 0
            //

            if ( 0 == _pQueryTree )
                THROW( CException( E_OUTOFMEMORY ) );
        }

        _dwStatus &= ~CMD_COLINFO_NOTPREPARED;

        if ( _pColumnsInfo )
            InitColumns();

        //
        // If this is not being called internally (from BuildTree) remove the
        // the command text
        //
        if ( _dwStatus & CMD_TEXT_TOTREE )
        {
            _dwStatus &= ~CMD_TEXT_TOTREE;
        }
        else
        {
            delete [] _pwszSQLText;
            _pwszSQLText     = 0;
            _guidCmdDialect  = DBGUID_SQL;
            _dwStatus       &= ~CMD_TEXT_SET;
        }
    }
    CATCH( CException, e )
    {
        sc = _DBErrorObj.PostHResult( e, IID_ICommandTree );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::Execute, public
//
//  Synopsis:   Execute the command; create rowsets for the query resu.
//
//  Arguments:  [pOuterUnk]    -- controlling IUnknown for the rowset
//              [riid]         -- interface IID requested for the rowset
//              [pParams]      -- parameters for the query
//              [pcRowsAffected] -- returned count of affected rows
//              [ppRowset]     -- returned rowset
//
//  History:    27 Jun 95   AlanW       Created
//              11-20-97    danleg      Added ICommandText & ICommandPrepare
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::Execute(
    IUnknown *             pOuterUnk,
    REFIID                 riid,
    DBPARAMS *             pParams,
    DBROWCOUNT *           pcRowsAffected,
    IUnknown * *           ppRowset)
{

    _DBErrorObj.ClearErrorInfo();

    //
    // Called from OpenRowset?
    //
    GUID guidPost = (_fGenByOpenRowset) ? IID_IOpenRowset : IID_ICommand;

    if (0 == ppRowset && IID_NULL != riid )
        return _DBErrorObj.PostHResult( E_INVALIDARG, guidPost );

    if (0 != pOuterUnk && riid != IID_IUnknown)
        return _DBErrorObj.PostHResult( DB_E_NOAGGREGATION, guidPost );

    CLock lck( _mtxCmd );

    SCODE       scResult = S_OK;
    IRowset *   pIRowset = 0;

    _dwStatus &= ~(CMD_EXEC_RUNNING);

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        if ( ppRowset )
            *ppRowset = 0;

        // Impersonate the session logon user
        
        HANDLE hToken = INVALID_HANDLE_VALUE;
        
        if ( !_xSession.IsNull() )
             hToken = _xSession->GetLogonToken();

        CImpersonateSessionUser imp( hToken );

        // Either SetCommandTree or SetCommandText should have already been called

        if ( 0 == _pQueryTree )
        {
            if ( IsCommandSet() )
            {
                //
                // No query tree.  Build one from the command text if one has been set.
                //
                scResult = BuildTree( );

                if ( DB_S_NORESULT == scResult )
                    return scResult;

                _dwStatus |= CMD_TREE_BUILT;
            }
            else
                THROW( CException(DB_E_NOCOMMAND) );
        }

        _dwStatus |= CMD_EXEC_RUNNING;

        //
        // Convert the tree into restriction, etc.
        // The pParams should probably be passed to the ctor of
        // the parser (when we do parameterized queries).
        //
        CParseCommandTree   Parse;
        Parse.ParseTree( _pQueryTree );

        XGrowable<const WCHAR *,SCOPE_COUNT_GROWSIZE> xaScopes( SCOPE_COUNT_GROWSIZE );
        XGrowable<ULONG,SCOPE_COUNT_GROWSIZE>         xaFlags( SCOPE_COUNT_GROWSIZE );
        XGrowable<const WCHAR *,SCOPE_COUNT_GROWSIZE> xaCatalogs( SCOPE_COUNT_GROWSIZE );
        XGrowable<const WCHAR *,SCOPE_COUNT_GROWSIZE> xaMachines( SCOPE_COUNT_GROWSIZE );
        unsigned cScopes = 0;

        Parse.GetScopes( cScopes, xaScopes, xaFlags, xaCatalogs, xaMachines );
        
        // If the tree had a DBOP_tree node instead of a DBOP_content_table, we can't
        // parse scope information from the tree. The client is responsible for 
        // setting scope properties.  Currently, this means the Tripolish parser
        if ( 0 < cScopes )
        {
            SetScopeProperties( this,
                                cScopes,
                                xaScopes.Get(),
                                xaFlags.Get(),
                                xaCatalogs.Get(),
                                xaMachines.Get() );
        }

        CRestriction * pCrst = Parse.GetRestriction();
        CCategorizationSet & categ = Parse.GetCategorization();

        unsigned cRowsets = 1;
        if ( 0 != categ.Count() )
            cRowsets += categ.Count();

        if (Parse.GetOutputColumns().Count() == 0)
            THROW( CException(DB_E_ERRORSINCOMMAND) );

        XArray<IUnknown *> Unknowns( cRowsets );

        //
        // If it appears the server went down between the time we made
        // the connection and did the execute, attempt once to
        // re-establish the connection.
        //

        int cTries = 1;
        XPtr<CMRowsetProps> xProps;

        do
        {
            //
            // Use a copy of the properties so the command object isn't
            // affected by the implied properties.  xProps may be acquired
            // in a failed loop if the server disconnects just before the
            // setbindings call.
            //

            if ( xProps.IsNull() )
            {
                xProps.Set( new CMRowsetProps( _RowsetProps ) );
        
                xProps->SetImpliedProperties( riid, cRowsets );
        
                //
                // Check if there are any properties in error. If properties are found
                // to be in error, indicate this on _RowsetProps.
                //
                scResult = xProps->ArePropsInError( _RowsetProps );
        
                if ( S_OK != scResult )
                    return scResult;
        
                if ( Parse.GetMaxResults() > 0 )
                    xProps->SetValLong( CMRowsetProps::eid_DBPROPSET_ROWSET,
                                        CMRowsetProps::eid_PROPVAL_MAXROWS,
                                        Parse.GetMaxResults() );
                
                if ( Parse.GetFirstRows() > 0 )
                    xProps->SetFirstRows( Parse.GetFirstRows() );
            }

            if ( !HaveQuery() )
                _pInternalQuery = QueryInternalQuery();

            SCODE scEx = S_OK;

            TRY
            {
                //
                // Used for GetSpecification on the rowset
                //
                IUnknown * pCreatorUnk = 0;
                if ( IsGenByOpenRowset() )
                {
                    Win4Assert( !_xSession.IsNull() );
                    pCreatorUnk = _xSession->GetOuterUnk();
                }
                else
                {
                    pCreatorUnk = (IUnknown *) _pControllingUnknown;
                }

                Win4Assert( 0 != xProps.GetPointer() );

                _pInternalQuery->Execute( pOuterUnk,
                                          pCrst ? pCrst->CastToStruct() : 0,  // Restrictions
                                          Parse.GetPidmap(),
                                          Parse.GetOutputColumns(), // Output columns
                                          Parse.GetSortColumns(),   // Sort Order
                                          xProps,
                                          categ,                    // Categorization
                                          cRowsets,
                                          Unknowns.GetPointer(),    // Return interfaces
                                          _aAccessors,
                                          pCreatorUnk);
            }
            CATCH( CException, e )
            {
                scEx = e.GetErrorCode();
                if ( ( STATUS_CONNECTION_DISCONNECTED != scEx ) ||
                     ( cTries > 1 ) )
                    RETHROW();
            }
            END_CATCH;

            if ( STATUS_CONNECTION_DISCONNECTED == scEx )
            {
                Win4Assert( 1 == cTries );
                cTries++;
                ReleaseInternalQuery();
                continue;
            }
            else
            {
                Win4Assert( S_OK == scEx );
                break;
            }
        }
        while ( TRUE );

        // release these categorized rowsets -- they are addref'ed when the
        // client does a getreferencedrowset

        for ( unsigned x = 1; x < cRowsets; x++ )
            Unknowns[ x ]->Release();

        XInterface<IUnknown> xUnknown( Unknowns[0] );

        if (IID_IUnknown == riid)
        {
            *ppRowset = xUnknown.GetPointer();
            xUnknown.Acquire();
        }
        else
        {
            if (IID_NULL != riid)
                scResult = xUnknown->QueryInterface( riid, (void **)ppRowset );

            Win4Assert( S_OK == scResult );     // should have failed earlier
            if (FAILED(scResult))
                THROW( CException(scResult) );
        }

        _dwStatus &= ~(CMD_EXEC_RUNNING);

        imp.Revert();
    }
    CATCH( CException, e )
    {
        //
        // Can't use PostHResult( e...) here because the final SCODE may get translated
        //
        scResult = e.GetErrorCode();

        vqDebugOut(( DEB_ERROR, "Exception %08x while creating query\n", scResult ));

        if ( QUERY_E_INVALIDRESTRICTION == scResult )
            scResult = DB_E_ERRORSINCOMMAND;

        //
        // In the case of OpenRowset, don't want to Post DB_E_ERRORSINCOMMAND
        //
        if ( _fGenByOpenRowset )
        {
            if( scResult == DB_E_ERRORSINCOMMAND )
                scResult = DB_E_NOTABLE;
        }

       _DBErrorObj.PostHResult( scResult, guidPost );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    #if CIDBG == 1
        if ( ( S_OK == scResult ) && ( IID_NULL != riid ) )
            Win4Assert( 0 != *ppRowset );
    #endif

    return scResult;
}

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::Cancel, public
//
//  Synopsis:   The consumer can allocate a secondary thread in which to cancel
//              the currently executing thread.  This cancel will only succeed
//              if the result set is still being generated.  If the rowset
//              object is being created, then it will be to late to cancel.
//
//  History:    11-20-97    danleg      Created
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::Cancel( void )
{
    _DBErrorObj.ClearErrorInfo();

    if( 0 == (_dwStatus & CMD_EXEC_RUNNING) )
        return S_OK;

    return _DBErrorObj.PostHResult(DB_E_CANTCANCEL, IID_ICommand);
}


#if 0 // ICommandValidate not yet implemented
//
//  ICommandValidate methods
//
SCODE CRootQuerySpec::ValidateCompletely( void )
{
    _DBErrorObj.ClearErrorInfo();
    vqDebugOut(( DEB_WARN, "CRootQuerySpec::ValidateCompletely not implemented\n" ));
    return PostHResult(E_NOTIMPL, IID_ICommandValidate);
}

SCODE CRootQuerySpec::ValidateSyntax( void )
{
    _DBErrorObj.ClearErrorInfo();
    vqDebugOut(( DEB_WARN, "CRootQuerySpec::ValidateSyntax not implemented\n" ));
    return PostHResult(E_NOTIMPL, IID_ICommandValidate);
}
#endif // 0


//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::GetDBSession, public
//
//  Synopsis:   Return the session object associated with this command
//
//  Arguments:  [riid]      -- IID of the desired interface
//              [ppSession] -- pointer to where to return interface pointer
//
//  History:    11-20-97    danleg      Created
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::GetDBSession(
    REFIID      riid,
    IUnknown ** ppSession )
{
    _DBErrorObj.ClearErrorInfo();

    if (0 == ppSession)
        return _DBErrorObj.PostHResult(E_INVALIDARG, IID_ICommand);

    SCODE   sc = S_OK;

    if ( !_xSession.IsNull() )
    {
        sc = (_xSession->GetOuterUnk())->QueryInterface( riid, (void **) ppSession );
    }
    else  // there was no session object
    {
        *ppSession = 0;
        sc = S_FALSE;
    }

    return sc;
}

//
// ICommandText methods
//

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::GetCommandText, public
//
//  Synopsis:   Echos the current command as text, including all
//              post-processing operations added.
//
//  Arguments:  [pguidDialect] -- Guid denoting the dialect of SQL
//              [ppwszCommand] -- Pointer to mem where to return command text
//
//  History:    10-01-97   danleg       Created from Monarch
//
//----------------------------------------------------------------------------

STDMETHODIMP CRootQuerySpec::GetCommandText
    (
    GUID *      pguidDialect,       //@parm INOUT | Guid denoting the dialect of sql
    LPOLESTR *  ppwszCommand        //@parm OUT | Pointer for the command text
    )
{
    SCODE       sc = S_OK;
    BOOL        fpguidNULL = FALSE;
    GUID        guidDialect;

    _DBErrorObj.ClearErrorInfo();

    CLock lck( _mtxCmd );

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        if( 0 == ppwszCommand )
        {
            THROW( CException(E_INVALIDARG) );
        }
        else
        {
            *ppwszCommand = 0;

            // Substitute a correct GUID for a NULL pguidDialect
            if( !pguidDialect )
            {
                guidDialect = DBGUID_SQL;
                pguidDialect = &guidDialect;

                // Don't return DB_S_DIALECTIGNORED in this case...
                fpguidNULL = TRUE;
            }

            // If the command has not been set, make sure the buffer
            // contains an empty string to return to the consumer
            if( !IsCommandSet() )
            {
                THROW( CException(DB_E_NOCOMMAND) );

            }
            else
            {
                // Allocate memory for the string we're going to return to the caller
                XArrayOLE<WCHAR> xwszCommand( wcslen(_pwszSQLText) + 1 ) ;

                // Copy our saved text into the newly allocated string
                wcscpy(xwszCommand.GetPointer(), _pwszSQLText);

                // If the text we're giving back is a different dialect than was
                // requested, let the caller know what dialect the text is in
                if( !fpguidNULL && _guidCmdDialect != *pguidDialect )
                {
                    *pguidDialect = _guidCmdDialect;
                    sc = DB_S_DIALECTIGNORED;
                }
                *ppwszCommand = xwszCommand.Acquire();
            }
        }
    }
    CATCH( CException, e )
    {
        sc  = _DBErrorObj.PostHResult( e, IID_ICommandText );
        if( pguidDialect )
            RtlZeroMemory( pguidDialect, sizeof(GUID) );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}


//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::SetCommandText, public
//
//  Synopsis:   Sets the current command text..
//
//  Arguments:  [rguidDialect] -- Guid denoting the dialect of SQL
//              [pwszCommand]  -- Command Text
//
//  History:    10-01-97   danleg       Created from Monarch
//
//----------------------------------------------------------------------------

STDMETHODIMP CRootQuerySpec::SetCommandText
    (
    REFGUID     rguidDialect,
    LPCOLESTR   pwszCommand
    )
{
    SCODE sc = S_OK;

    // Clear previous Error Object for this thread
    _DBErrorObj.ClearErrorInfo();

    CLock lck( _mtxCmd );

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        // Don't allow text to be set if we've got a rowset open
        if( !IsRowsetOpen() )
        {
            // Check Dialect
            if( rguidDialect == DBGUID_SQL || rguidDialect == DBGUID_DEFAULT )
            {
                //
                // Delete existing SQL text
                //
                delete [] _pwszSQLText;
                _pwszSQLText = 0;

                //
                // Delete Command Tree
                //
                delete _pQueryTree;
                _pQueryTree = 0;

                if( (0 == pwszCommand) || (L'\0' == *pwszCommand) )
                {
                    _guidCmdDialect  = DBGUID_SQL;
                    _dwStatus       &= ~CMD_TEXT_SET;
                    _dwStatus       &= ~CMD_COLINFO_NOTPREPARED;
                }
                else
                {
                    //
                    // Save the text and dialect
                    //
                    XArray<WCHAR> xwszSQLText( wcslen(pwszCommand) + 1 );
                    wcscpy(xwszSQLText.GetPointer(), pwszCommand);
                    _pwszSQLText = xwszSQLText.Acquire();

                    _guidCmdDialect = rguidDialect;

                    // Set status flag that we have set text
                    _dwStatus      |= CMD_TEXT_SET;
                    _dwStatus      |= CMD_COLINFO_NOTPREPARED;
                }

                if ( _pColumnsInfo )
                    InitColumns( );

                _dwStatus &= ~CMD_TEXT_PREPARED;
                _dwStatus &= ~CMD_TREE_BUILT;

                // Whenever new text is set on the Command Object,
                // the value for QUERY_RESTRICTION should be set to
                // an empty string

                _RowsetProps.SetValString(
                    CMRowsetProps::eid_DBPROPSET_MSIDXS_ROWSET_EXT,
                    CMRowsetProps::eid_MSIDXSPROPVAL_QUERY_RESTRICTION,
                    L"");
            }
            else
            {
                THROW( CException(DB_E_DIALECTNOTSUPPORTED) );
            }
        }
        else
        {
            THROW( CException(DB_E_OBJECTOPEN) );
        }
    }
    CATCH( CException, e )
    {
        sc  = _DBErrorObj.PostHResult( e, IID_ICommandText );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//
// ICommandPrepare methods
//
//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::Prepare, public
//
//  Synopsis:   Given that a SQL text has been set, prepare the statement
//
//  History:    10-31-97   danleg       Created from Monarch
//
//----------------------------------------------------------------------------

STDMETHODIMP CRootQuerySpec::Prepare
    (
    ULONG     cExpectedRuns
    )
{
    SCODE sc = S_OK;

    // Clear previous Error Object for this thread
    _DBErrorObj.ClearErrorInfo();

    CLock lck( _mtxCmd );

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        // Don't allow a new prepare with an open rowset
        if( !IsRowsetOpen() )
        {
            if( IsCommandSet() )
            {
                //
                // Don't build the tree again if it was built as a result of
                // GetCommandTree or Execute, and we haven't done a SetCommandText
                // since.
                //
                if ( !(_dwStatus & CMD_TREE_BUILT) )
                {
                    // Impersonate the session logon user

                    HANDLE hToken = INVALID_HANDLE_VALUE;

                    if ( !_xSession.IsNull() )
                         hToken = _xSession->GetLogonToken();

                    CImpersonateSessionUser imp( hToken );

                    sc = BuildTree( );

                    if ( DB_S_NORESULT == sc )
                        return sc;

                    _dwStatus |= CMD_TEXT_PREPARED;

                    if ( _pColumnsInfo )
                        InitColumns();

                    imp.Revert();
                }

            }
            else
                sc = DB_E_NOCOMMAND;
        }
        else
        {
            sc = DB_E_OBJECTOPEN;
        }
    }
    CATCH( CException, e )
    {
        sc = _DBErrorObj.PostHResult( e, IID_ICommandText );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::Unprepare, public
//
//  Synopsis:   Unprepare the current prepared command plan, if there is one.
//
//  History:    10-31-97   danleg       Created from Monarch
//
//----------------------------------------------------------------------------
STDMETHODIMP CRootQuerySpec::Unprepare
    (
    )
{
    SCODE sc = S_OK;

    // Clear previous Error Object for this thread
    _DBErrorObj.ClearErrorInfo();

    CLock lck( _mtxCmd );

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        if( !IsRowsetOpen() )
        {
            _dwStatus &= ~CMD_TEXT_PREPARED;
            _dwStatus |= CMD_COLINFO_NOTPREPARED;

            if ( _pColumnsInfo )
                InitColumns( );
        }
        else
            THROW( CException(DB_E_OBJECTOPEN) );
    }
    CATCH( CException, e )
    {
        sc = _DBErrorObj.PostHResult( e, IID_ICommandPrepare );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}


//
//  IQuery methods
//

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::AddPostProcessing, public
//
//  Synopsis:   Add to the top of a command tree
//
//  Arguments:  [ppRoot] -- DBCOMMANDTREE node at root of tree
//              [fCopy]  - TRUE if command tree should be copied
//
//  History:    29 Jun 95   AlanW       Created
//
//----------------------------------------------------------------------------

BOOL CheckForPriorTree( const CDbCmdTreeNode *pNode )
{
    return pNode->GetCommandType() == DBOP_prior_command_tree;
}

SCODE CRootQuerySpec::AddPostProcessing(
    DBCOMMANDTREE * *      ppRoot,
    BOOL                   fCopy)
{
    _DBErrorObj.ClearErrorInfo();

    // OLEDB spec. bug #????; fCopy is non-sensical
    if (0 == ppRoot || FALSE == fCopy)
        return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IQuery);

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        _CheckRootNode( *ppRoot );

        XPtr<CDbCmdTreeNode> TreeCopy( CDbCmdTreeNode::CastFromStruct(*ppRoot)->Clone() );
        if (0 == TreeCopy.GetPointer())
            THROW(CException(E_OUTOFMEMORY));

        ULONG cNodes = 0;
        XArrayOLE<DBCOMMANDTREE *> pNodes;

        _FindTreeNodes( TreeCopy.GetPointer(),
                        cNodes,
                        pNodes,
                        CheckForPriorTree );

        if (cNodes != 1)
        {
            vqDebugOut((DEB_WARN, "CRootQuerySpec::AddPostProcessing - "
                                   "%d references to prior tree found\n",
                                cNodes));
            THROW(CException(E_INVALIDARG));    // DB_E_BADCOMMANDTREE???
        }

        //
        //  The command tree node with DBOP_prior_command_tree can have
        //  siblings, but it must not have any children.
        //  Likewise, the original command tree can have children, but it
        //  must not have any siblings.
        //  Splice the trees together by copying the root node of the
        //  original tree onto the DBOP_prior_command_tree node, then
        //  freeing the orginal root node.
        //
        if (pNodes[0]->pctFirstChild != 0 ||
            pNodes[0]->wKind != DBVALUEKIND_EMPTY)
            THROW(CException(E_INVALIDARG));    // DB_E_BADCOMMANDTREE???

        // Perhaps we should just substitute a DBOP_table_identifier
        // node with default table in this case.

        if (0 == _pQueryTree)
            THROW(CException(E_INVALIDARG));    // DB_E_NOCOMMANDTREE???

        //
        //  Transfer the pointers and values from the root node
        //  to the prior_command_tree node.
        //

        _pQueryTree->TransferNode( CDbCmdTreeNode::CastFromStruct(pNodes[0]) );
        Win4Assert(0 == _pQueryTree->GetFirstChild() &&
                   0 == _pQueryTree->GetNextSibling() &&
                   DBVALUEKIND_EMPTY == _pQueryTree->GetValueType());

        delete _pQueryTree;
        _pQueryTree = TreeCopy.Acquire();
    }
    CATCH( CException, e )
    {
        sc = _DBErrorObj.PostHResult( e, IID_IQuery );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::GetCardinalityEstimate, public
//
//  Synopsis:   Get estimated cardinality of the query tree
//
//  Arguments:  [pulCardinality] -- Pointer to memory to hold cardinality
//
//  History:    29 Jun 95   AlanW       Created
//              2 May  97   KrishnaN    Added this header block
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::GetCardinalityEstimate(
    DBORDINAL *       pulCardinality)
{
    _DBErrorObj.ClearErrorInfo();
    vqDebugOut(( DEB_WARN, "CRootQuerySpec::GetCardinalityEstimate not implemented\n" ));
    return _DBErrorObj.PostHResult(S_FALSE, IID_IQuery);
}

//
//  ICommandProperties methods
//

//+---------------------------------------------------------------------------
//
//  Method:     DetermineScodeIndex
//
//  Synopsis:   Returns an index into a static array of SCODEs
//
//              NOTE: This function will go away once CRowsetProperties and
//                    CMRowsetProps are merged completely.
//
//  Arguments:  [sc]    - SCODE for which an index is returned
//
//  History:     01-05-98       danleg      Created
//
//----------------------------------------------------------------------------

inline ULONG DetermineScodeIndex
    (
    SCODE sc
    )
{
    switch( sc )
    {
        case S_OK:                  return 0;
        case DB_S_ERRORSOCCURRED:   return 1;
        case E_FAIL:
        default:                    return 2;
        case E_INVALIDARG:          return 3;
        case E_OUTOFMEMORY:         return 4;
        case DB_E_ERRORSOCCURRED:   return 5;
    }
}

//+---------------------------------------------------------------------------
//
//  Method:     DetermineNewSCODE
//
//  Synopsis:   Given two SCODEs returned by the two property handling
//              mechanisms used, returned a resultant SCODE to return from
//              Get/SetProperties.
//
//              NOTE: This function will go away once CRowsetProperties and
//                    CMRowsetProps are merged completely.
//
//  Arguments:
//
//  History:     01-05-98       danleg      Created
//
//----------------------------------------------------------------------------

SCODE DetermineNewSCODE
    (
    SCODE   sc1,
    SCODE   sc2
    )
{
    ULONG   isc1 = DetermineScodeIndex(sc1),
            isc2 = DetermineScodeIndex(sc2);

static const SCODE  s_rgPropHresultMap[6][6] =
    {
        {S_OK,                  DB_S_ERRORSOCCURRED,    E_FAIL, E_INVALIDARG,   E_OUTOFMEMORY,  DB_S_ERRORSOCCURRED},
        {DB_S_ERRORSOCCURRED,   DB_S_ERRORSOCCURRED,    E_FAIL, E_INVALIDARG,   E_OUTOFMEMORY,  DB_S_ERRORSOCCURRED},
        {E_FAIL,                E_FAIL,                 E_FAIL, E_FAIL,         E_FAIL,         E_FAIL},
        {E_INVALIDARG,          E_INVALIDARG,           E_FAIL, E_INVALIDARG,   E_INVALIDARG,   E_INVALIDARG},
        {E_OUTOFMEMORY,         E_OUTOFMEMORY,          E_FAIL, E_OUTOFMEMORY,  E_OUTOFMEMORY,  E_OUTOFMEMORY},
        {DB_S_ERRORSOCCURRED,   DB_S_ERRORSOCCURRED,    E_FAIL, E_INVALIDARG,   E_OUTOFMEMORY,  DB_E_ERRORSOCCURRED},
    };

    return s_rgPropHresultMap[isc1][isc2];
}

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::GetProperties, public
//
//  Synopsis:   Get rowset properties
//
//  Arguments:  [cPropertySetIDs]    - number of desired properties or 0
//              [rgPropertySetIDs]   - array of desired properties or NULL
//              [pcPropertySets]     - number of property sets returned
//              [prgPropertySets]    - array of returned property sets
//
//  History:     16 Nov 95   AlanW       Created
//               02-22-98    danleg      Changed to use CMRowsetProps
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::GetProperties(
    const ULONG       cPropertySetIDs,
    const DBPROPIDSET rgPropertySetIDs[],
    ULONG *           pcPropertySets,
    DBPROPSET **      prgPropertySets)
{
    _DBErrorObj.ClearErrorInfo();

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        _RowsetProps.GetPropertiesArgChk( cPropertySetIDs,
                                          rgPropertySetIDs,
                                          pcPropertySets,
                                          prgPropertySets );

        sc = _RowsetProps.GetProperties( cPropertySetIDs,
                                         rgPropertySetIDs,
                                         pcPropertySets,
                                         prgPropertySets );
    }
    CATCH( CException, e )
    {
        //
        // Don't PostHResult here.  Let the caller do the posting.
        //
        sc = _DBErrorObj.PostHResult( e, IID_ICommandProperties );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
} //GetProperties

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::SetProperties, public
//
//  Synopsis:   Set rowset properties
//
//  Arguments:  [cPropertySets]  - number of property sets
//              [rgProperties]   - array of property sets to be set
//
//  History:     16 Nov 95   AlanW       Created
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::SetProperties(
    ULONG                  cPropertySets,
    DBPROPSET              rgPropertySets[])
{
    _DBErrorObj.ClearErrorInfo();

    if ( HaveQuery() && _pInternalQuery->IsQueryActive() )
        return _DBErrorObj.PostHResult(DB_E_OBJECTOPEN, IID_ICommandProperties);

    //
    // Quick return
    //
    if( cPropertySets == 0 )
        return S_OK;

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {

        CUtlProps::SetPropertiesArgChk( cPropertySets, rgPropertySets );

        if ( IsRowsetOpen() )
            THROW( CException(DB_E_OBJECTOPEN) );

        DWORD dwPropFlags = _RowsetProps.GetPropertyFlags();

        sc = _RowsetProps.SetProperties( cPropertySets, rgPropertySets );

        if ( SUCCEEDED( sc ) )
        {
            if ( _pColumnsInfo &&
                 _RowsetProps.GetPropertyFlags() != dwPropFlags )
                InitColumns();
        }
    }
    CATCH( CException, e )
    {
        //
        // Don't PostHResult here.  Let the caller do the posting.
        //

        sc = e.GetErrorCode();
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//
//  IServiceProperties methods
//

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::GetPropertyInfo, public
//
//  Synopsis:   Get rowset properties
//
//  Arguments:  [cPropertySetIDs]    - number of desired properties or 0
//              [rgPropertySetIDs]   - array of desired properties or NULL
//              [pcPropertySets]     - number of property sets returned
//              [prgPropertySets]    - array of returned property sets
//              [ppwszDesc]          - if non-zero, property descriptions are
//                                     returneed
//
//  History:     16 Nov 95   AlanW       Created
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::GetPropertyInfo(
    const ULONG            cPropertySetIDs,
    const DBPROPIDSET      rgPropertySetIDs[],
    ULONG *                pcPropertySets,
    DBPROPINFOSET **       prgPropertySets,
    WCHAR **               ppwszDesc)
{
    if ( (0 != cPropertySetIDs && 0 == rgPropertySetIDs) ||
          0 == pcPropertySets ||
          0 == prgPropertySets )
    {
        if (pcPropertySets)
           *pcPropertySets = 0;
        if (prgPropertySets)
           *prgPropertySets = 0;
        return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IServiceProperties);
    }

    SCODE sc = S_OK;
    *pcPropertySets = 0;
    *prgPropertySets = 0;
    if (ppwszDesc)
       *ppwszDesc = 0;


    TRANSLATE_EXCEPTIONS;
    TRY
    {
        sc = _PropInfo.GetPropertyInfo( cPropertySetIDs,
                                        rgPropertySetIDs,
                                        pcPropertySets,
                                        prgPropertySets,
                                        ppwszDesc );

        // Don't PostHResult here -- it's a good chance it's a scope
        // property that we're expecting to fail.  Spare the expense.
        // The child object will post the error for us.
    }
    CATCH( CException, e )
    {
        _DBErrorObj.PostHResult(e.GetErrorCode(), IID_IServiceProperties);
        sc = GetOleError(e);

    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::SetRequestedProperties, public
//
//  Synopsis:   Set rowset properties
//
//  Arguments:  [cPropertySets]  - number of property sets
//              [rgProperties]   - array of property sets to be set
//
//  History:    16 Nov 95   AlanW       Created
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::SetRequestedProperties(
    ULONG                  cPropertySets,
    DBPROPSET              rgPropertySets[])
{
    if ( HaveQuery() && _pInternalQuery->IsQueryActive() )
        return _DBErrorObj.PostHResult(DB_E_OBJECTOPEN, IID_IServiceProperties);

    if ( 0 != cPropertySets && 0 == rgPropertySets)
        return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IServiceProperties);

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        sc = _RowsetProps.SetProperties( cPropertySets,
                                         rgPropertySets );

        // Don't PostHResult here -- it's a good chance it's a scope
        // property that we're expecting to fail.  Spare the expense.
        // The child object will post the error for us.
    }
    CATCH( CException, e )
    {
        _DBErrorObj.PostHResult(e.GetErrorCode(), IID_IServiceProperties);
        sc = GetOleError(e);
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::SetSuppliedProperties, public
//
//  Synopsis:   Set rowset properties
//
//  Arguments:  [cPropertySets]  - number of property sets
//              [rgProperties]   - array of property sets to be set
//
//  History:     16 Nov 95   AlanW       Created
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::SetSuppliedProperties(
    ULONG                  cPropertySets,
    DBPROPSET              rgPropertySets[])
{
    if ( HaveQuery() && _pInternalQuery->IsQueryActive() )
        return _DBErrorObj.PostHResult(DB_E_OBJECTOPEN, IID_IServiceProperties);

    if ( 0 != cPropertySets && 0 == rgPropertySets)
        return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IServiceProperties);

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        sc = _RowsetProps.SetProperties( cPropertySets,
                                         rgPropertySets );

        // Don't PostHResult here -- it's a good chance it's a scope
        // property that we're expecting to fail.  Spare the expense.
        // The child object will post the error for us.
    }
    CATCH( CException, e )
    {
        _DBErrorObj.PostHResult(e.GetErrorCode(), IID_IServiceProperties);
        sc = GetOleError(e);
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}


//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::_CheckRootNode, private
//
//  Synopsis:   Check a client's root node for validity
//
//  Arguments:  [pRoot] -- DBCOMMANDTREE node at root of tree
//
//  Notes:      A command tree root node may have children, but it
//              may not have siblings.
//
//  History:    29 Jun 95   AlanW       Created
//
//----------------------------------------------------------------------------

void CRootQuerySpec::_CheckRootNode(
    const DBCOMMANDTREE *  pRoot)
{
    if (pRoot->pctNextSibling)
        THROW(CException(E_INVALIDARG)); 
}


//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::GetColumnsInfo, private
//
//  Synopsis:   Create an IColumnsInfo* for the columns in the query tree
//
//  Arguments:  -none-
//
//  Returns:    CColumnsInfo* - a pointer to a CColumnsInfo that implements
//                              IColumnsInfo.
//
//----------------------------------------------------------------------------

static GUID guidBmk = DBBMKGUID;

CColumnsInfo * CRootQuerySpec::GetColumnsInfo()
{
    if ( 0 == _pColumnsInfo )
    {
        _pColumnsInfo = new CColumnsInfo( *((IUnknown *) (ICommand *) this),
                                          _DBErrorObj, FALSE );

        InitColumns( );
    }

    return _pColumnsInfo;
}


//+---------------------------------------------------------------------------
//
//  Method:     CRootQuerySpec::InitColumns, private
//
//  Synopsis:   Reinitialize the columns associated with the CColumnsInfo
//
//  Arguments:  -none-
//
//----------------------------------------------------------------------------

void CRootQuerySpec::InitColumns( )
{
    if ( _pQueryTree && !(_dwStatus & CMD_COLINFO_NOTPREPARED) )
    {
        BOOL fSequential = TRUE;        // need to know for CColumnsInfo ctor
        //
        // Fault-in columnsinfo.
        //
        CParseCommandTree   Parse;
        Parse.ParseTree( _pQueryTree );

        CCategorizationSet & rCateg = Parse.GetCategorization();
        CPidMapperWithNames & pidmap = Parse.GetPidmap();
        CColumnSet const * pColSet = &Parse.GetOutputColumns();

        if ( 0 != rCateg.Count() )
        {
            //
            // Ole-db spec says that for categorization, we must use the
            // top-level columns only.
            //
            pColSet = &(rCateg.Get(0)->GetColumnSet());
        }

        for ( unsigned i = 0; i < pColSet->Count(); i++ )
        {
            CFullPropSpec const * pPropSpec = pidmap.PidToName( pColSet->Get(i));
            if (pPropSpec->IsPropertyPropid() &&
                pPropSpec->GetPropertyPropid() == PROPID_DBBMK_BOOKMARK &&
                pPropSpec->GetPropSet() == guidBmk)
               fSequential = FALSE;
        }

        if ( _RowsetProps.GetPropertyFlags() &
             ( eLocatable | eScrollable ) )
            fSequential = FALSE;

        _pColumnsInfo->InitColumns( *pColSet,
                                    pidmap,
                                    fSequential );
    }
    else
    {
        _pColumnsInfo->InitColumns( (_dwStatus & CMD_COLINFO_NOTPREPARED) );
    }
}


//+---------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::CreateAccessor
//
//  Synopsis:   Makes an accessor that a client can use to get data.
//
//  Arguments:  [dwAccessorFlags]  -- read/write access requested
//              [cBindings]    -- # of bindings in rgBindings
//              [rgBindings]   -- array of bindings for the accessor to support
//              [cbRowSize]    -- ignored for IRowset
//              [phAccessor]   -- returns created accessor if all is ok
//              [rgBindStatus] -- array of binding statuses
//
//  Returns:    SCODE error code
//
//  History:    11-07-95   srikants   Created
//
//  Notes:
//
//----------------------------------------------------------------------------

STDMETHODIMP CRootQuerySpec::CreateAccessor(
    DBACCESSORFLAGS     dwAccessorFlags,
    DBCOUNTITEM         cBindings,
    const DBBINDING     rgBindings[],
    DBLENGTH            cbRowSize,
    HACCESSOR *         phAccessor,
    DBBINDSTATUS        rgBindStatus[])
{
    _DBErrorObj.ClearErrorInfo();

    SCODE sc = S_OK;

    if (0 == phAccessor || (0 != cBindings && 0 == rgBindings))
        return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IAccessor);

    // Make sure pointer is good while zeroing in case of a later error

    *phAccessor = 0;


    TRANSLATE_EXCEPTIONS;
    TRY
    {
        CColumnsInfo * pColumnsInfo = 0;

        XPtr<CRowDataAccessor> Accessor(new CRowDataAccessor(dwAccessorFlags,
                                                             cBindings,
                                                             rgBindings,
                                                             rgBindStatus,
                                   (_RowsetProps.GetPropertyFlags() & eExtendedTypes) != 0,
                                                             (IUnknown *) (ICommand *) this,
                                                             pColumnsInfo
                                                             ));
        CLock lck( _mtxCmd );

        _aAccessors.Add( Accessor.GetPointer() );

        *phAccessor = (Accessor.Acquire())->Cast();
    }
    CATCH(CException, e)
    {
        sc = _DBErrorObj.PostHResult( e, IID_IAccessor );
        _DBErrorObj.PostHResult( sc, IID_IAccessor );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::GetBindings, private
//
//  Synopsis:   Returns an accessor's bindings
//
//  Arguments:  [hAccessor]   -- accessor being queried
//              [dwAccessorFlags] -- returns read/write access of accessor
//              [pcBindings]  -- returns # of bindings in rgBindings
//              [prgBindings] -- returns array of bindings
//
//  Returns:    SCODE error code
//
//  History:    14 Dec 94       dlee   Created
//
//----------------------------------------------------------------------------

STDMETHODIMP CRootQuerySpec::GetBindings(
    HACCESSOR         hAccessor,
    DBACCESSORFLAGS * pdwAccessorFlags,
    DBCOUNTITEM *     pcBindings,
    DBBINDING * *     prgBindings) /*const*/
{
    _DBErrorObj.ClearErrorInfo();

    SCODE sc = S_OK;

    if (0 == pdwAccessorFlags ||
        0 == pcBindings ||
        0 == prgBindings)
    {
        // fill in error values where possible
        if (pdwAccessorFlags)
           *pdwAccessorFlags = DBACCESSOR_INVALID;
        if (pcBindings)
           *pcBindings = 0;
        if (prgBindings)
           *prgBindings = 0;

        return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IAccessor);
    }

    *pdwAccessorFlags = DBACCESSOR_INVALID;
    *pcBindings = 0;
    *prgBindings = 0;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        CLock lck( _mtxCmd );
        CAccessor * pAccessor = (CAccessor *)_aAccessors.Convert( hAccessor );
        pAccessor->GetBindings(pdwAccessorFlags, pcBindings, prgBindings);
    }
    CATCH(CException, e)
    {
        sc = _DBErrorObj.PostHResult( e, IID_IAccessor );
        _DBErrorObj.PostHResult( sc, IID_IAccessor );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;


    return sc;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::AddRefAccessor, private
//
//  Synopsis:   Frees an accessor
//
//  Arguments:  [hAccessor]   -- accessor being freed
//              [pcRefCount]  -- pointer to residual refcount (optional)
//
//  Returns:    SCODE error code
//
//  History:    14 Dec 94       dlee   Created
//
//----------------------------------------------------------------------------

STDMETHODIMP CRootQuerySpec::AddRefAccessor(
    HACCESSOR   hAccessor,
    ULONG *     pcRefCount )
{
    _DBErrorObj.ClearErrorInfo();

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        CLock lck( _mtxCmd );
        _aAccessors.AddRef( hAccessor, pcRefCount );
    }
    CATCH(CException, e)
    {
        sc = _DBErrorObj.PostHResult( e, IID_IAccessor );
        _DBErrorObj.PostHResult(sc, IID_IAccessor);
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::ReleaseAccessor, private
//
//  Synopsis:   Frees an accessor
//
//  Arguments:  [hAccessor]   -- accessor being freed
//              [pcRefCount]  -- pointer to residual refcount (optional)
//
//  Returns:    SCODE error code
//
//  History:    14 Dec 94       dlee   Created
//
//----------------------------------------------------------------------------

STDMETHODIMP CRootQuerySpec::ReleaseAccessor(
    HACCESSOR   hAccessor,
    ULONG *     pcRefCount )
{
    _DBErrorObj.ClearErrorInfo();

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        CLock lck( _mtxCmd );
        _aAccessors.Release( hAccessor, pcRefCount );
    }
    CATCH(CException, e)
    {
        sc = _DBErrorObj.PostHResult( e, IID_IAccessor );
        _DBErrorObj.PostHResult(sc, IID_IAccessor);
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::CanConvert, public
//
//  Synopsis:   Indicate whether a type conversion is valid.
//
//  Arguments:  [wFromType]      -- source type
//              [wToType]        -- destination type
//              [dwConvertFlags] -- read/write access requested
//
//  Returns:    S_OK if the conversion is available, S_FALSE otherwise.
//              E_FAIL, E_INVALIDARG or DB_E_BADCONVERTFLAG on errors.
//
//  History:    20 Nov 96      AlanW    Created
//              14 Jan 98      VikasMan Passed IDataConvert(OLE-DB data conv.
//                                      interface) to CanConvertType
//
//----------------------------------------------------------------------------

STDMETHODIMP CRootQuerySpec::CanConvert( DBTYPE wFromType, DBTYPE wToType, DBCONVERTFLAGS dwConvertFlags )
{
    _DBErrorObj.ClearErrorInfo();

    SCODE sc = S_OK;

    TRANSLATE_EXCEPTIONS;
    TRY
    {
        if (((dwConvertFlags & DBCONVERTFLAGS_COLUMN) &&
             (dwConvertFlags & DBCONVERTFLAGS_PARAMETER)) ||
            (dwConvertFlags & ~(DBCONVERTFLAGS_COLUMN |
                                DBCONVERTFLAGS_PARAMETER |
                                DBCONVERTFLAGS_ISFIXEDLENGTH |
                                DBCONVERTFLAGS_ISLONG |
                                DBCONVERTFLAGS_FROMVARIANT)))
        {
            sc = DB_E_BADCONVERTFLAG;
        }
        else if ( ( dwConvertFlags & DBCONVERTFLAGS_FROMVARIANT ) &&
                  !IsValidFromVariantType(wFromType) )
        {
            sc = DB_E_BADTYPE;
        }
        else
        {
            // Allocate this on the stack
            XInterface<IDataConvert> xDataConvert;

            BOOL fOk = CAccessor::CanConvertType( wFromType,
                                                  wToType,
                                   (_RowsetProps.GetPropertyFlags() & eExtendedTypes) != 0,
                                    xDataConvert );
            sc = fOk ? S_OK : S_FALSE;
        }
        if (FAILED(sc))
            _DBErrorObj.PostHResult(sc, IID_IConvertType);
    }
    CATCH(CException, e)
    {
        sc = _DBErrorObj.PostHResult( e, IID_IConvertType );
        _DBErrorObj.PostHResult( sc, IID_IConvertType );
    }
    END_CATCH;
    UNTRANSLATE_EXCEPTIONS;

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::BuildTree, public
//
//  Synopsis:   Takes a cached SQL Text and translates it into a Query Tree
//              Called from Execute(), Prepare() and GetCommandTree().
//
//  Arguments:  [pIID]      -  IID of interface calling this function
//
//
//  Returns:    [S_OK]          - a command tree was built successfully
//              [DB_S_NORESULT] - the command didn't generate a tree
//                                (e.g SET PROPERTYNAME...)
//              All error codes are thrown.
//
//
//  History:    10-31-97        danleg      Created
//              01-01-98        danleg      Moved global views to CreateParser
//
//----------------------------------------------------------------------------

SCODE CRootQuerySpec::BuildTree( )
{
    SCODE sc = S_OK;

    DBCOMMANDTREE * pDBCOMMANDTREE = 0;

    XInterface<IParserTreeProperties> xIPTProperties;

    LCID lcidContent =   GetLCIDFromString((LPWSTR)_RowsetProps.GetValString(
                                    CMRowsetProps::eid_DBPROPSET_MSIDXS_ROWSET_EXT,
                                    CMRowsetProps::eid_MSIDXSPROPVAL_COMMAND_LOCALE_STRING));

    //
    // Synch IParserSession's catalog cache with DBPROP_CURRENTCATALOG.  If no session,
    // catalogs are specified using the catalog..scope() syntax anyway.
    //
    if ( !_xSession.IsNull() )
    {
        LPCWSTR pwszCatalog = ((_xSession->GetDataSrcPtr())->GetDSPropsPtr())->GetValString(
                                    CMDSProps::eid_DBPROPSET_DATASOURCE,
                                    CMDSProps::eid_DBPROPVAL_CURRENTCATALOG );

        _xpIPSession->SetCatalog( pwszCatalog );
    }

    // NOTE: For CREATE VIEW and SET PROPERTYNAME calls, ToTree will return DB_S_NORESULT
    sc = _xpIPSession->ToTree( lcidContent,
                               _pwszSQLText,
                               &pDBCOMMANDTREE,
                               xIPTProperties.GetPPointer() );

    if( S_OK == sc )
    {
        //
        // Set flag to indicate that BuildTree is calling SetCommandTree
        //
        _dwStatus |= CMD_TEXT_TOTREE;

        // Set the command tree
        sc = SetCommandTree( &pDBCOMMANDTREE, DBCOMMANDREUSE_NONE, FALSE );
        if ( SUCCEEDED(sc) )
        {
            VARIANT vVal;
            VariantInit( &vVal );

            // We need to set the QUERY_RESTRICTION so it can be cloned into
            // the rowset properties object
            if( SUCCEEDED( xIPTProperties->GetProperties(PTPROPS_CIRESTRICTION,
                                                         &vVal)) )
            {
                _RowsetProps.SetValString(
                    CMRowsetProps::eid_DBPROPSET_MSIDXS_ROWSET_EXT,
                    CMRowsetProps::eid_MSIDXSPROPVAL_QUERY_RESTRICTION,
                    (LPCWSTR)V_BSTR(&vVal) );
            }
            VariantClear( &vVal );
        }
    }
    else if( FAILED(sc) && !xIPTProperties.IsNull() )
    {
        // Retrieve Error Information
        SCODE           sc2 = S_OK;
        DISPPARAMS *    pDispParams = NULL;
        VARIANT         vVal[3];
        ULONG           ul;

        for(ul=0; ul<NUMELEM(vVal); ul++)
            VariantInit(&vVal[ul]);

        if( SUCCEEDED(sc2 = xIPTProperties->GetProperties(
                                            PTPROPS_ERR_IDS, &vVal[0])) )
        {
            if( (V_I4(&vVal[0]) > 0) && SUCCEEDED(sc2 = xIPTProperties->GetProperties(
                                                PTPROPS_ERR_HR, &vVal[1])) )
            {
                if( SUCCEEDED(sc2 = xIPTProperties->GetProperties(
                                                    PTPROPS_ERR_DISPPARAM, &vVal[2])) )
                {
                    // Change safearray into DISPPARMS
                    SAFEARRAY* psa = V_ARRAY(&vVal[2]);
                    if( psa && psa->rgsabound[0].cElements)
                    {
                        pDispParams = (DISPPARAMS*)CoTaskMemAlloc(sizeof(DISPPARAMS));
                        if( pDispParams )
                        {
                            pDispParams->cNamedArgs = 0;
                            pDispParams->rgdispidNamedArgs = NULL;
                            pDispParams->cArgs = psa->rgsabound[0].cElements;
                            pDispParams->rgvarg =
                                (VARIANT*)CoTaskMemAlloc(sizeof(VARIANTARG) * psa->rgsabound[0].cElements);
                            if( pDispParams->rgvarg )
                            {
                                for (ULONG i=0; i<psa->rgsabound[0].cElements; i++)
                                {
                                    VariantInit(&(pDispParams->rgvarg[i]));
                                    V_VT(&(pDispParams->rgvarg[i])) = VT_BSTR;
                                    V_BSTR(&(pDispParams->rgvarg[i])) = ((BSTR*)psa->pvData)[i];
                                    ((BSTR*)psa->pvData)[i] = NULL;
                                }
                            }
                        }
                    }

                    // Post a parser error
                    _DBErrorObj.PostParserError( V_I4(&vVal[1]),
                                                 V_I4(&vVal[0]),
                                                 &pDispParams );

                    // This is the SCODE of the error just posted.
                    sc2 = V_I4(&vVal[1]);
                    if ( FAILED(sc2) )
                        sc = sc2;

                    Win4Assert( pDispParams == NULL ); // Should be null after post
                }
            }
        }

        for ( ul=0; ul<NUMELEM(vVal); ul++ )
            VariantClear( &vVal[ul] );
    }

    if( pDBCOMMANDTREE )
        FreeCommandTree( &pDBCOMMANDTREE );

    if ( FAILED(sc) )
        THROW( CException(sc) );

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Member:     CRootQuerySpec::CreateParser, private
//
//  Synopsis:   Creates a parser object if one was not passed through a session
//
//  History:    11-25-97    danleg      Created
//
//----------------------------------------------------------------------------

void CRootQuerySpec::CreateParser()
{
    SCODE sc = S_OK;

    CLock lck( _mtxCmd );

    sc = MakeIParser( _xIParser.GetPPointer() );
    if ( FAILED(sc) )
    {
        Win4Assert( sc != E_INVALIDARG );
        THROW( CException(sc) );
    }

    XInterface<IColumnMapperCreator> xColMapCreator;

    XInterface<CImpIParserVerify> xIPVerify(new CImpIParserVerify());

    //
    // Create an IParserSession object
    //
    xIPVerify->GetColMapCreator( ((IColumnMapperCreator**)xColMapCreator.GetQIPointer()) );

    sc = _xIParser->CreateSession( &DBGUID_MSSQLTEXT,
                                   DEFAULT_MACHINE,
                                   xIPVerify.GetPointer(),
                                   xColMapCreator.GetPointer(),
                                   (IParserSession**)_xpIPSession.GetQIPointer() );
    if ( FAILED(sc) )
        THROW( CException(sc) );

    //
    // Set default catalog in the parser session object
    //
    _xpwszCatalog.Init( MAX_PATH );
    ULONG cOut;
    sc = xIPVerify->GetDefaultCatalog( _xpwszCatalog.GetPointer(),
                                       _xpwszCatalog.Count(),
                                       &cOut);

    //
    // _xpwszCatalog isn't long enough
    //
    Win4Assert( E_INVALIDARG != sc );
    if ( FAILED(sc) )
        THROW( CException(sc) );

    sc = _xpIPSession->SetCatalog( _xpwszCatalog.GetPointer() );
    if( FAILED(sc) )
        THROW( CException(sc) );


    DBCOMMANDTREE * pDBCOMMANDTREE = 0;
    XInterface<IParserTreeProperties> xIPTProperties;

    LCID lcidContent =   GetLCIDFromString((LPWSTR)_RowsetProps.GetValString(
                                    CMRowsetProps::eid_DBPROPSET_MSIDXS_ROWSET_EXT,
                                    CMRowsetProps::eid_MSIDXSPROPVAL_COMMAND_LOCALE_STRING));

    //
    // Predefined views
    //
    sc = _xpIPSession->ToTree( lcidContent,
                               s_pwszPredefinedViews,
                               &pDBCOMMANDTREE,
                               xIPTProperties.GetPPointer() );
    if ( FAILED(sc) )
        THROW( CException(sc) );
} //CreateParser