able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/query/bigtable/query.cxx

940 lines
28 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994 - 2000.
//
// File: query.cxx
//
// Contents: Class encapsulating all the context for a running
// query, including the query execution context, the
// cached query results, and all cursors over the
// results.
// Dispatches requests to the appropriate subobject.
//
// Classes: CAsyncQuery
// CGetRowsParams
//
// History: 31 May 94 AlanW Created
//
//--------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <query.hxx>
#include <srequest.hxx>
#include <rowseek.hxx>
#include <tbrowkey.hxx>
#include <oleprop.hxx>
#include "tabledbg.hxx"
//+-------------------------------------------------------------------------
//
// Member: CGetRowsParams::GetRowBuffer, public inline
//
// Synopsis: Return a pointer to the row buffer. If this is the first
// reference, get it from the fixed allocator.
//
// Arguments: - none -
//
// Returns: PBYTE - a pointer to the row buffer.
//
// Notes: We don't put this in query.hxx since we don't want to
// have to refer to PFixedVarAllocator there.
//
//--------------------------------------------------------------------------
PBYTE CGetRowsParams::GetRowBuffer( void )
{
if (0 == _pData)
_pData = _rAllocator.AllocFixed();
return (PBYTE) _pData;
}
PBYTE CGetRowsParams::GetBuffer( ) const
{ return _rAllocator.BufferAddr(); }
//+---------------------------------------------------------------------------
//
// Member: CAsyncQuery::CAsyncQuery, public
//
// Synopsis: Creates a locally accessible Query
//
// Arguments: [qopt] - Query optimizer
// [col] - Initial set of columns to return
// [sort] - Initial sort
// [categ] - Categorization specification
// [cCursors] - # of cursors to create
// [aCursors] - array of cursors returned
// [pidremap] - prop ID mapping
// [fEnableNotification] - if TRUE, allow watches
// [pDocStore] - client doc store
// [pEvtComplete] - completion event
//
//----------------------------------------------------------------------------
CAsyncQuery::CAsyncQuery( XQueryOptimizer & qopt,
XColumnSet & col,
XSortSet & sort,
XCategorizationSet &categ,
unsigned cCursors,
ULONG * aCursors,
XInterface<CPidRemapper> & pidremap,
BOOL fEnableNotification,
ICiCDocStore *pDocStore,
CRequestServer * pQuiesce
)
: _fCanDoWorkidToPath( !qopt->IsWorkidUnique() ),
PQuery( ),
_ref( 1 ),
_pidremap( pidremap.Acquire() ),
_Table( col,
sort,
cCursors - 1,
_mutex,
!_fCanDoWorkidToPath,
pQuiesce ),
_cRowsLastAsked (0),
_aCursors( ),
_aCategorize( cCursors - 1 )
{
//
// Get ci manager and translator interfaces
//
ICiManager *pCiManager = 0;
SCODE sc = pDocStore->GetContentIndex( &pCiManager );
if ( FAILED( sc ) )
{
Win4Assert( !"Need to support GetContentIndex interface" );
THROW( CException( sc ) );
}
_xCiManager.Set( pCiManager );
ICiCDocNameToWorkidTranslator *pNameToWidTranslator;
sc = pDocStore->QueryInterface( IID_ICiCDocNameToWorkidTranslator,
(void **) &pNameToWidTranslator );
if ( FAILED( sc ) )
{
Win4Assert( !"Need to support translator QI" );
THROW( CException( sc ) );
}
_xNameToWidTranslator.Set( pNameToWidTranslator );
Win4Assert( 0 != cCursors );
// make a cursor for the main table and each categorization level
for (unsigned cursor = 0; cursor < cCursors; cursor++)
aCursors[cursor] = _CreateRowCursor();
// the last cursor is associated with the main table
_aCursors.Lookup(aCursors[cCursors - 1]).SetSource( &_Table );
if (cCursors > 1)
{
//
// NOTE: pidWorkid is always added to the sort set in the table,
// so it should always be sorted. That's why it's sort count-1
// SPECDEVIATION - if workid was already in the sort, this test
// is incorrect. Who would want to categorize on workid though?
//
if ( ! _Table.IsSorted() ||
cCursors-1 > _Table.GetSortSet()->Count()-1 )
{
// CLEANCODE: Should this check be handled in the categorizers?
// Is it specific to the unique categorization?
tbDebugOut(( DEB_WARN, "Query contains too few sort specs "
"for categorization spec\n" ));
THROW( CException( E_INVALIDARG ) );
}
// this is a categorized table, so set up the categorizers
for ( unsigned cat = 0; cat < (cCursors - 1); cat++ )
{
_aCategorize[cat] = new CCategorize( * (categ->Get(cat)),
cat + 1,
cat ? _aCategorize[cat-1] : 0,
_mutex );
_aCursors.Lookup(aCursors[cat]).SetSource( _aCategorize[cat] );
}
_Table.SetCategorizer(_aCategorize[cCursors - 2]);
// now tell each categorizer what it is categorizing over
for ( cat = 0; cat < (cCursors - 2); cat++ )
_aCategorize[cat]->SetChild( _aCategorize[ cat + 1 ] );
_aCategorize[ cCursors - 2 ]->SetChild( & _Table );
}
// Without the lock, the query can be complete and destructed
// BEFORE the constructor finishes
CLock lock( _mutex );
//
// Since we can be swapping rows, we may need singleton cursor(s)
//
qopt->EnableSingletonCursors();
if ( 0 != pQuiesce )
pQuiesce->SetPQuery( (PQuery *) this );
_QExec.Set( new CQAsyncExecute( qopt, fEnableNotification, _Table, pDocStore ) );
_Table.SetQueryExecute( _QExec.GetPointer() );
ciDebugOut(( DEB_USER1, "Using an asynchronous cursor.\n" ));
END_CONSTRUCTION( CAsyncQuery );
}
//+---------------------------------------------------------------------------
//
// Member: CAsyncQuery::~CAsyncQuery, public
//
// Synopsis: Destroy the query
//
//----------------------------------------------------------------------------
CAsyncQuery::~CAsyncQuery()
{
CLock lock( _mutex );
//Win4Assert( _ref == 0 ); This isn't true when queries are aborted
_Table.ReleaseQueryExecute();
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::AddRef, public
//
// Synopsis: Reference the query.
//
//--------------------------------------------------------------------------
ULONG CAsyncQuery::AddRef(void)
{
return InterlockedIncrement( &_ref );
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::Release, public
//
// Synopsis: De-Reference the query.
//
// Effects: If the ref count goes to 0 then the query is deleted.
//
//--------------------------------------------------------------------------
ULONG CAsyncQuery::Release(void)
{
long l = InterlockedDecrement( &_ref );
if ( l <= 0 )
{
tbDebugOut(( DEB_ITRACE, "CAsyncQuery unreferenced. Deleting.\n" ));
delete this;
return 0;
}
return l;
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::_CreateRowCursor, private
//
// Synopsis: Create a new CTableCursor, return a handle to it.
//
// Arguments: - none -
//
// Returns: ULONG - handle associated with the new cursor. Will
// be zero if the cursor could not be created.
//
// Notes: There needs to be a subsequent call to SetBindings prior
// to any call to GetRows.
//
//--------------------------------------------------------------------------
ULONG CAsyncQuery::_CreateRowCursor( )
{
CTableCursor * pCursor = new CTableCursor;
ULONG hCursor = 0;
_aCursors.Add(pCursor, hCursor);
// By default, make the cursor refer to the real table,
// not categorization
pCursor->SetSource(&_Table);
Win4Assert(hCursor != 0);
return hCursor;
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::FreeCursor, public
//
// Synopsis: Free a handle to a CTableCursor
//
// Arguments: [hCursor] - handle to the cursor to be freed
//
// Returns: # of cursors left
//
//--------------------------------------------------------------------------
unsigned CAsyncQuery::FreeCursor(
ULONG hCursor )
{
Win4Assert( hCursor != 0 );
_aCursors.Release(hCursor);
return _aCursors.Count();
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::SetBindings, public
//
// Synopsis: Set column bindings into a cursor
//
// Arguments: [hCursor] - the handle of the cursor to set bindings on
// [cbRowLength] - the width of an output row
// [cols] - a description of column bindings to be set
// [pids] - a PID mapper which maps fake pids in cols to
// column IDs.
//
// Returns: nothing
//
//--------------------------------------------------------------------------
void
CAsyncQuery::SetBindings(
ULONG hCursor,
ULONG cbRowLength,
CTableColumnSet & cols,
CPidMapper & pids )
{
CTableCursor& rCursor = _aCursors.Lookup(hCursor);
if (0 == cols.Count() ||
0 == cbRowLength || cbRowLength >= USHRT_MAX)
THROW( CException( E_INVALIDARG ));
XPtr<CTableColumnSet> outset(new CTableColumnSet( cols.Count() ));
for (unsigned iCol = 0; iCol < cols.Count(); iCol++)
{
CTableColumn * pCol = cols.Get( iCol );
CFullPropSpec * propspec = pids.Get( pCol->PropId );
//
// Convert the DBID to a PROPID
//
// Win4Assert( iCol+1 == pCol->PropId ); // therefore pids is useless
PROPID prop = _pidremap->NameToReal(propspec);
if ( prop == pidInvalid || _Table.IsColumnInTable(prop) == FALSE )
{
tbDebugOut(( DEB_ERROR, "Column unavailable: prop = 0x%x\n", prop ));
THROW( CException( DB_E_BADCOLUMNID ));
}
if (pCol->IsCompressedCol())
THROW( CException( E_INVALIDARG ));
XPtr<CTableColumn> xpOutcol ( new CTableColumn( prop, pCol->GetStoredType() ) );
if (pCol->IsValueStored())
xpOutcol->SetValueField(pCol->GetStoredType(),
pCol->GetValueOffset(),
pCol->GetValueSize());
Win4Assert( pCol->IsStatusStored() );
xpOutcol->SetStatusField(pCol->GetStatusOffset(),
(USHORT)pCol->GetStatusSize());
if (pCol->IsLengthStored())
xpOutcol->SetLengthField(pCol->GetLengthOffset(),
(USHORT)pCol->GetLengthSize());
outset->Add(xpOutcol, iCol);
}
SCODE sc = rCursor.SetBindings( cbRowLength, outset );
if ( FAILED( sc ) )
THROW( CException( sc ) );
} //SetBindings
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::GetRows, public
//
// Synopsis: Retrieve row data for a table cursor
//
// Arguments: [hCursor] - the handle of the cursor to fetch data for
// [rSeekDesc] - row seek operation to be done before fetch
// [rFetchParams] - row fetch parameters and buffer pointers
// [pSeekDescOut] - row seek description for restart
//
// Returns: SCODE - the status of the operation. E_HANDLE
// is returned if hCursor cannot be looked up,
// presumably an internal error.
//
// History: 24 Jan 1995 Alanw Created
//
//--------------------------------------------------------------------------
SCODE
CAsyncQuery::GetRows(
ULONG hCursor,
const CRowSeekDescription & rSeekDesc,
CGetRowsParams& rFetchParams,
XPtr<CRowSeekDescription> & pSeekDescOut)
{
CTableCursor & rCursor = _aCursors.Lookup(hCursor);
rCursor.ValidateBindings();
CTableSource & rSource = rCursor.GetSource();
Win4Assert(rCursor.GetRowWidth() == rFetchParams.GetRowWidth());
return rSeekDesc.GetRows( rCursor,
rSource,
rFetchParams,
pSeekDescOut );
} //GetRows
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::RestartPosition, public
//
// Synopsis: Reset fetch position for chapter to the start
//
// Arguments: [hCursor] - the handle of the cursor to restart
// [chapter] - the chapter to restart
//
// Returns: SCODE - the status of the operation.
//
// Notes:
//
// History: 17 Apr 1997 EmilyB Created
//
//--------------------------------------------------------------------------
void
CAsyncQuery::RestartPosition(
ULONG hCursor,
CI_TBL_CHAPT chapter)
{
CTableCursor & rCursor = _aCursors.Lookup(hCursor);
CTableSource & rSource = rCursor.GetSource();
rSource.RestartPosition ( chapter );
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::RatioFinished, public
//
// Synopsis: Return the completion status as a fraction
//
// Arguments: [hCursor] - the handle of the cursor to check completion for
// [rulDenominator] - on return, denominator of fraction
// [rulNumerator] - on return, numerator of fraction
// [rcRows] - on return, number of rows in cursor
// [rfNewRows] - on return, TRUE if new rows available
//
// Returns: nothing
//
// Notes: A handle of zero can be passed for use with sequential
// cursors to check completion before a handle exists.
//
//--------------------------------------------------------------------------
void CAsyncQuery::RatioFinished(
ULONG hCursor,
DBCOUNTITEM & rulDenominator,
DBCOUNTITEM & rulNumerator,
DBCOUNTITEM & rcRows,
BOOL & rfNewRows
) {
if (hCursor != 0)
CTableCursor& rCursor = _aCursors.Lookup(hCursor); // For error check
rulDenominator = 1;
rulNumerator = 0;
rfNewRows = FALSE;
unsigned status = QUERY_FILL_STATUS(_Table.Status());
//
// SPECDEVIATION: should do something more meaningful with STAT_ERROR
// RatioFinished should probably fail in this case.
//
if (STAT_DONE == status ||
STAT_ERROR == status ||
STAT_REFRESH == status)
{
rulNumerator = 1;
rcRows = _Table.RowCount();
if (rcRows != _cRowsLastAsked)
{
_cRowsLastAsked = rcRows;
rfNewRows = TRUE;
}
return;
}
_Table.RatioFinished (rulDenominator, rulNumerator, rcRows);
if (rcRows != _cRowsLastAsked)
{
_cRowsLastAsked = rcRows;
rfNewRows = TRUE;
}
Win4Assert( rulDenominator >= rulNumerator );
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::Compare, public
//
// Synopsis: Return the approximate current position as a fraction
//
// Arguments: [hCursor] - the handle of the cursor to compare bmks from
// [bmkFirst] - First bookmark to compare
// [bmkSecond] - Second bookmark to compare
// [rdwComparison] - on return, comparison value
//
// Returns: nothing
//
//--------------------------------------------------------------------------
void CAsyncQuery::Compare(
ULONG hCursor,
CI_TBL_CHAPT chapt,
CI_TBL_BMK bmkFirst,
CI_TBL_BMK bmkSecond,
DWORD & rdwComparison
) {
rdwComparison = DBCOMPARE_NOTCOMPARABLE;
CTableCursor& rCursor = _aCursors.Lookup(hCursor);
CTableSource & rSource = rCursor.GetSource();
DBCOUNTITEM ulNum1, ulDen1;
SCODE scRet = rSource.GetApproximatePosition( chapt,
bmkFirst,
&ulNum1,
&ulDen1);
DBCOUNTITEM ulNum2, ulDen2;
if (SUCCEEDED(scRet))
{
scRet = rSource.GetApproximatePosition( chapt,
bmkSecond,
&ulNum2,
&ulDen2);
}
if (SUCCEEDED(scRet))
{
Win4Assert(ulDen1 == ulDen2);
if (ulNum1 < ulNum2)
rdwComparison = DBCOMPARE_LT;
else if (ulNum1 > ulNum2)
rdwComparison = DBCOMPARE_GT;
else // ulNum1 == ulNum2
rdwComparison = DBCOMPARE_EQ;
}
// CLEANCODE - have the source table THROW if errors in GetApproximatePosition
if (scRet != S_OK)
THROW(CException(scRet));
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::GetApproximatePosition, public
//
// Synopsis: Return the approximate current position as a fraction
//
// Arguments: [hCursor] - the handle of the cursor to retrieve info. from
// [bmk] - bookmark of row to get position of
// [pulNumerator] - on return, numerator of fraction
// [pulDenominator] - on return, denominator of fraction
//
// Returns: nothing
//
//--------------------------------------------------------------------------
void
CAsyncQuery::GetApproximatePosition(
ULONG hCursor,
CI_TBL_CHAPT chapt,
CI_TBL_BMK bmk,
DBCOUNTITEM * pulNumerator,
DBCOUNTITEM * pulDenominator
) {
CTableCursor& rCursor = _aCursors.Lookup(hCursor);
CTableSource & rSource = rCursor.GetSource();
SCODE scRet = rSource.GetApproximatePosition( chapt,
bmk,
pulNumerator,
pulDenominator);
// CLEANCODE - have the source table THROW if errors in GetApproximatePosition
if (scRet != S_OK)
THROW(CException(scRet));
}
//+---------------------------------------------------------------------------
//
// Member: CAsyncQuery::GetNotifications, private
//
// Synopsis: Retrieves the notification info from the query object
// row data.
//
// Arguments: [rSync] -- notification synchronization info
// [rParams] -- notification data info
//
// Returns: SCODE
//
// History: 10-24-94 dlee created
//
//----------------------------------------------------------------------------
SCODE
CAsyncQuery::GetNotifications(
CNotificationSync & rSync,
DBWATCHNOTIFY & changeType )
{
return _Table.GetNotifications(rSync,changeType);
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::SetWatchMode
//
// Synopsis: Stub implementation
//
// Arguments: [phRegion] -- handle to watch region
// [mode] -- watch mode
//
// History: May-2-95 BartoszM Created
//
//--------------------------------------------------------------------------
void CAsyncQuery::SetWatchMode (
HWATCHREGION* phRegion,
ULONG mode)
{
if (*phRegion == watchRegionInvalid)
_Table.CreateWatchRegion (mode, phRegion);
else
_Table.ChangeWatchMode (*phRegion, mode);
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::GetWatchInfo
//
// Synopsis: Stub implementation
//
// Arguments: [hRegion] -- handle to watch region
// [pMode] -- watch mode
// [pChapter] -- chapter
// [pBookmark] -- bookmark
// [pcRows] -- number of rows
//
// History: May-2-95 BartoszM Created
//
//--------------------------------------------------------------------------
void CAsyncQuery::GetWatchInfo (
HWATCHREGION hRegion,
ULONG* pMode,
CI_TBL_CHAPT* pChapter,
CI_TBL_BMK* pBookmark,
DBCOUNTITEM* pcRows)
{
_Table.GetWatchRegionInfo (hRegion, pChapter, pBookmark, (DBROWCOUNT *)pcRows);
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::ShrinkWatchRegion
//
// Synopsis: Stub implementation
//
// Arguments: [hRegion] -- handle to watch region
// [pChapter] -- chapter
// [pBookmark] -- bookmark
// [cRows] -- number of rows
//
// History: May-2-95 BartoszM Created
//
//--------------------------------------------------------------------------
void CAsyncQuery::ShrinkWatchRegion (
HWATCHREGION hRegion,
CI_TBL_CHAPT chapter,
CI_TBL_BMK bookmark,
LONG cRows )
{
if (cRows == 0)
_Table.DeleteWatchRegion (hRegion);
else
_Table.ShrinkWatchRegion (hRegion, chapter, bookmark, cRows);
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::Refresh
//
// Synopsis: Stub implementation
//
// Arguments: [] --
//
// History: Arp-4-95 BartoszM Created
//
//--------------------------------------------------------------------------
void CAsyncQuery::Refresh()
{
_Table.Refresh();
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::GetQueryStatus, public
//
// Synopsis: Return the query status
//
// Arguments: [hCursor] - the handle of the cursor to check completion for
// [rdwStatus] - on return, the query status
//
// Returns: nothing
//
//--------------------------------------------------------------------------
void CAsyncQuery::GetQueryStatus(
ULONG hCursor,
DWORD & rdwStatus)
{
rdwStatus = _Table.Status();
}
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::GetQueryStatusEx, public
//
// Synopsis: Return the query status plus bonus information. It's kind
// of an odd assortment of info, but it saves net trips.
//
// Arguments: [hCursor] - handle of the cursor to check completion for
// [rdwStatus] - returns the query status
// [rcFilteredDocuments] - returns # of filtered docs
// [rcDocumentsToFilter] - returns # of docs to filter
// [rdwRatioFinishedDenominator] - ratio finished denom
// [rdwRatioFinishedNumerator] - ratio finished num
// [bmk] - bmk to find
// [riRowBmk] - index of bmk row
// [rcRowsTotal] - # of rows in table
//
// History: Nov-9-96 dlee Created
//
//--------------------------------------------------------------------------
void CAsyncQuery::GetQueryStatusEx(
ULONG hCursor,
DWORD & rdwStatus,
DWORD & rcFilteredDocuments,
DWORD & rcDocumentsToFilter,
DBCOUNTITEM & rdwRatioFinishedDenominator,
DBCOUNTITEM & rdwRatioFinishedNumerator,
CI_TBL_BMK bmk,
DBCOUNTITEM & riRowBmk,
DBCOUNTITEM & rcRowsTotal )
{
rdwStatus = _Table.Status();
CIF_STATE state;
state.cbStruct = sizeof state;
SCODE sc = _xCiManager->GetStatus( &state );
if ( SUCCEEDED( sc ) )
{
rcFilteredDocuments = state.cFilteredDocuments;
rcDocumentsToFilter = state.cDocuments;
}
else
{
ciDebugOut(( DEB_ERROR, "CAsyncQuery::GetQueryStatusEx, get status failed, 0x%x\n", sc ));
rcFilteredDocuments = 0;
rcDocumentsToFilter = 0;
}
DBCOUNTITEM cRows;
BOOL fNewRows;
RatioFinished( hCursor,
rdwRatioFinishedDenominator,
rdwRatioFinishedNumerator,
cRows,
fNewRows );
GetApproximatePosition( hCursor,
0,
bmk,
& riRowBmk,
& rcRowsTotal );
} //GetQueryStatusEx
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::WorkIdToPath
//
// Synopsis: Converts a wid to a path
//
// Arguments: [wid] -- of the file to be translated
// [funnyPath] -- resulting path
//
// History: Jun-1-95 dlee Created
//
//--------------------------------------------------------------------------
void CAsyncQuery::WorkIdToPath( WORKID wid, CFunnyPath & funnyPath )
{
if ( _fCanDoWorkidToPath )
{
ULONG cbBuf = MAX_PATH * sizeof WCHAR; // first guess -- it may be more
XArray<BYTE> xBuf( cbBuf );
CInlineVariant * pVariant = (CInlineVariant *) xBuf.GetPointer();
if (! _Table.WorkIdToPath( wid, *pVariant, cbBuf ) )
{
if ( 0 != cbBuf )
{
BYTE *pb = xBuf.Acquire();
delete [] pb;
cbBuf += sizeof CInlineVariant;
xBuf.Init( cbBuf );
_Table.WorkIdToPath( wid, *pVariant, cbBuf );
}
}
if ( 0 != cbBuf )
{
WCHAR *pwc = (WCHAR *) pVariant->GetVarBuffer();
funnyPath.SetPath( pwc );
}
}
else
{
ICiCDocName *pDocName;
SCODE sc = _xNameToWidTranslator->QueryDocName( &pDocName );
if ( SUCCEEDED( sc ) )
{
XInterface<ICiCDocName> xDocName( pDocName );
sc = _xNameToWidTranslator->WorkIdToDocName( wid,
xDocName.GetPointer() );
if ( SUCCEEDED( sc ) && sc != CI_S_WORKID_DELETED )
{
// PERFFIX: Here we are using two buffers XGrowable and CFunnyPath.
// This can be avoided if xDocName->Get can take in CFunnyPath instead of WCHAR*
XGrowable<WCHAR> xBuf(MAX_PATH);
ULONG cb = xBuf.SizeOf();
sc = xDocName->Get( (BYTE *) xBuf.Get(), &cb );
if ( CI_E_BUFFERTOOSMALL == sc )
{
xBuf.SetSizeInBytes( cb );
sc = xDocName->Get( (BYTE *) xBuf.Get(), &cb );
}
if ( SUCCEEDED( sc ) )
{
funnyPath.SetPath( xBuf.Get() );
}
}
}
}
} //WorkIdToPath
BOOL CAsyncQuery::CanDoWorkIdToPath()
{
return _fCanDoWorkidToPath;
} //CanDoWorkIdToPath
//+-------------------------------------------------------------------------
//
// Member: CAsyncQuery::FetchDeferredValue
//
// Synopsis: Fetch deferred value from property cache
//
// Arguments: [wid] -- Workid.
// [ps] -- Property to be fetched.
// [var] -- Property returned here.
//
// History: Jun-1-95 KyleP Created
//
//--------------------------------------------------------------------------
BOOL CAsyncQuery::FetchDeferredValue(
WORKID wid,
CFullPropSpec const & ps,
PROPVARIANT & var )
{
//
// If using a NULL catalog, assume a file system and go get the value.
// The NULL catalog case is only supported by fsci, anyway, so it's
// ok to do this hack.
//
if ( _fCanDoWorkidToPath )
{
CFunnyPath funnyPath;
WorkIdToPath( wid, funnyPath );
COLEPropManager propMgr;
propMgr.Open( funnyPath );
return propMgr.ReadProperty( ps, var );
}
return _QExec->FetchDeferredValue( wid, ps, var );
} //FetchDeferredValue
Reference in a new issue Copy permalink