//+---------------------------------------------------------------------------
//
// 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