780 lines
22 KiB
C++
780 lines
22 KiB
C++
|
//+-------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Microsoft Windows
|
||
|
|
// Copyright (C) Microsoft Corporation, 1994 - 2000.
|
||
|
|
//
|
||
|
|
// File: tblwindo.hxx
|
||
|
|
//
|
||
|
|
// Contents: Declaration of the CTableWindow class, a component of
|
||
|
|
// a large table.
|
||
|
|
//
|
||
|
|
// Classes: CTableWindow
|
||
|
|
//
|
||
|
|
// History: 14 Jun 1994 Alanw Created
|
||
|
|
// 20 Jun 1995 BartoszM Added watch regions
|
||
|
|
//
|
||
|
|
//--------------------------------------------------------------------------
|
||
|
|
|
||
|
|
#pragma once
|
||
|
|
|
||
|
|
#include <tableseg.hxx>
|
||
|
|
#include <shardbuf.hxx> // Shared buffer
|
||
|
|
|
||
|
|
#include "tblvarnt.hxx" // for CTableVariant
|
||
|
|
#include "rowcomp.hxx" // for CRowCompareXX
|
||
|
|
#include "rowindex.hxx" // for CRowIndex
|
||
|
|
#include "bmkmap.hxx" // for Book Mark Mapping
|
||
|
|
#include "wnotifmg.hxx" // Watch region notifications manager
|
||
|
|
|
||
|
|
class CTableWindowSplit;
|
||
|
|
class CTableRowKey;
|
||
|
|
class CPathStore;
|
||
|
|
class CSingletonCursor;
|
||
|
|
|
||
|
|
class CWindowWatch
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
|
||
|
|
HWATCHREGION _hRegion;
|
||
|
|
long _iRowStart;
|
||
|
|
long _cRowsHere; // rows watched in this window
|
||
|
|
long _cRowsLeft; // rows watched here and in following segments
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
class CChangeScript; // NEWFEATURE - until we give change scripts.
|
||
|
|
|
||
|
|
//+-------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Class: CTableWindow
|
||
|
|
//
|
||
|
|
// Purpose: A segment of a large table which is fully buffered in
|
||
|
|
// memory.
|
||
|
|
// It can be directly transferred to the user from the
|
||
|
|
// cached rowdata.
|
||
|
|
//
|
||
|
|
// Interface:
|
||
|
|
//
|
||
|
|
//--------------------------------------------------------------------------
|
||
|
|
|
||
|
|
class CTableWindow : public CTableSegment
|
||
|
|
{
|
||
|
|
INLINE_UNWIND( CTableWindow )
|
||
|
|
|
||
|
|
friend CRowCompareVariant;
|
||
|
|
friend class CTableWindowSplit;
|
||
|
|
friend class CLargeTable;
|
||
|
|
friend class CWindowRowIter;
|
||
|
|
friend class CTableRowLocator;
|
||
|
|
friend class CBucketizeWindows;
|
||
|
|
|
||
|
|
public:
|
||
|
|
//
|
||
|
|
// Indicator values for data values.
|
||
|
|
//
|
||
|
|
// NOTE: These values need to be translated between these values
|
||
|
|
// and the standard defines used by OLE DB. We define our
|
||
|
|
// own values so we can store them in a byte (or smaller)
|
||
|
|
// field in the row data.
|
||
|
|
//
|
||
|
|
enum TableIndicator
|
||
|
|
{
|
||
|
|
TBL_DATA_OKAY = 0, // data stored okay
|
||
|
|
TBL_DATA_OUTOFRANGE, // range error, e.g., long into short
|
||
|
|
TBL_DATA_CANTCOERCE, // type mismatch
|
||
|
|
TBL_DATA_USEENTRYID, // entry too big, use entry ID
|
||
|
|
TBL_DATA_OVERRUN, // value too big for data area
|
||
|
|
TBL_DATA_EMPTY, // no value for this data point
|
||
|
|
TBL_DATA_ROWADDED, // row status: added after cursor created
|
||
|
|
TBL_DATA_BADBOOKMARK, // row status: bookmark for row was invalid
|
||
|
|
TBL_DATA_PENDING_DELETE, // row status: pending delete
|
||
|
|
TBL_DATA_HARD_DELETE // row status: hard deleted; not visible
|
||
|
|
};
|
||
|
|
|
||
|
|
CTableWindow(
|
||
|
|
CSortSet const * pSortSet,
|
||
|
|
CTableKeyCompare & comparator,
|
||
|
|
CColumnMasterSet * pMasterColumns,
|
||
|
|
ULONG segId,
|
||
|
|
CCategorize *pCategorizer,
|
||
|
|
CSharedBuffer & sharedBuf,
|
||
|
|
CQAsyncExecute & QExecute
|
||
|
|
);
|
||
|
|
|
||
|
|
CTableWindow( CTableWindow & src,
|
||
|
|
ULONG segId
|
||
|
|
);
|
||
|
|
|
||
|
|
~CTableWindow();
|
||
|
|
|
||
|
|
// Virtual methods inherited from CTableSink
|
||
|
|
WORKID PathToWorkID( CRetriever& obj,
|
||
|
|
CTableSink::ERowType eRowType );
|
||
|
|
|
||
|
|
BOOL PutRow( CRetriever & obj, CTableSink::ERowType eRowType )
|
||
|
|
{
|
||
|
|
Win4Assert( !"Must not be called" );
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL RemoveRow( PROPVARIANT const & varUnique,
|
||
|
|
WORKID & widNext,
|
||
|
|
CI_TBL_CHAPT & chapt );
|
||
|
|
|
||
|
|
CSortSet const & SortOrder();
|
||
|
|
|
||
|
|
// Virtual methods inherited from CTableSegment
|
||
|
|
BOOL PutRow( CRetriever & obj, CTableRowKey & currKey );
|
||
|
|
|
||
|
|
DBCOUNTITEM RowCount()
|
||
|
|
{
|
||
|
|
return _visibleRowIndex.RowCount();
|
||
|
|
}
|
||
|
|
|
||
|
|
SCODE GetRows( HWATCHREGION hRegion,
|
||
|
|
WORKID widStart,
|
||
|
|
CI_TBL_CHAPT chapt,
|
||
|
|
ULONG & cRowsToGet,
|
||
|
|
CTableColumnSet const & rOutColumns,
|
||
|
|
CGetRowsParams& rGetParams,
|
||
|
|
WORKID& rwidNextRowToTransfer );
|
||
|
|
|
||
|
|
void LokGetOneColumn( WORKID wid,
|
||
|
|
CTableColumn const & rOutColumn,
|
||
|
|
BYTE * pbOut,
|
||
|
|
PVarAllocator & rVarAllocator );
|
||
|
|
|
||
|
|
BOOL IsRowInSegment( WORKID wid );
|
||
|
|
|
||
|
|
BOOL IsPendingDelete( WORKID wid );
|
||
|
|
|
||
|
|
void CompareRange( CRetriever &obj, CCompareResult & rslt );
|
||
|
|
|
||
|
|
SCODE GetNotifications( CNotificationParams &rParams );
|
||
|
|
|
||
|
|
// Other public methods
|
||
|
|
BOOL RowOffset(WORKID wid, ULONG & iRow)
|
||
|
|
{
|
||
|
|
if ( widInvalid == wid )
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
TBL_OFF obRowOffset = 0;
|
||
|
|
if ( FindBookMark( wid, obRowOffset, iRow ) )
|
||
|
|
return TRUE;
|
||
|
|
else return _FindWorkId(wid, obRowOffset, iRow);
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL FindBookMark( WORKID wid, TBL_OFF &obRow, ULONG & iRow );
|
||
|
|
|
||
|
|
WORKID GetBookMarkAt( ULONG iRow );
|
||
|
|
|
||
|
|
WORKID GetFirstBookMark();
|
||
|
|
|
||
|
|
int CompressData(); // attempt to reduce data storage needs
|
||
|
|
|
||
|
|
inline ULONG MemUsed( void ) {
|
||
|
|
// PERFFIX - also need so sum all non-global, non-shared compressions
|
||
|
|
return _cbHeapUsed + _DataAllocator.MemUsed();
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL IsSortedSplit( ULONG & riSplit )
|
||
|
|
{
|
||
|
|
return _GetInvisibleRowIndex().FindMidSplitPoint( riSplit );
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL IsEmptyForQuery();
|
||
|
|
|
||
|
|
BOOL IsGettingFull();
|
||
|
|
|
||
|
|
unsigned PercentFull();
|
||
|
|
|
||
|
|
// Watch region manipulations
|
||
|
|
|
||
|
|
long AddWatch (HWATCHREGION hRegion,
|
||
|
|
LONG iStart,
|
||
|
|
LONG cRows,
|
||
|
|
BOOL isLast);
|
||
|
|
|
||
|
|
long ModifyWatch (HWATCHREGION hRegion,
|
||
|
|
LONG iStart,
|
||
|
|
LONG cRows,
|
||
|
|
BOOL isLast);
|
||
|
|
|
||
|
|
long DeleteWatch (HWATCHREGION hRegion);
|
||
|
|
|
||
|
|
long ShrinkWatch (HWATCHREGION hRegion,
|
||
|
|
CI_TBL_BMK bookmark,
|
||
|
|
LONG cRows);
|
||
|
|
|
||
|
|
long ShrinkWatch (HWATCHREGION hRegion, LONG cRows);
|
||
|
|
|
||
|
|
BOOL HasWatch (HWATCHREGION hRegion);
|
||
|
|
|
||
|
|
BOOL IsWatched (HWATCHREGION hRegion, CI_TBL_BMK bookmark);
|
||
|
|
|
||
|
|
BOOL IsWatched()
|
||
|
|
{
|
||
|
|
if ( _aWindowWatch.Count() > 0 )
|
||
|
|
{
|
||
|
|
if ( _xDeltaBookMarkMap.IsNull() )
|
||
|
|
_xDeltaBookMarkMap.Set( new CBookMarkMap( _dynRowIndex ) );
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
long RowsWatched (HWATCHREGION hRegion);
|
||
|
|
|
||
|
|
WORKID RowWorkid(BYTE *pRow)
|
||
|
|
{ return *(WORKID *) (pRow + _iOffsetWid); }
|
||
|
|
|
||
|
|
LONG RowRank(BYTE *pRow)
|
||
|
|
{
|
||
|
|
return ( ULONG_MAX == _iOffsetRank ) ?
|
||
|
|
MAX_QUERY_RANK :
|
||
|
|
*(LONG *) (pRow + _iOffsetRank);
|
||
|
|
}
|
||
|
|
|
||
|
|
LONG RowHitCount(BYTE *pRow)
|
||
|
|
{
|
||
|
|
return ( ULONG_MAX == _iOffsetHitCount ) ?
|
||
|
|
0 :
|
||
|
|
*(LONG *) (pRow + _iOffsetHitCount);
|
||
|
|
}
|
||
|
|
|
||
|
|
long GetWatchStart( HWATCHREGION hRegion) const
|
||
|
|
{
|
||
|
|
unsigned i = FindRegion(hRegion);
|
||
|
|
Win4Assert (i < _aWindowWatch.Count());
|
||
|
|
|
||
|
|
return _aWindowWatch.Get(i)._iRowStart;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL FindNearestDynamicBmk( CI_TBL_CHAPT chapter,
|
||
|
|
CI_TBL_BMK & bookmark );
|
||
|
|
|
||
|
|
BOOL FindFirstNonDeleteDynamicBmk( CI_TBL_BMK & bookmark );
|
||
|
|
|
||
|
|
BOOL FindLastNonDeleteDynamicBmk( CI_TBL_BMK & bookmark );
|
||
|
|
|
||
|
|
BOOL IsFirstRowFirstOfCategory();
|
||
|
|
|
||
|
|
#ifdef CIEXTMODE
|
||
|
|
void CiExtDump(void *ciExtSelf);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
//
|
||
|
|
// No Copy consructor allowed for this.
|
||
|
|
//
|
||
|
|
CTableWindow( CTableWindow & src );
|
||
|
|
|
||
|
|
void _FinishInit( CTableRowAlloc & rowMap, unsigned &maxAlignment );
|
||
|
|
|
||
|
|
CSharedBuffer & _GetSharedBuf() const { return _sharedBuf; }
|
||
|
|
|
||
|
|
void _InitSortComparators();
|
||
|
|
|
||
|
|
void _PopulateRow( CRetriever &obj, BYTE *pThisRow, WORKID wid );
|
||
|
|
|
||
|
|
BOOL _FindWorkId( WORKID wid, TBL_OFF & obRow, ULONG & iRow );
|
||
|
|
|
||
|
|
WORKID _GetWorkIdAt( ULONG iRow );
|
||
|
|
|
||
|
|
WORKID _GetFirstWorkId();
|
||
|
|
|
||
|
|
WORKID _GetLastWorkId();
|
||
|
|
|
||
|
|
void _AddColumnDesc( CColumnMasterDesc& MasterCol,
|
||
|
|
CTableRowAlloc& RowMap,
|
||
|
|
unsigned& maxAlignment);
|
||
|
|
|
||
|
|
void _AddColumnDesc( CTableColumn & src,
|
||
|
|
CTableRowAlloc& RowMap,
|
||
|
|
unsigned& maxAlignment);
|
||
|
|
|
||
|
|
void _AddWatchItem (CWindowWatch& watch);
|
||
|
|
|
||
|
|
void _RemoveWatchItem (unsigned i);
|
||
|
|
|
||
|
|
CRowIndex & _GetInvisibleRowIndex()
|
||
|
|
{
|
||
|
|
return IsWatched() ? _dynRowIndex : _visibleRowIndex;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Methods used for window->bucket conversion
|
||
|
|
//
|
||
|
|
|
||
|
|
void GetSortKey( ULONG iRow, CTableRowKey & bktRow );
|
||
|
|
|
||
|
|
unsigned FindRegion (HWATCHREGION hRegion) const;
|
||
|
|
|
||
|
|
void _StartStaticDynamicSplit();
|
||
|
|
void _EndStaticDynamicSplit();
|
||
|
|
void _ReconcileRowIndexes( CRowIndex & dst , CRowIndex & src );
|
||
|
|
void _CleanupAndReconcileRowIndexes( BOOL fCreatingWatch );
|
||
|
|
void _Refresh();
|
||
|
|
|
||
|
|
//
|
||
|
|
// Storage for fixed length row data
|
||
|
|
//
|
||
|
|
|
||
|
|
unsigned _cbRowSize; // size in bytes of data for each row
|
||
|
|
unsigned _iOffsetWid; // offset of WorkID in row data
|
||
|
|
unsigned _iOffsetRank; // offset of rank in row data
|
||
|
|
unsigned _iOffsetHitCount; // offset of hitcount in row data
|
||
|
|
unsigned _iOffsetRowStatus; // offset of row status in row data
|
||
|
|
unsigned _iOffsetChapter; // offset of chapter number (optional)
|
||
|
|
CTableColumnSet _Columns; // column descriptions for this window
|
||
|
|
|
||
|
|
//
|
||
|
|
// Shared buffer for the whole table used as temporary memory.
|
||
|
|
//
|
||
|
|
CSharedBuffer & _sharedBuf;
|
||
|
|
|
||
|
|
XPtr<CSingletonCursor> _xCursor; // singleton cursor used in GetRows
|
||
|
|
|
||
|
|
//
|
||
|
|
// Memory management related methods and variables.
|
||
|
|
//
|
||
|
|
|
||
|
|
BYTE * _RowAlloc( void )
|
||
|
|
{
|
||
|
|
_cRowsAllocated++;
|
||
|
|
|
||
|
|
// Just get a new row from the allocator
|
||
|
|
|
||
|
|
BYTE *pbRetBuf = (BYTE *) _DataAllocator.AllocFixed();
|
||
|
|
|
||
|
|
Win4Assert(0 != pbRetBuf);
|
||
|
|
|
||
|
|
return pbRetBuf;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Additional storage for variable length data which is not
|
||
|
|
// stored as a compressed column. When first needed after a
|
||
|
|
// window is created, this will begin at the end of the block of
|
||
|
|
// data for row data, and grow downward toward it. When these
|
||
|
|
// grow enough to meet, the row data will be moved out into
|
||
|
|
// a separate block, allowing the variable data to expand into the
|
||
|
|
// newly freed area.
|
||
|
|
//
|
||
|
|
// At the time this data is moved or grown, it may be a good time to
|
||
|
|
// convert columns for compressions. All extra data for
|
||
|
|
// compressed columns will be stored with the column descriptor.
|
||
|
|
//
|
||
|
|
|
||
|
|
CFixedVarTableWindowAllocator _DataAllocator; // Variable data allocator
|
||
|
|
|
||
|
|
ULONG _cbHeapUsed; // total heap memory used by structure
|
||
|
|
|
||
|
|
CPathStore * _pPathStore; // Store for paths.
|
||
|
|
|
||
|
|
//
|
||
|
|
// Row indirection object. This holds offsets in the heap where each
|
||
|
|
// row resides. The row index is sorted by the current sort order.
|
||
|
|
//
|
||
|
|
CRowIndex _dynRowIndex;
|
||
|
|
|
||
|
|
//
|
||
|
|
// The "static" row index that will be used for giving rows to the
|
||
|
|
// client (user).
|
||
|
|
//
|
||
|
|
CRowIndex _visibleRowIndex;
|
||
|
|
|
||
|
|
//
|
||
|
|
// BookMark mapping object. If there are no notifications, it is
|
||
|
|
// associated with the _dynRowIndex; o/w it is associated with the
|
||
|
|
// _visibleRowIndex.
|
||
|
|
//
|
||
|
|
CBookMarkMap _BookMarkMap;
|
||
|
|
|
||
|
|
//
|
||
|
|
// BookMark mapping object for the "deltas" or changes pending
|
||
|
|
// notification to the user. It is always associated with the _dynRowIndex
|
||
|
|
//
|
||
|
|
XPtr<CBookMarkMap> _xDeltaBookMarkMap;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Notification processing object
|
||
|
|
//
|
||
|
|
CDynArrayInPlace<CWindowWatch> _aWindowWatch;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Row sorting objects.
|
||
|
|
//
|
||
|
|
|
||
|
|
XPtr<CRowCompareVariant> _RowCompare;
|
||
|
|
XPtr<CRowCompare> _QuickRowCompare;
|
||
|
|
CSortSet const * _pSortSet;
|
||
|
|
|
||
|
|
ULONG _cPendingDeletes; // # of rows with pending deletes. These are
|
||
|
|
// visible to retrievals.
|
||
|
|
ULONG _cRowsHardDeleted; // # of rows "hard" deleted - not visible to
|
||
|
|
// retrievals.
|
||
|
|
|
||
|
|
ULONG _cRowsAllocated; // # of rows allocated in the table
|
||
|
|
|
||
|
|
|
||
|
|
BOOL _fSplitInProgress; // Flag set to TRUE when a window split is
|
||
|
|
// in progress.
|
||
|
|
|
||
|
|
CQAsyncExecute & _QueryExecute; // The query object that will be used
|
||
|
|
// when retrieving the partial deferred cols.
|
||
|
|
|
||
|
|
BOOL _IsTableWatched() const;
|
||
|
|
|
||
|
|
ULONG _AllocatedRowCount()
|
||
|
|
{
|
||
|
|
return _cRowsAllocated;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL _fCanPartialDefer ; // Is set in constructor by taking value from the query session
|
||
|
|
|
||
|
|
//
|
||
|
|
// Functions to get at row metadata that always exists
|
||
|
|
//
|
||
|
|
|
||
|
|
void _SetRowWorkid(BYTE *pRow,WORKID wid)
|
||
|
|
{ *(WORKID *) (pRow + _iOffsetWid) = wid; }
|
||
|
|
ULONG _RowStatus(BYTE *pRow)
|
||
|
|
{ return *(BYTE *) (pRow + _iOffsetRowStatus); }
|
||
|
|
void _SetRowStatus(BYTE *pRow,BYTE status)
|
||
|
|
{ *(BYTE *) (pRow + _iOffsetRowStatus) = status; }
|
||
|
|
|
||
|
|
ULONG _RowChapter(BYTE *pRow)
|
||
|
|
{ return *(unsigned *) (pRow + _iOffsetChapter); }
|
||
|
|
|
||
|
|
void _SetChapter(BYTE *pRow,unsigned Chapter)
|
||
|
|
{ *(unsigned *) (pRow + _iOffsetChapter) = Chapter; }
|
||
|
|
|
||
|
|
//
|
||
|
|
// Methods to support window splitting. These will be used by the
|
||
|
|
// CTableWindowSplit class.
|
||
|
|
//
|
||
|
|
|
||
|
|
CRowIndex & _GetVisibleRowIndex()
|
||
|
|
{
|
||
|
|
return _visibleRowIndex;
|
||
|
|
}
|
||
|
|
|
||
|
|
CRowIndex & _GetDynamicRowIndex()
|
||
|
|
{
|
||
|
|
return _dynRowIndex;
|
||
|
|
}
|
||
|
|
|
||
|
|
BYTE * _GetRow( TBL_OFF oTableRow )
|
||
|
|
{
|
||
|
|
return (BYTE *) _DataAllocator.FixedPointer( oTableRow );
|
||
|
|
}
|
||
|
|
|
||
|
|
void _PutRowToVisibleRowIndex( CTableWindow & srcWindow, TBL_OFF oSrcRow );
|
||
|
|
|
||
|
|
void _PutRowToDynRowIndex( CTableWindow & srcWindow, TBL_OFF oSrcRow );
|
||
|
|
|
||
|
|
TBL_OFF _CopyRow( CTableWindow & srcWindow, TBL_OFF oSrcRow );
|
||
|
|
|
||
|
|
WORKID _GetWorkId( TBL_OFF oTableRow )
|
||
|
|
{
|
||
|
|
BYTE * pbRow = _GetRow( oTableRow );
|
||
|
|
return RowWorkid( pbRow );
|
||
|
|
}
|
||
|
|
|
||
|
|
LONG _GetRank( TBL_OFF oTableRow )
|
||
|
|
{
|
||
|
|
BYTE * pbRow = _GetRow( oTableRow );
|
||
|
|
return RowRank( pbRow );
|
||
|
|
}
|
||
|
|
|
||
|
|
LONG _GetHitCount( TBL_OFF oTableRow )
|
||
|
|
{
|
||
|
|
BYTE * pbRow = _GetRow( oTableRow );
|
||
|
|
return RowHitCount( pbRow );
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL _IsRowDeleted( TBL_OFF oTableRow )
|
||
|
|
{
|
||
|
|
BYTE * pbRow = _GetRow( oTableRow );
|
||
|
|
const ULONG rowStatus = _RowStatus( pbRow );
|
||
|
|
return TBL_DATA_PENDING_DELETE == rowStatus ||
|
||
|
|
TBL_DATA_HARD_DELETE == rowStatus ;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL _IsWorkIdInVisRowIndex( WORKID wid )
|
||
|
|
{
|
||
|
|
return _BookMarkMap.IsBookMarkPresent(wid);
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL _IsRowInVisRowIndex( TBL_OFF oTableRow )
|
||
|
|
{
|
||
|
|
BYTE * pbRow = _GetRow(oTableRow);
|
||
|
|
Win4Assert( pbRow );
|
||
|
|
WORKID wid = RowWorkid(pbRow);
|
||
|
|
TBL_OFF oRowFound;
|
||
|
|
BOOL fFound = _BookMarkMap.FindBookMark( wid, oRowFound );
|
||
|
|
return fFound && oRowFound == oTableRow;
|
||
|
|
}
|
||
|
|
|
||
|
|
int _CompareRows( TBL_OFF obRow1, TBL_OFF obRow2 )
|
||
|
|
{
|
||
|
|
if ( 0 != _QuickRowCompare.GetPointer() )
|
||
|
|
return _QuickRowCompare->Compare( obRow1, obRow2 );
|
||
|
|
else
|
||
|
|
return _RowCompare->Compare( obRow1, obRow2 );
|
||
|
|
}
|
||
|
|
|
||
|
|
BYTE * _GetRowFromIndex( ULONG iRow, CRowIndex & rowIndex )
|
||
|
|
{
|
||
|
|
return _GetRow( rowIndex.GetRow( iRow ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
void _SetSplitInProgress() { _fSplitInProgress = TRUE; }
|
||
|
|
void _SetSplitDone() { _fSplitInProgress = FALSE; }
|
||
|
|
|
||
|
|
void _CopyColumnData( BYTE* pbSrcRow, BYTE* pbOutRow,
|
||
|
|
CTableColumn **pTableCols, CTableColumnSet const& rOutColumns,
|
||
|
|
PVarAllocator& rDstPool, CRetriever* obj = NULL );
|
||
|
|
|
||
|
|
inline BOOL _CanPartialDeferCol( XPtr<CTableColumn>& xTableCol ) const
|
||
|
|
{
|
||
|
|
Win4Assert( xTableCol.GetPointer() );
|
||
|
|
Win4Assert( _pSortSet );
|
||
|
|
|
||
|
|
return ( xTableCol->PropId != pidWorkId &&
|
||
|
|
xTableCol->PropId != pidRank &&
|
||
|
|
xTableCol->PropId != pidRankVector &&
|
||
|
|
xTableCol->PropId != pidHitCount &&
|
||
|
|
xTableCol->PropId != pidRowStatus &&
|
||
|
|
xTableCol->PropId != pidChapter &&
|
||
|
|
xTableCol->PropId != pidSelf &&
|
||
|
|
!_pSortSet->Exists( xTableCol->PropId ) );
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
//+-------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CTableWindow::PathToWorkID, inline
|
||
|
|
//
|
||
|
|
// Synopsis: Path to WorkID conversion
|
||
|
|
//
|
||
|
|
// Arguments: [obj] -- positioned cursor to row
|
||
|
|
//
|
||
|
|
// Returns: WORKID - the WorkID assigned
|
||
|
|
//
|
||
|
|
// Notes: This method should be called only on CLargeTable.
|
||
|
|
// CLEANCODE: for now it's convenient to have this as a
|
||
|
|
// virtual method on CTableSink. It should become
|
||
|
|
// an ordinary method on CLargeTable once the
|
||
|
|
// ITable code is removed.
|
||
|
|
//
|
||
|
|
//--------------------------------------------------------------------------
|
||
|
|
|
||
|
|
inline WORKID CTableWindow::PathToWorkID(
|
||
|
|
CRetriever& obj,
|
||
|
|
CTableSink::ERowType eRowType )
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CTableWindow::GetBookMarkAt
|
||
|
|
//
|
||
|
|
// Synopsis: Returns a bookmark at the specified offset.
|
||
|
|
//
|
||
|
|
// Arguments: [iRow] -
|
||
|
|
//
|
||
|
|
// History: 8-04-95 srikants Created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
inline
|
||
|
|
WORKID CTableWindow::GetBookMarkAt( ULONG iRow )
|
||
|
|
{
|
||
|
|
Win4Assert( iRow < _GetVisibleRowIndex().RowCount() );
|
||
|
|
return RowWorkid( _GetRowFromIndex( iRow, _GetVisibleRowIndex() ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CTableWindow::GetFirstBookMark
|
||
|
|
//
|
||
|
|
// Synopsis: Returns the first BOOKMARK in the window. A BOOKMARK is one
|
||
|
|
// which is visible to a client.
|
||
|
|
//
|
||
|
|
// History: 8-04-95 srikants Created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
inline
|
||
|
|
WORKID CTableWindow::GetFirstBookMark()
|
||
|
|
{
|
||
|
|
if ( 0 == RowCount() )
|
||
|
|
return widInvalid;
|
||
|
|
else
|
||
|
|
return GetBookMarkAt(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CTableWindow::_GetWorkIdAt
|
||
|
|
//
|
||
|
|
// Synopsis: Returns the workid at the specified offset in the
|
||
|
|
// "invisible" row index , ie, query row index.
|
||
|
|
//
|
||
|
|
// Arguments: [iRow] -
|
||
|
|
//
|
||
|
|
// History: 8-02-95 srikants Created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
inline
|
||
|
|
WORKID CTableWindow::_GetWorkIdAt( ULONG iRow )
|
||
|
|
{
|
||
|
|
Win4Assert( iRow < _GetInvisibleRowIndex().RowCount() );
|
||
|
|
return RowWorkid( _GetRowFromIndex(iRow , _GetInvisibleRowIndex()) );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: _GetFirstWorkId
|
||
|
|
//
|
||
|
|
// Synopsis: Returns the first WORKID visible to the QUERY only. Note that
|
||
|
|
// this can be different from the first bookmark.
|
||
|
|
//
|
||
|
|
// History: 8-04-95 srikants Created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
inline
|
||
|
|
WORKID CTableWindow::_GetFirstWorkId()
|
||
|
|
{
|
||
|
|
if ( 0 == RowCount() )
|
||
|
|
return widInvalid;
|
||
|
|
else
|
||
|
|
return _GetWorkIdAt(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: _GetLastWorkId
|
||
|
|
//
|
||
|
|
// Synopsis: Returns the last WORKID visible to the QUERY only. Note that
|
||
|
|
// this can be different from the first bookmark.
|
||
|
|
//
|
||
|
|
// History: 03-12-98 vikasman Created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
inline
|
||
|
|
WORKID CTableWindow::_GetLastWorkId()
|
||
|
|
{
|
||
|
|
if ( 0 == RowCount() )
|
||
|
|
return widInvalid;
|
||
|
|
else
|
||
|
|
return _GetWorkIdAt( (ULONG) RowCount() - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Class: CWindowRowIter ()
|
||
|
|
//
|
||
|
|
// Purpose: An iterator to retrieve WORKIDs from the a window.
|
||
|
|
//
|
||
|
|
// History: 2-16-95 srikants Created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
class CWindowRowIter
|
||
|
|
{
|
||
|
|
|
||
|
|
public:
|
||
|
|
|
||
|
|
CWindowRowIter( CTableWindow & window )
|
||
|
|
: _window(window), _rowIndex( window._GetInvisibleRowIndex() ),
|
||
|
|
_curr(0),
|
||
|
|
_cTotal( _rowIndex.RowCount() )
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL AtEnd() const
|
||
|
|
{
|
||
|
|
Win4Assert( _curr <= _cTotal );
|
||
|
|
return _curr == _cTotal;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL AtEnd( ULONG iEnd ) const
|
||
|
|
{
|
||
|
|
Win4Assert( _curr <= _cTotal && iEnd <= _cTotal );
|
||
|
|
return _curr == iEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
WORKID Get() const
|
||
|
|
{
|
||
|
|
Win4Assert( !AtEnd() );
|
||
|
|
TBL_OFF oTableRow = _rowIndex.GetRow(_curr);
|
||
|
|
return _window._GetWorkId( oTableRow );
|
||
|
|
}
|
||
|
|
|
||
|
|
LONG Rank() const
|
||
|
|
{
|
||
|
|
Win4Assert( !AtEnd() );
|
||
|
|
TBL_OFF oTableRow = _rowIndex.GetRow(_curr);
|
||
|
|
return _window._GetRank( oTableRow );
|
||
|
|
}
|
||
|
|
|
||
|
|
LONG HitCount() const
|
||
|
|
{
|
||
|
|
Win4Assert( !AtEnd() );
|
||
|
|
TBL_OFF oTableRow = _rowIndex.GetRow(_curr);
|
||
|
|
return _window._GetHitCount( oTableRow );
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL IsDeletedRow() const
|
||
|
|
{
|
||
|
|
Win4Assert( !AtEnd() );
|
||
|
|
TBL_OFF oTableRow = _rowIndex.GetRow(_curr);
|
||
|
|
return _window._IsRowDeleted( oTableRow );
|
||
|
|
}
|
||
|
|
|
||
|
|
ULONG GetCurrPos() const
|
||
|
|
{
|
||
|
|
return _curr;
|
||
|
|
}
|
||
|
|
|
||
|
|
void Next()
|
||
|
|
{
|
||
|
|
Win4Assert( !AtEnd() );
|
||
|
|
_curr++;
|
||
|
|
}
|
||
|
|
|
||
|
|
ULONG TotalRows() const { return _cTotal; }
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
CTableWindow & _window;
|
||
|
|
CRowIndex & _rowIndex;
|
||
|
|
ULONG _curr;
|
||
|
|
const ULONG _cTotal;
|
||
|
|
};
|
||
|
|
|