//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994 - 2000.
//
// File: DOQUERY.CXX
//
// Contents: Functions to make query nodes and trees, and to execute
// queries.
//
// History: 02 Nov 94 alanw Created from main.cxx and screen.cxx.
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <doquery.hxx>
#include <catstate.hxx>
static const GUID guidBmk = DBBMKGUID;
static const GUID psGuidStorage = PSGUID_STORAGE;
static const GUID psGuidQuery = DBQUERYGUID;
static const GUID guidQueryExt = DBPROPSET_QUERYEXT;
static const GUID guidRowset = DBPROPSET_ROWSET;
static CDbColId psRank( psGuidQuery, DISPID_QUERY_RANK );
static CDbColId psBookmark( guidBmk, PROPID_DBBMK_BOOKMARK );
static CDbColId psPath( psGuidStorage, PID_STG_PATH );
//+---------------------------------------------------------------------------
//
// Function: FormTableNode
//
// Synopsis: Forms a selection node and if needed a sort node
//
// Arguments: [rst] - Restriction tree describing the query
// [states] - global state info
// [plist] - friendly property name list
//
// Returns: A pointer to a commandtree node
//
// History: 9-4-95 SitaramR Created
//
//----------------------------------------------------------------------------
CDbCmdTreeNode *FormTableNode(
CDbCmdTreeNode & rst,
CCatState & states,
IColumnMapper * plist )
{
//
// First create a selection node and append the restriction tree to it
//
XPtr<CDbSelectNode> xSelect( new CDbSelectNode() );
if ( xSelect.IsNull() || !xSelect->IsValid() )
THROW( CException( STATUS_NO_MEMORY ) );
//
// Clone the restriction and use it.
//
CDbCmdTreeNode * pExpr = rst.Clone();
if ( 0 == pExpr )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
//
// Now make the restriction a child of the selection node.
//
xSelect->SetRestriction( pExpr );
XPtr<CDbCmdTreeNode> xTable;
unsigned int cSortProp = states.NumberOfSortProps();
if ( cSortProp > 0 )
{
CDbSortNode * pSort = new CDbSortNode();
if ( 0 == pSort )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
XPtr<CDbCmdTreeNode> xSort( pSort );
for( unsigned i = 0; i < cSortProp; i++ )
{
WCHAR const * wcsName;
SORTDIR sd;
states.GetSortProp( i,
&wcsName,
&sd );
DBID *pdbid = 0;
if( FAILED(plist->GetPropInfoFromName( wcsName,
&pdbid,
0,
0 )) )
THROW( CQueryException( QUERY_UNKNOWN_PROPERTY_FOR_SORT ) );
//
// Add the sort column.
//
CDbColId *pprop = (CDbColId *)pdbid;
if ( !pSort->AddSortColumn( *pprop,
(sd == SORT_DOWN) ? TRUE : FALSE,
states.GetLocale()))
{
THROW( CException( STATUS_NO_MEMORY ) );
}
}
if ( pSort->AddTable( xSelect.GetPointer() ) )
xSelect.Acquire();
else
{
THROW( CException( STATUS_NO_MEMORY ) );
}
xTable.Set( xSort.Acquire() );
}
else
xTable.Set( xSelect.Acquire() );
return xTable.Acquire();
}
//+---------------------------------------------------------------------------
//
// Function: FormQueryTree
//
// Synopsis: Forms a query tree consisting of the projection nodes,
// selection node, sort node(s) and the restriction tree.
//
// Arguments: [rst] - Restriction tree describing the query
// [states] - global state info
// [plist] - friendly property name list
//
// Returns: A pointer to the query tree. It is the responsibility of
// the caller to later free it.
//
// History: 6-20-95 srikants Created
//
//----------------------------------------------------------------------------
CDbCmdTreeNode * FormQueryTree( CDbCmdTreeNode & rst,
CCatState & states,
IColumnMapper * plist,
BOOL fAddBmkCol,
BOOL fAddRankForBrowse )
{
CDbCmdTreeNode *pTable = FormTableNode( rst, states, plist );
XPtr<CDbCmdTreeNode> xTable( pTable );
XPtr<CDbCmdTreeNode> xQuery;
unsigned cCategories = states.NumberOfCategories();
if ( cCategories > 0 )
{
//
// First create nesting node for the base table
//
CDbNestingNode *pNestNodeBase = new CDbNestingNode;
if ( pNestNodeBase == 0 )
THROW ( CException( STATUS_NO_MEMORY ) );
XPtr<CDbCmdTreeNode> xNestNodeBase( pNestNodeBase );
BOOL fNeedPath = TRUE;
BOOL fNeedRank = fAddRankForBrowse;
//
// Next add all the columns in the state.
//
CDbColId * pprop = 0;
DBID *pdbid = 0;
unsigned int cCol = states.NumberOfColumns();
for ( unsigned int i = 0; i < cCol; i++ )
{
if( FAILED(plist->GetPropInfoFromName( states.GetColumn( i ),
&pdbid,
0,
0 )) )
THROW( CQueryException( QUERY_UNKNOWN_PROPERTY_FOR_OUTPUT ) );
pprop = (CDbColId *)pdbid;
if ( *pprop == psPath )
{
fNeedPath = FALSE;
}
else if ( *pprop == psRank )
{
fNeedRank = FALSE;
}
if ( !pNestNodeBase->AddChildColumn( *pprop ) )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
}
if ( fNeedPath && !pNestNodeBase->AddChildColumn( psPath ) )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
if ( fNeedRank && !pNestNodeBase->AddChildColumn( psRank ) )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
//
// Add categories to the output column
//
for ( i = 0; i < cCategories; i++ )
{
//
// We need to ensure that we don't add categories that have already been
// added above. The following test can be speeded up from O( i*j ) to O( i+j ),
// but the the number of categories and the number of columns are usually very small.
//
BOOL fFound = FALSE;
for ( unsigned j=0; j<states.NumberOfColumns(); j++ )
{
if ( _wcsicmp( states.GetCategory(i), states.GetColumn( j ) ) == 0 )
{
fFound = TRUE;
break;
}
}
if ( !fFound )
{
if( FAILED(plist->GetPropInfoFromName( states.GetCategory( i ),
&pdbid,
0,
0 )) )
THROW( CQueryException( QUERY_UNKNOWN_PROPERTY_FOR_CATEGORIZATION ) );
pprop = (CDbColId *)pdbid;
if ( !pNestNodeBase->AddChildColumn( *pprop ) )
THROW( CException( STATUS_NO_MEMORY ) );
}
}
if ( pNestNodeBase->AddTable( xTable.GetPointer() ) )
xTable.Acquire();
else
{
THROW( CException( STATUS_NO_MEMORY ) );
}
if ( FAILED(plist->GetPropInfoFromName( states.GetCategory( cCategories - 1 ),
&pdbid,
0,
0 )) )
THROW( CQueryException( QUERY_UNKNOWN_PROPERTY_FOR_OUTPUT ) );
pprop = (CDbColId *)pdbid;
if ( !pNestNodeBase->AddGroupingColumn( *pprop ) )
THROW( CException( STATUS_NO_MEMORY ) );
if ( !pNestNodeBase->AddParentColumn( *pprop ) )
THROW( CException( STATUS_NO_MEMORY ) );
if ( !pNestNodeBase->AddParentColumn( psBookmark ) )
THROW( CException( STATUS_NO_MEMORY ) );
//
// Now create the nesting nodes for remaining categories, if any
//
XPtr<CDbCmdTreeNode> xCategChild( xNestNodeBase.Acquire() );
for ( int j=cCategories-2; j>=0; j-- )
{
if ( FAILED(plist->GetPropInfoFromName( states.GetCategory( j ),
&pdbid,
0,
0 )) )
{
THROW( CQueryException( QUERY_UNKNOWN_PROPERTY_FOR_OUTPUT ) );
}
pprop = (CDbColId *)pdbid;
CDbNestingNode *pCategParent = new CDbNestingNode;
if ( pCategParent == 0 )
THROW( CException( STATUS_NO_MEMORY ) );
XPtr<CDbCmdTreeNode> xCategParent( pCategParent );
if ( pCategParent->AddTable( xCategChild.GetPointer() ) )
xCategChild.Acquire();
else
{
THROW( CException( STATUS_NO_MEMORY ) );
}
if ( !pCategParent->AddGroupingColumn( *pprop ) )
THROW( CException( STATUS_NO_MEMORY ) );
if ( !pCategParent->AddParentColumn( *pprop ) )
THROW( CException( STATUS_NO_MEMORY ) );
if ( !pCategParent->AddParentColumn( psBookmark ) )
THROW( CException( STATUS_NO_MEMORY ) );
xCategChild.Set( xCategParent.Acquire() );
}
xQuery.Set( xCategChild.Acquire() );
}
else
{
//
// Create the projection node
//
CDbProjectNode * pProject = new CDbProjectNode();
if ( 0 == pProject )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
XPtr<CDbCmdTreeNode> xProject( pProject );
//
// Add the selection/sort node
//
if ( pProject->AddTable( xTable.GetPointer() ) )
xTable.Acquire();
else
{
THROW( CException( STATUS_NO_MEMORY ) );
}
//
// We query with two additional, but hidden, columns: path and rank,
// because this information is needed by the browser (via Clipboard).
// Care is taken in CRows::DisplayHeader and CRows::DisplayRows so that
// the hidden columns are not displayed to the user
//
BOOL fNeedPath = TRUE;
BOOL fNeedRank = fAddRankForBrowse;
//
// Next add all the columns in the state.
//
unsigned int cCol = states.NumberOfColumns();
for ( unsigned int i = 0; i < cCol; i++ )
{
CDbColId * pprop = 0;
DBID *pdbid = 0;
if( FAILED(plist->GetPropInfoFromName( states.GetColumn( i ),
&pdbid,
0,
0 )) )
THROW( CQueryException( QUERY_UNKNOWN_PROPERTY_FOR_OUTPUT ) );
pprop = (CDbColId *)pdbid;
if ( *pprop == psPath )
{
fNeedPath = FALSE;
}
else if ( *pprop == psRank )
{
fNeedRank = FALSE;
}
if ( !pProject->AddProjectColumn( *pprop ) )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
}
if ( fNeedPath && !pProject->AddProjectColumn( psPath ) )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
if ( fNeedRank && !pProject->AddProjectColumn( psRank ) )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
if (fAddBmkCol && !pProject->AddProjectColumn( psBookmark ) )
{
THROW( CException( STATUS_NO_MEMORY ) );
}
xQuery.Set( xProject.Acquire() );
}
CDbTopNode *pTop = 0;
if ( states.IsMaxResultsSpecified() )
{
//
// Use the top node to set a cap on the number of query results
//
pTop = new CDbTopNode();
if ( pTop == 0 )
THROW( CException( STATUS_NO_MEMORY ) );
pTop->SetChild( xQuery.Acquire() );
pTop->SetValue( states.GetMaxResults() );
}
//
// Set FirstRows here
//
if ( states.IsFirstRowsSpecified() )
{
CDbFirstRowsNode *pFR = new CDbFirstRowsNode();
if ( pFR == 0 )
THROW( CException( STATUS_NO_MEMORY ) );
CDbCmdTreeNode *pChild = pTop ? pTop : xQuery.Acquire();
pFR->SetChild( pChild );
pFR->SetValue( states.GetFirstRows() );
return pFR;
}
if ( 0 != pTop )
return pTop;
return xQuery.Acquire();
}
//+---------------------------------------------------------------------------
//
// Function: SetScopePropertiesNoThrow
//
// Synopsis: Sets rowset properties pertaining to scope on command object.
//
// Arguments: [pCmd] -- Command object
// [cDirs] -- Number of elements in following arrays
// [apDirs] -- Array of scopes
// [aulFlags] -- Array of flags (depths)
// [apCats] -- Array of catalogs
// [apMachines] -- Array of machines
//
// Notes: Either apDirs and aulFlags, or apCats and apMachines may be
// NULL.
//
// History: 03-Mar-1997 KyleP Created
// 14-May-1997 mohamedn use real BSTRs
// 19-May-1997 KrishnaN Not throwing exceptions.
//
//----------------------------------------------------------------------------
SCODE SetScopePropertiesNoThrow( ICommand * pCmd,
unsigned cDirs,
WCHAR const * const * apDirs,
ULONG const * aulFlags,
WCHAR const * const * apCats,
WCHAR const * const * apMachines )
{
SCODE sc = S_OK;
TRY
{
XInterface<ICommandProperties> xCmdProp;
sc = pCmd->QueryInterface( IID_ICommandProperties, xCmdProp.GetQIPointer() );
if ( FAILED( sc ) )
return sc;
//
// It's expensive to convert all of these to BSTRs, but we have
// to since our public API just takes regular strings.
//
CDynArrayInPlace<XBStr> aMachines(cDirs);
CDynArrayInPlace<XBStr> aCatalogs(cDirs);
CDynArrayInPlace<XBStr> aScopes(cDirs);
unsigned i;
//
// init array of BSTRs of machines
//
if ( 0 != apMachines)
{
for ( i = 0; i < cDirs; i++ )
{
XBStr xBstr;
xBstr.SetText( (WCHAR *)apMachines[i]);
aMachines.Add(xBstr,i);
xBstr.Acquire();
}
}
//
// init array of BSTRs of catalogs
//
if ( 0 != apCats)
{
for ( i = 0; i < cDirs; i++ )
{
XBStr xBstr;
xBstr.SetText( (WCHAR *)apCats[i]);
aCatalogs.Add(xBstr,i);
xBstr.Acquire();
}
}
//
// init array of BSTRs of scopes
//
if ( 0 != apDirs)
{
for ( i = 0; i < cDirs; i++ )
{
XBStr xBstr;
xBstr.SetText( (WCHAR *)apDirs[i]);
aScopes.Add(xBstr,i);
xBstr.Acquire();
}
}
SAFEARRAY saScope = { 1, // Dimension
FADF_AUTO | FADF_BSTR, // Flags: on stack, contains BSTRs
sizeof(BSTR), // Size of an element
1, // Lock count. 1 for safety.
(void *) aScopes.GetPointer(),// The data
{ cDirs, 0 } }; // Bounds (element count, low bound)
SAFEARRAY saDepth = { 1, // Dimension
FADF_AUTO, // Flags: on stack
sizeof(LONG), // Size of an element
1, // Lock count. 1 for safety.
(void *)aulFlags, // The data
{ cDirs, 0 } }; // Bounds (element count, low bound)
SAFEARRAY saCatalog = { 1, // Dimension
FADF_AUTO | FADF_BSTR, // Flags: on stack, contains BSTRs
sizeof(BSTR), // Size of an element
1, // Lock count. 1 for safety.
(void *) aCatalogs.GetPointer(), // The data
{ cDirs, 0 } }; // Bounds (element count, low bound)
SAFEARRAY saMachine = { 1, // Dimension
FADF_AUTO | FADF_BSTR, // Flags: on stack, contains BSTRs
sizeof(BSTR), // Size of an element
1, // Lock count. 1 for safety.
(void *) aMachines.GetPointer(), // The data
{ cDirs, 0 } }; // Bounds (element count, low bound)
DBPROP aScopeProps[2] = {
{ DBPROP_CI_INCLUDE_SCOPES , 0, DBPROPSTATUS_OK, {0, DBKIND_GUID_PROPID, 0}, { VT_BSTR | VT_ARRAY, 0, 0, 0, (ULONG_PTR)&saScope } },
{ DBPROP_CI_DEPTHS , 0, DBPROPSTATUS_OK, {0, DBKIND_GUID_PROPID, 0}, { VT_I4 | VT_ARRAY, 0, 0, 0, (ULONG_PTR)&saDepth } } };
DBPROP aCatalogProps[1] = {
{ DBPROP_CI_CATALOG_NAME , 0, DBPROPSTATUS_OK, {0, DBKIND_GUID_PROPID, 0}, { VT_BSTR | VT_ARRAY, 0, 0, 0, (ULONG_PTR)&saCatalog } } };
DBPROP aMachineProps[1] = {
{ DBPROP_MACHINE , 0, DBPROPSTATUS_OK, {0, DBKIND_GUID_PROPID, 0}, { VT_BSTR | VT_ARRAY, 0, 0, 0, (ULONG_PTR)&saMachine } } };
DBPROPSET aAllPropsets[3] = {
{ aScopeProps, 2, DBPROPSET_FSCIFRMWRK_EXT } ,
{ aCatalogProps, 1, DBPROPSET_FSCIFRMWRK_EXT } ,
{ aMachineProps, 1, DBPROPSET_CIFRMWRKCORE_EXT } };
DBPROPSET * pPropsets = 0;
ULONG cPropsets = 0;
if ( 0 != apDirs )
{
pPropsets = &aAllPropsets[0];
cPropsets = 1;
}
else
{
pPropsets = &aAllPropsets[1];
}
if ( 0 != apCats && 0 != apMachines )
{
cPropsets += 2;
}
sc = xCmdProp->SetProperties( cPropsets, pPropsets );
}
CATCH(CException, e)
{
sc = GetOleError(e);
}
END_CATCH
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: SetScopeProperties
//
// Synopsis: Sets rowset properties pertaining to scope on command object.
//
// Arguments: [pCmd] -- Command object
// [cDirs] -- Number of elements in following arrays
// [apDirs] -- Array of scopes
// [aulFlags] -- Array of flags (depths)
// [apCats] -- Array of catalogs
// [apMachines] -- Array of machines
//
// History: 03-Mar-1997 KyleP Created
//
//----------------------------------------------------------------------------
void SetScopeProperties( ICommand * pCmd,
unsigned cDirs,
WCHAR const * const * apDirs,
ULONG const * aulFlags,
WCHAR const * const * apCats,
WCHAR const * const * apMachines )
{
SCODE sc = SetScopePropertiesNoThrow(pCmd, cDirs, apDirs,
aulFlags, apCats, apMachines);
if (FAILED(sc))
THROW( CException(sc) );
}