You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
578 lines
16 KiB
578 lines
16 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1994 - 2000.
|
|
//
|
|
// File: rowindex.cxx
|
|
//
|
|
// Contents: Implementation of CRowIndex
|
|
//
|
|
// Classes: CRowIndex
|
|
//
|
|
// History: 23 Aug 1994 dlee Created
|
|
// 30 Nov 1996 dlee Converted to use dynarrayinplace
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "pch.cxx"
|
|
#pragma hdrstop
|
|
|
|
#include "rowindex.hxx"
|
|
#include "tabledbg.hxx"
|
|
|
|
inline BOOL isOdd(ULONG x) { return 0 != (x & 1); }
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CRowIndex::_FindInsertionPoint, private
|
|
//
|
|
// Synopsis: Binary search to find insertion point for a row.
|
|
// Returns one past the last row or the first row >=
|
|
// to the given row
|
|
//
|
|
// Arguments: [Value] -- value of the row -- internally an offset
|
|
//
|
|
// History: 23 Aug 1994 dlee Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
ULONG CRowIndex::_FindInsertionPoint(
|
|
TBL_OFF Value ) const
|
|
{
|
|
ULONG cRows = _aRows.Count();
|
|
ULONG iLo = 0;
|
|
ULONG iHi = cRows - 1;
|
|
|
|
do
|
|
{
|
|
ULONG cHalf = cRows / 2;
|
|
|
|
if (0 != cHalf)
|
|
{
|
|
ULONG iMid = isOdd(cRows) ? cHalf : (cHalf - 1);
|
|
iMid += iLo;
|
|
int i = _pRowCompare->Compare( Value, _aRows[iMid] );
|
|
|
|
if (0 == i)
|
|
{
|
|
return iMid;
|
|
}
|
|
else if (i < 0)
|
|
{
|
|
iHi = iMid - 1;
|
|
cRows = isOdd(cRows) ? cHalf : (cHalf - 1);
|
|
}
|
|
else
|
|
{
|
|
iLo = iMid + 1;
|
|
cRows = cHalf;
|
|
}
|
|
}
|
|
else if (0 != cRows)
|
|
{
|
|
int i = _pRowCompare->Compare( Value, _aRows[iLo] );
|
|
|
|
if (i <= 0)
|
|
return iLo;
|
|
else
|
|
return iLo + 1;
|
|
}
|
|
else return iLo;
|
|
}
|
|
while (TRUE);
|
|
|
|
Win4Assert(! "Invalid CRowIndex::_Find function exit point");
|
|
return 0;
|
|
} //_FindInsertionPoint
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: _FindRowByLinearSearch, private
|
|
//
|
|
// Synopsis: Given the offset of a row in the table window, this method
|
|
// searches for the entry in the row index which points to that
|
|
// row.
|
|
//
|
|
// Arguments: [oTableRow] -- Offset of the row in the table window.
|
|
// [iRowIndex] -- On output, will have the index of the entry
|
|
// in the row index which points to oTableRow.
|
|
//
|
|
// Returns: TRUE if found; FALSE o/w
|
|
//
|
|
// History: 11-22-94 srikants Created
|
|
//
|
|
// Notes: The row index is searched linearly. This must be used only
|
|
// if there is no row comparator.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL CRowIndex::_FindRowByLinearSearch(
|
|
TBL_OFF oTableRow,
|
|
ULONG & iRowIndex ) const
|
|
{
|
|
for ( ULONG iCurr = 0; iCurr < _aRows.Count(); iCurr++ )
|
|
{
|
|
if ( _aRows[iCurr] == oTableRow )
|
|
{
|
|
iRowIndex = iCurr;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
} // _FindRowByLinearSearch
|
|
|
|
#if 0
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: _FindRowByBinarySearch, private
|
|
//
|
|
// Synopsis: Using a binary search, this method locates the entry in the
|
|
// row index which is same as the row indicated by oTableRow.
|
|
// As duplicates are allowed, it is possible that there is more
|
|
// than one entry in the row index, which will match the row in
|
|
// the table window indicated by the oTableRow.
|
|
//
|
|
// Arguments: [oTableRow] -- Offset of the row in the table window.
|
|
// [iRowIndex] -- On output, will contain the index of the entry
|
|
// in the row index which has the same key as the "oTableRow"
|
|
//
|
|
// Returns: TRUE if found successfully. FALSE o/w
|
|
//
|
|
// History: 11-22-94 srikants Created
|
|
//
|
|
// Notes: NOT TESTED OR REVIEWED
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL CRowIndex::_FindRowByBinarySearch(
|
|
TBL_OFF oTableRow,
|
|
ULONG & iRowIndex ) const
|
|
{
|
|
|
|
Win4Assert( 0 != _pRowCompare );
|
|
|
|
ULONG *pBase = _Base();
|
|
|
|
ULONG cRows = _aRows.Count();
|
|
ULONG iLo = 0;
|
|
ULONG iHi = _aRows.Count() - 1;
|
|
|
|
ULONG cHalf = 0;
|
|
|
|
do
|
|
{
|
|
cHalf = cRows / 2;
|
|
|
|
if (0 != cHalf)
|
|
{
|
|
ULONG iMid = isOdd(cRows) ? cHalf : (cHalf - 1);
|
|
iMid += iLo;
|
|
|
|
int i = _pRowCompare->Compare(oTableRow, pBase[iMid]);
|
|
|
|
if (0 == i)
|
|
{
|
|
iRowIndex = iMid;
|
|
return TRUE;
|
|
}
|
|
else if (i < 0)
|
|
{
|
|
iHi = iMid - 1;
|
|
cRows = isOdd(cRows) ? cHalf : (cHalf - 1);
|
|
}
|
|
else
|
|
{
|
|
iLo = iMid + 1;
|
|
cRows = cHalf;
|
|
}
|
|
}
|
|
else if (0 != cRows)
|
|
{
|
|
Win4Assert( 1 == cRows );
|
|
int i = _pRowCompare->Compare(oTableRow, pBase[iLo]);
|
|
|
|
if ( 0 == i )
|
|
{
|
|
iRowIndex = iLo;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
while ( 0 != cHalf );
|
|
|
|
Win4Assert( !_FindRowByLinearSearch( oTableRow, iRowIndex ) );
|
|
return FALSE;
|
|
|
|
} // FindRowByBinarySearch
|
|
|
|
#endif
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FindRow, public
|
|
//
|
|
// Synopsis: Given an offset of a row in the table window, this method
|
|
// locates the entry in the row index, which points to the
|
|
// row in the table window.
|
|
//
|
|
// Arguments: [oTableRow] -- (IN) The offset of the row in the table window.
|
|
// [iRowIndex] -- (OUT) The index of the entry in the row index
|
|
// which points to the oTableRow.
|
|
//
|
|
// Returns: TRUE if search successful; FALSE O/W
|
|
//
|
|
// History: 11-22-94 srikants Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL CRowIndex::FindRow( TBL_OFF oTableRow, ULONG &iRowIndex ) const
|
|
{
|
|
return _FindRowByLinearSearch( oTableRow, iRowIndex );
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CRowIndex::AddRow, public
|
|
//
|
|
// Synopsis: Adds a row in sort order to the index
|
|
//
|
|
// Arguments: [Value] -- Value to insert in the index, represents a row
|
|
//
|
|
// Returns: Index of the newly added row
|
|
//
|
|
// History: 23 Aug 1994 dlee Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
ULONG CRowIndex::AddRow(TBL_OFF Value)
|
|
{
|
|
Win4Assert( 0 != _pRowCompare );
|
|
|
|
ULONG cRows = _aRows.Count();
|
|
|
|
// Find the insertion point for the new row.
|
|
|
|
if ( 0 == cRows )
|
|
{
|
|
// No rows yet
|
|
|
|
_aRows[0] = Value;
|
|
return 0;
|
|
}
|
|
else if ( ( _pRowCompare->Compare( _aRows[cRows - 1], Value ) ) <= 0 )
|
|
{
|
|
// append a row to the end
|
|
|
|
_aRows[ cRows ] = Value;
|
|
return cRows;
|
|
}
|
|
|
|
// insert a row.
|
|
|
|
ULONG iInsertionPoint = _FindInsertionPoint( Value );
|
|
|
|
_aRows.Insert( Value, iInsertionPoint );
|
|
|
|
return iInsertionPoint;
|
|
} //AddRow
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CRowIndex::DeleteRow, public
|
|
//
|
|
// Synopsis: Deletes a row from the index and moves the following rows
|
|
// up a notch in the array.
|
|
//
|
|
// Arguments: [iRow] -- row to be deleted
|
|
//
|
|
// History: 29 Aug 1994 dlee Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CRowIndex::DeleteRow(ULONG iRow)
|
|
{
|
|
Win4Assert( iRow < _aRows.Count() );
|
|
|
|
_aRows.Remove( iRow );
|
|
} //DeleteRow
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CRowIndex::ResortRow, public
|
|
//
|
|
// Synopsis: Bubbles the given row up or down based on the sort key.
|
|
// Useful for when a file property is updated after being
|
|
// added to the table.
|
|
//
|
|
// Arguments: [iRow] -- row to be resorted
|
|
//
|
|
// Returns: ULONG - new index of the row
|
|
//
|
|
// PERFFIX: should probably do a binary search, not a linear one
|
|
//
|
|
// History: 29 Aug 1994 dlee Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
ULONG CRowIndex::ResortRow(ULONG iRow)
|
|
{
|
|
Win4Assert(iRow < _aRows.Count());
|
|
|
|
Win4Assert( 0 != _pRowCompare );
|
|
|
|
// Get the start of the array of offsets
|
|
|
|
TBL_OFF *pBase = _Base();
|
|
Win4Assert(0 != pBase);
|
|
|
|
// Bubble toward row 0
|
|
|
|
while ((iRow > 0) &&
|
|
(_pRowCompare->Compare(pBase[iRow], pBase[iRow - 1]) < 0))
|
|
{
|
|
TBL_OFF iTmp = pBase[iRow];
|
|
pBase[iRow] = pBase[iRow - 1];
|
|
iRow--;
|
|
pBase[iRow] = iTmp;
|
|
}
|
|
|
|
// Bubble toward the last row
|
|
|
|
while ((iRow < (_aRows.Count() - 1)) &&
|
|
(_pRowCompare->Compare(pBase[iRow], pBase[iRow + 1]) > 0))
|
|
{
|
|
TBL_OFF iTmp = pBase[iRow];
|
|
pBase[iRow] = pBase[iRow + 1];
|
|
iRow++;
|
|
pBase[iRow] = iTmp;
|
|
}
|
|
|
|
return iRow;
|
|
} //ResortRow
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CRowIndex::ResizeAndInit
|
|
//
|
|
// Synopsis: Resizes the current row index to be the same size as
|
|
// specified.
|
|
//
|
|
// Arguments: [cNewRows] - Number of rows in the new row index.
|
|
//
|
|
// History: 7-31-95 srikants Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CRowIndex::ResizeAndInit( ULONG cNewRows )
|
|
{
|
|
_aRows.Clear();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: SyncUp
|
|
//
|
|
// Synopsis: Synchronizes the permutation (rowindex contents) with that
|
|
// of the new index.
|
|
//
|
|
// Arguments: [newIndex] -- The newIndex whose permutation must be copied
|
|
// to our permutation.
|
|
//
|
|
// History: 11-29-94 srikants Created
|
|
// 11-30-96 dlee converted to dynarrayinplace
|
|
//
|
|
// Notes: The implementation is optimized by doing a block copy of the
|
|
// contents of the source row index. That is much faster than
|
|
// adding individual entries from the source row index.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CRowIndex::SyncUp( CRowIndex & newIndex )
|
|
{
|
|
_aRows.Duplicate( newIndex._aRows );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FindSplitPoint
|
|
//
|
|
// Synopsis: Given a row whose offset in the table is "oTableRow", this
|
|
// method finds out the highest row in the rowIndex which is <=
|
|
// "oTableRow". This method is used during a window split to
|
|
// determine the split-position of a rowIndex.
|
|
//
|
|
// Arguments: [oTableRow] - Offset of the row to compare with.
|
|
//
|
|
// Returns: The first row that belongs to the RHS.
|
|
//
|
|
// History: 1-08-95 srikants Created
|
|
//
|
|
// Notes: This method is used to find a split point in the client
|
|
// row index during a window split. After determining the split
|
|
// point in the query row index, we have to find a point in the
|
|
// client row index which will split the client row index also
|
|
// in the same manner as the query row index.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
LONG CRowIndex::FindSplitPoint( TBL_OFF oTableRow ) const
|
|
{
|
|
|
|
#if DBG==1
|
|
// CheckSortOrder();
|
|
#endif // DBG==1
|
|
|
|
// Get the start of the array of offsets
|
|
|
|
LONG iSplitRow = LONG_MAX;
|
|
|
|
int iComp = 0;
|
|
|
|
if ( 0 == _pRowCompare || 0 == _aRows.Count() )
|
|
{
|
|
iSplitRow = 0;
|
|
}
|
|
else if ( _pRowCompare->Compare( oTableRow, _aRows[0] ) < 0 )
|
|
{
|
|
//
|
|
// The given row is < the smallest row in the row index.
|
|
//
|
|
iSplitRow = 0;
|
|
}
|
|
else if ( (iComp =
|
|
_pRowCompare->Compare( oTableRow, _aRows[_aRows.Count()-1] )) >= 0 )
|
|
{
|
|
//
|
|
// The given row is >= the biggest row in the row index.
|
|
//
|
|
iSplitRow = _aRows.Count();
|
|
}
|
|
else
|
|
{
|
|
|
|
ULONG oSplitRow = _FindInsertionPoint( oTableRow );
|
|
Win4Assert( oSplitRow < _aRows.Count() );
|
|
|
|
iSplitRow = (LONG) _aRows.Count();
|
|
for ( unsigned i = oSplitRow; i < _aRows.Count(); i++ )
|
|
{
|
|
int iComp = _pRowCompare->Compare( oTableRow, _aRows[i] );
|
|
Win4Assert( iComp <= 0 );
|
|
if ( iComp < 0 )
|
|
{
|
|
iSplitRow = (LONG) i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Win4Assert( LONG_MAX != iSplitRow );
|
|
return iSplitRow;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FindMidSplitPoint
|
|
//
|
|
// Synopsis: Finds out a point in the row index which can serve as a split
|
|
// point during a window split. The split point is such that
|
|
// all rows in the rowindex from 0..SplitPoint are <= the row
|
|
// in the SplitPoint and all rows SplitPoint+1.._aRows.Count()-1 are
|
|
// > the row in the SplitPoint.
|
|
//
|
|
// Arguments: [riSplitPoint] - (output) The split point, if one exists.
|
|
//
|
|
// Returns: TRUE if a split point satisfying the above requirement is
|
|
// found. FALSE o/w
|
|
//
|
|
// History: 1-25-95 srikants Created
|
|
//
|
|
// Notes: This method is used during a window split to determine a
|
|
// split point in the query row index (if one exists).
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL CRowIndex::FindMidSplitPoint( ULONG & riSplitPoint ) const
|
|
{
|
|
|
|
#if DBG==1
|
|
// CheckSortOrder();
|
|
#endif // DBG==1
|
|
|
|
BOOL fFound = FALSE;
|
|
|
|
if ( 0 != _aRows.Count() && 0 != _pRowCompare )
|
|
{
|
|
ULONG oMidPoint = _aRows.Count()/2;
|
|
|
|
//
|
|
// Find the first row to the RHS which is > the middle row.
|
|
//
|
|
for ( ULONG j = oMidPoint+1; j < _aRows.Count(); j++ )
|
|
{
|
|
int iComp;
|
|
if ( 0 != ( iComp =
|
|
_pRowCompare->Compare( _aRows[oMidPoint],
|
|
_aRows[j]) ) )
|
|
{
|
|
Win4Assert( iComp < 0 );
|
|
fFound = TRUE;
|
|
riSplitPoint = j-1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !fFound )
|
|
{
|
|
//
|
|
// All rows to the right of oMidPoint are equal. We should now
|
|
// try the LHS.
|
|
//
|
|
for ( int i = (int) oMidPoint-1; i >= 0; i-- )
|
|
{
|
|
int iComp;
|
|
if ( 0 != (iComp = _pRowCompare->Compare( _aRows[i], _aRows[oMidPoint] )) )
|
|
{
|
|
Win4Assert( iComp < 0 );
|
|
fFound = TRUE;
|
|
riSplitPoint = (ULONG) i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// PERFFIX - this algorithm can be modified to find the split point
|
|
// which is as close to the mid point as possible. That would mean
|
|
// looking the LHS even if we find a split point in the RHS and the
|
|
// split point != the oMidPoint. That will involve more comparisons.
|
|
//
|
|
}
|
|
|
|
return fFound;
|
|
}
|
|
|
|
#if CIDBG==1 || DBG==1
|
|
|
|
void CRowIndex::CheckSortOrder() const
|
|
{
|
|
if ( _aRows.Count() <= 1 || 0 == _pRowCompare )
|
|
{
|
|
return;
|
|
}
|
|
|
|
for ( unsigned i = 0; i < _aRows.Count()-1 ; i++ )
|
|
{
|
|
int iComp = _pRowCompare->Compare( _aRows[i], _aRows[i+1] );
|
|
Win4Assert( iComp <= 0 );
|
|
}
|
|
}
|
|
|
|
#endif // CIDBG==1 || DBG==1
|