mars_nwe/mars-flaim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5d6ed25106940bc686ddef219aa801104c3ed2b0
mars-flaim/flaim/src/fscursor.cpp
ahodgkinson 7de8b6be39 Ported FLAIM to FTK. 
git-svn-id: https://svn.code.sf.net/p/flaim/code/trunk@509 0109f412-320b-0410-ab79-c3e0c5ffbbe6
2006-06-05 22:59:36 +00:00

2805 lines
63 KiB
C++
Raw Blame History

//-------------------------------------------------------------------------
// Desc: Routines used during query to traverse through index b-trees.
// Tabs: 3
//
// Copyright (c) 2000-2006 Novell, Inc. All Rights Reserved.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of version 2 of the GNU General Public
// License as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, contact Novell, Inc.
//
// To contact Novell about this file by physical or electronic mail,
// you may find current contact information at www.novell.com
//
// $Id: fscursor.cpp 12329 2006-01-20 17:49:30 -0700 (Fri, 20 Jan 2006) ahodgkinson $
//-------------------------------------------------------------------------
#include "flaimsys.h"
FSTATIC FLMINT FSCompareKeys(
FLMBOOL bKey1IsUntilKey,
FLMBYTE * pKey1,
FLMUINT uiKeyLen1,
FLMBOOL bExclusiveKey1,
FLMBOOL bKey2IsUntilKey,
FLMBYTE * pKey2,
FLMUINT uiKeyLen2,
FLMBOOL bExclusiveKey2);
#define FS_COMPARE_KEYS( bKey1IsUntilKey,pKeyPos1,bKey2IsUntilKey,pKeyPos2) \
FSCompareKeys( (bKey1IsUntilKey), \
(pKeyPos1)->pKey, (pKeyPos1)->uiKeyLen, (pKeyPos1)->bExclusiveKey, \
(bKey2IsUntilKey), \
(pKeyPos2)->pKey, (pKeyPos2)->uiKeyLen, (pKeyPos2)->bExclusiveKey)
/****************************************************************************
Desc:
****************************************************************************/
FSIndexCursor::FSIndexCursor()
{
m_pFirstSet = m_pCurSet = NULL;
m_pSavedPos = NULL;
m_curKeyPos.bStackInUse = FALSE;
reset();
}
/****************************************************************************
Desc:
****************************************************************************/
FSIndexCursor::~FSIndexCursor()
{
releaseBlocks();
freeSets();
}
/****************************************************************************
Desc: Resets any allocations, keys, state, etc.
****************************************************************************/
void FSIndexCursor::reset( void)
{
releaseBlocks();
freeSets();
m_uiIndexNum = m_uiCurrTransId = m_uiBlkChangeCnt = 0;
m_pFirstSet = m_pCurSet = NULL;
m_pSavedPos = NULL;
m_curKeyPos.bExclusiveKey = FALSE;
m_DefaultSet.pNext = m_DefaultSet.pPrev = NULL;
m_DefaultSet.fromKey.bStackInUse =
m_DefaultSet.untilKey.bStackInUse = FALSE;
m_bAtBOF = TRUE;
m_bAtEOF = FALSE;
}
/****************************************************************************
Desc: Resets to a new transaction that may change the read consistency of
the query. This is usually an old view error internal or external of
this class.
****************************************************************************/
RCODE FSIndexCursor::resetTransaction(
FDB * pDb)
{
RCODE rc = FERR_OK;
KEYSET * pTmpSet;
if( RC_BAD( rc = fdictGetIndex(
pDb->pDict, pDb->pFile->bInLimitedMode,
m_uiIndexNum, &m_pLFile, &m_pIxd)))
{
goto Exit;
}
m_uiCurrTransId = pDb->LogHdr.uiCurrTransID;
m_uiBlkChangeCnt = pDb->uiBlkChangeCnt;
m_bIsUpdateTrans = (pDb->uiTransType == FLM_UPDATE_TRANS) ? TRUE : FALSE;
// Need to release all stacks that are currently in use.
for( pTmpSet = m_pFirstSet; pTmpSet; pTmpSet = pTmpSet->pNext)
{
releaseKeyBlocks( &pTmpSet->fromKey);
releaseKeyBlocks( &pTmpSet->untilKey);
}
releaseKeyBlocks( &m_DefaultSet.fromKey);
releaseKeyBlocks( &m_DefaultSet.untilKey);
if( m_pSavedPos)
{
releaseKeyBlocks( m_pSavedPos);
}
releaseKeyBlocks( &m_curKeyPos);
Exit:
return( rc);
}
/****************************************************************************
Desc: Free all of the allocated sets.
****************************************************************************/
void FSIndexCursor::freeSets( void)
{
KEYSET * pCurSet; // Current set.
KEYSET * pNextSet; // Current set.
for( pCurSet = m_pFirstSet; pCurSet; pCurSet = pNextSet)
{
pNextSet = pCurSet->pNext;
if( pCurSet != &m_DefaultSet)
{
f_free( &pCurSet);
}
}
m_pFirstSet = m_pCurSet = NULL;
if( m_pSavedPos)
{
releaseKeyBlocks( m_pSavedPos);
f_free( &m_pSavedPos);
m_pSavedPos = NULL;
}
}
/****************************************************************************
Desc: Releases the cache blocks back to cache.
****************************************************************************/
void FSIndexCursor::releaseBlocks( void)
{
KEYSET * pCurSet;
// Unuse all of the cache blocks in the from and until keys.
for( pCurSet = m_pFirstSet; pCurSet; pCurSet = pCurSet->pNext)
{
releaseKeyBlocks( &pCurSet->fromKey);
releaseKeyBlocks( &pCurSet->untilKey);
}
releaseKeyBlocks( &m_curKeyPos);
}
/****************************************************************************
Desc: Setup the from and until keys in the cursor. Return counts
after positioning to the from and until key in the index.
This code does not work with multiple key sets of FROM/UNTIL keys.
****************************************************************************/
RCODE FSIndexCursor::setupKeys(
FDB * pDb,
IXD * pIxd,
QPREDICATE ** ppQPredicateList,
FLMBOOL * pbDoRecMatch, // [out] Leave alone or set to TRUE.
FLMBOOL * pbDoKeyMatch, // [out] Set to TRUE or FALSE
FLMUINT * puiLeafBlocksBetween,// [out] blocks between the stacks
FLMUINT * puiTotalKeys, // [out] total number of keys
FLMUINT * puiTotalRefs, // [out] total references
FLMBOOL * pbTotalsEstimated) // [out] set to TRUE when estimating.
{
RCODE rc = FERR_OK;
FLMUINT uiUntilKeyLen;
FLMBYTE pUntilKey [MAX_KEY_SIZ + 4];
DIN_STATE dinState;
RESET_DINSTATE( dinState);
m_uiIndexNum = pIxd->uiIndexNum;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
m_DefaultSet.fromKey.uiRefPosition = 0;
m_DefaultSet.untilKey.uiRefPosition = 0;
m_DefaultSet.fromKey.bExclusiveKey = FALSE;
m_DefaultSet.untilKey.bExclusiveKey = TRUE;
if( RC_BAD( rc = flmBuildFromAndUntilKeys( pIxd, ppQPredicateList,
m_DefaultSet.fromKey.pKey, &m_DefaultSet.fromKey.uiKeyLen,
m_DefaultSet.untilKey.pKey, &m_DefaultSet.untilKey.uiKeyLen,
pbDoRecMatch, pbDoKeyMatch, &m_DefaultSet.untilKey.bExclusiveKey)))
{
goto Exit;
}
// Here is a rundown of how the data is setup after this call.
// Default.FROM key - block address and current element offset and
// generated FROM key.
// Default.UNTIL key - full stack setup and the generated UNTIL key
// curKeyPos - pKey is the first key positioned the full stack is setup.
f_memcpy( m_curKeyPos.pKey, m_DefaultSet.fromKey.pKey,
m_curKeyPos.uiKeyLen = m_DefaultSet.fromKey.uiKeyLen);
f_memcpy( pUntilKey, m_DefaultSet.untilKey.pKey,
uiUntilKeyLen = m_DefaultSet.untilKey.uiKeyLen);
m_pCurSet = m_pFirstSet = &m_DefaultSet;
m_DefaultSet.fromKey.uiRecordId = m_curKeyPos.uiRecordId = 0;
m_DefaultSet.fromKey.uiDomain = m_curKeyPos.uiDomain = MAX_DOMAIN;
m_DefaultSet.untilKey.uiRecordId = 0;
m_DefaultSet.untilKey.uiDomain = ZERO_DOMAIN;
// Want any of the counts back?
if( puiLeafBlocksBetween || puiTotalKeys || puiTotalRefs)
{
if( RC_OK( rc = setKeyPosition( pDb, TRUE,
&m_DefaultSet.fromKey, &m_curKeyPos)))
{
// Copy the b-tree information to the from key.
m_DefaultSet.fromKey.uiBlockAddr = m_curKeyPos.uiBlockAddr;
m_DefaultSet.fromKey.uiDomain = m_curKeyPos.uiDomain;
m_DefaultSet.fromKey.uiBlockTransId = m_curKeyPos.uiBlockTransId;
m_DefaultSet.fromKey.uiCurElm = m_curKeyPos.uiCurElm;
// All keys bewteen FROM and UNTIL may be gone.
if( FS_COMPARE_KEYS( FALSE, &m_curKeyPos,
TRUE, &m_DefaultSet.untilKey) <= 0)
{
rc = setKeyPosition( pDb, TRUE,
&m_DefaultSet.untilKey, &m_DefaultSet.untilKey);
rc = (rc == FERR_EOF_HIT) ? FERR_OK: rc;
// Restore the original UNTIL key - throws away what the last key is.
f_memcpy( m_DefaultSet.untilKey.pKey, pUntilKey,
m_DefaultSet.untilKey.uiKeyLen = uiUntilKeyLen);
}
else
{
rc = RC_SET( FERR_BOF_HIT);
}
}
else
{
if( rc == FERR_EOF_HIT)
{
m_bAtEOF = TRUE;
}
m_bAtBOF = FALSE;
}
if( RC_BAD( rc))
{
// Empty tree or empty set case.
if( rc == FERR_EOF_HIT || rc == FERR_BOF_HIT)
{
if( puiLeafBlocksBetween)
*puiLeafBlocksBetween = 0;
if( puiTotalKeys)
*puiTotalKeys = 0;
if( puiTotalRefs)
*puiTotalRefs = 0;
if( pbTotalsEstimated)
*pbTotalsEstimated = FALSE;
rc = FERR_OK;
}
goto Exit;
}
else
{
// If this is a positioning index, set the ref positions.
if( pIxd->uiFlags & IXD_POSITIONING)
{
if( RC_BAD( rc = FSGetBtreeRefPosition( pDb,
m_curKeyPos.pStack, &dinState,
&m_DefaultSet.fromKey.uiRefPosition)))
{
goto Exit;
}
if( RC_BAD( rc = FSGetBtreeRefPosition( pDb,
m_DefaultSet.untilKey.pStack, &dinState,
&m_DefaultSet.untilKey.uiRefPosition)))
{
goto Exit;
}
}
if( RC_BAD( rc = FSComputeIndexCounts( m_curKeyPos.pStack,
m_DefaultSet.untilKey.pStack, puiLeafBlocksBetween, puiTotalKeys,
puiTotalRefs, pbTotalsEstimated)))
{
goto Exit;
}
}
}
m_bAtBOF = TRUE;
Exit:
return( rc);
}
/****************************************************************************
Public: setupKeys
Desc: Setup a cursor with just a single FROM/UNTIL key.
****************************************************************************/
RCODE FSIndexCursor::setupKeys(
FDB * pDb,
IXD * pIxd,
FLMBYTE * pFromKey,
FLMUINT uiFromKeyLen,
FLMUINT uiFromRecordId,
FLMBYTE * pUntilKey,
FLMUINT uiUntilKeyLen,
FLMUINT uiUntilRecordId,
FLMBOOL bExclusiveUntil)
{
RCODE rc;
m_uiIndexNum = pIxd->uiIndexNum;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
m_DefaultSet.pNext = m_DefaultSet.pPrev = NULL;
// FROM key
m_DefaultSet.fromKey.uiRecordId = uiFromRecordId;
m_DefaultSet.fromKey.uiDomain =
uiFromRecordId ? DRN_DOMAIN( uiFromRecordId) + 1: MAX_DOMAIN;
m_DefaultSet.fromKey.uiKeyLen = uiFromKeyLen;
f_memcpy( m_DefaultSet.fromKey.pKey, pFromKey, uiFromKeyLen);
m_DefaultSet.fromKey.bExclusiveKey = FALSE;
// UNTIL key
m_DefaultSet.untilKey.uiRecordId = uiUntilRecordId;
m_DefaultSet.untilKey.uiDomain =
uiUntilRecordId ? DRN_DOMAIN( uiUntilRecordId) + 1: ZERO_DOMAIN;
m_DefaultSet.untilKey.uiKeyLen = uiUntilKeyLen;
f_memcpy( m_DefaultSet.untilKey.pKey, pUntilKey, uiUntilKeyLen);
m_DefaultSet.untilKey.bExclusiveKey = bExclusiveUntil;
m_pFirstSet = &m_DefaultSet;
m_bAtBOF = TRUE;
m_pCurSet = NULL;
// If this is a positioning index we need to setup the FROM/UNTIL
// btrees to get the FROM/UNTIL reference positions.
if( pIxd->uiFlags & IXD_POSITIONING)
{
if( RC_BAD( rc = setupForPositioning( pDb)))
{
goto Exit;
}
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Read down all of the b-tree sets (FROM/UNTIL) so the all absolute
positioning values can be set.
****************************************************************************/
RCODE FSIndexCursor::setupForPositioning(
FDB * pDb)
{
RCODE rc = FERR_OK;
DIN_STATE dinState;
FLMUINT uiTempKeyLen;
FLMBYTE pTempKey [MAX_KEY_SIZ + 4];
KEYSET * pSrcSet; // Current source set
// Read all of the FROM/UNTIL keys going from the last set to the first.
// This way m_curKeyPos will be positioned to the first key.
for( pSrcSet = m_pFirstSet; pSrcSet->pNext; pSrcSet = pSrcSet->pNext)
{
;
}
for( ; pSrcSet; pSrcSet = pSrcSet->pPrev)
{
f_memcpy( pTempKey, pSrcSet->untilKey.pKey,
uiTempKeyLen = pSrcSet->untilKey.uiKeyLen);
if( RC_BAD( rc = setKeyPosition( pDb, TRUE,
&pSrcSet->untilKey, &pSrcSet->untilKey)))
{
goto Exit;
}
// Copy the key back.
f_memcpy( pSrcSet->untilKey.pKey, pTempKey,
pSrcSet->untilKey.uiKeyLen = uiTempKeyLen);
if( m_pIxd->uiFlags & IXD_POSITIONING)
{
if( RC_BAD( rc = FSGetBtreeRefPosition( pDb,
pSrcSet->untilKey.pStack, &dinState,
&pSrcSet->untilKey.uiRefPosition)))
{
goto Exit;
}
}
if( pSrcSet == m_pFirstSet)
{
if( RC_BAD( rc = setKeyPosition( pDb, TRUE,
&pSrcSet->fromKey, &m_curKeyPos)))
{
goto Exit;
}
m_pCurSet = m_pFirstSet;
// Copy the b-tree information to the from key.
m_pCurSet->fromKey.uiBlockAddr = m_curKeyPos.uiBlockAddr;
m_pCurSet->fromKey.uiDomain = m_curKeyPos.uiDomain;
m_pCurSet->fromKey.uiBlockTransId = m_curKeyPos.uiBlockTransId;
m_pCurSet->fromKey.uiCurElm = m_curKeyPos.uiCurElm;
if( m_pIxd->uiFlags & IXD_POSITIONING)
{
if( RC_BAD( rc = FSGetBtreeRefPosition( pDb,
m_curKeyPos.pStack, &dinState,
&pSrcSet->fromKey.uiRefPosition)))
{
goto Exit;
}
}
}
else
{
f_memcpy( pTempKey, pSrcSet->fromKey.pKey,
uiTempKeyLen = pSrcSet->fromKey.uiKeyLen);
if( RC_BAD( rc = setKeyPosition( pDb, TRUE,
&pSrcSet->fromKey, &pSrcSet->fromKey)))
{
goto Exit;
}
// Copy the key back.
f_memcpy( pSrcSet->fromKey.pKey, pTempKey,
pSrcSet->fromKey.uiKeyLen = uiTempKeyLen);
if( m_pIxd->uiFlags & IXD_POSITIONING)
{
if( RC_BAD( rc = FSGetBtreeRefPosition( pDb,
pSrcSet->fromKey.pStack, &dinState,
&pSrcSet->fromKey.uiRefPosition)))
{
goto Exit;
}
}
}
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Merge the input cursors fromUntil sets as a result of a UNION.
****************************************************************************/
RCODE FSIndexCursor::unionKeys(
FSIndexCursor * pFSCursor)
{
RCODE rc = FERR_OK;
KEYSET * pInputSet; // Sets input via pFSCursor.
KEYSET * pSrcSet; // Current set
KEYSET * pDestSet = NULL; // Newly allocated set
KEYSET * pCurDestSet = NULL; // New current set
KEYSET * pPrevDestSet;
// We need to release all of the blocks. Too complex
pFSCursor->releaseBlocks();
releaseBlocks();
pInputSet = pFSCursor->getFromUntilSets();
pSrcSet = m_pFirstSet;
while( pSrcSet || pInputSet)
{
FLMBOOL bFromKeyLessThan;
FLMBOOL bUntilKeyGreaterThan;
pPrevDestSet = pCurDestSet;
if( RC_BAD( rc = f_calloc( sizeof( KEYSET), &pCurDestSet)))
{
goto Exit;
}
if( !pSrcSet)
{
f_memcpy( pCurDestSet, pInputSet, sizeof( KEYSET));
pInputSet = pInputSet->pNext;
}
else if( !pInputSet)
{
f_memcpy( pCurDestSet, pSrcSet, sizeof( KEYSET));
pSrcSet = pSrcSet->pNext;
}
else if( !FSCompareKeyPos( pInputSet, pSrcSet,
&bFromKeyLessThan, &bUntilKeyGreaterThan))
{
if( bFromKeyLessThan)
{
f_memcpy( pCurDestSet, pInputSet, sizeof( KEYSET));
pInputSet = pInputSet->pNext;
}
else
{
f_memcpy( pCurDestSet, pSrcSet, sizeof( KEYSET));
pSrcSet = pSrcSet->pNext;
}
}
else
{
f_memcpy( &pCurDestSet->fromKey,
bFromKeyLessThan ? &pInputSet->fromKey : &pSrcSet->fromKey,
sizeof( KEYPOS));
for(;;)
{
// Keys overlap - take the lowest FROM key and highest UNTIL key
// walking through the lower UNTIL key set while the keys overlap.
if( bUntilKeyGreaterThan)
{
if( ((pSrcSet = pSrcSet->pNext) == NULL) ||
!FSCompareKeyPos( pInputSet, pSrcSet,
&bFromKeyLessThan, &bUntilKeyGreaterThan))
{
f_memcpy( &pCurDestSet->untilKey, &pInputSet->untilKey,
sizeof( KEYPOS));
pInputSet = pInputSet->pNext;
break;
}
}
else
{
if( ((pInputSet = pInputSet->pNext) == NULL) ||
!FSCompareKeyPos( pInputSet, pSrcSet,
&bFromKeyLessThan, &bUntilKeyGreaterThan))
{
f_memcpy( &pCurDestSet->untilKey,
&pSrcSet->untilKey, sizeof( KEYPOS));
pSrcSet = pSrcSet->pNext;
break;
}
}
}
}
// Link in.
pCurDestSet->pNext = NULL;
if( !pDestSet)
{
pDestSet = pCurDestSet;
pCurDestSet->pPrev = NULL;
}
else
{
pPrevDestSet->pNext = pCurDestSet;
pCurDestSet->pPrev = pPrevDestSet;
}
}
// We went to the trouble of having a default set allocated with this class.
// Undo the last allocation. if( pDestSet) then pCurDestSet can be used.
freeSets();
if( pDestSet)
{
f_memcpy( &m_DefaultSet, pCurDestSet, sizeof( KEYSET));
if( pCurDestSet->pPrev)
{
pCurDestSet->pPrev->pNext = &m_DefaultSet;
m_pFirstSet = pDestSet;
}
else
{
m_pFirstSet = &m_DefaultSet;
}
f_free( &pCurDestSet);
}
m_bAtBOF = TRUE;
m_pCurSet = NULL;
Exit:
return( rc);
}
/****************************************************************************
Desc: Intersect the from/until key sets of pFSCursor into 'this'.
****************************************************************************/
RCODE FSIndexCursor::intersectKeys(
FDB * pDb,
FSIndexCursor * pFSCursor)
{
RCODE rc = FERR_OK;
KEYSET * pInputSet; // Sets input via pFSCursor.
KEYSET * pSrcSet; // Current set
KEYSET * pDestSet = NULL; // Newly allocated set
KEYSET * pCurDestSet = NULL; // New current set
KEYSET * pPrevDestSet;
// Create a new destiniation set and throw away the current set.
pFSCursor->releaseBlocks();
releaseBlocks();
pInputSet = pFSCursor->getFromUntilSets();
pSrcSet = m_pFirstSet;
while( pSrcSet && pInputSet)
{
FLMBOOL bFromKeyLessThan;
FLMBOOL bUntilKeyGreaterThan;
if( !FSCompareKeyPos( pInputSet, pSrcSet,
&bFromKeyLessThan, &bUntilKeyGreaterThan))
{
// Keys do NOT overlap - go to the next set section.
if( bFromKeyLessThan)
{
pInputSet = pInputSet->pNext;
}
else
{
pSrcSet = pSrcSet->pNext;
}
}
else
{
// Values overlap - see the two boolean values on how they overlap.
pPrevDestSet = pCurDestSet;
if( RC_BAD( rc = f_calloc( sizeof( KEYSET), &pCurDestSet)))
{
goto Exit;
}
pCurDestSet->pNext = NULL;
if( !pDestSet)
{
pDestSet = pCurDestSet;
pCurDestSet->pPrev = NULL;
}
else
{
pCurDestSet->pPrev = pPrevDestSet;
pPrevDestSet->pNext = pCurDestSet;
}
// Take the highest FROM key.
f_memcpy( &pCurDestSet->fromKey,
bFromKeyLessThan ? &pSrcSet->fromKey : &pInputSet->fromKey,
sizeof( KEYPOS));
// Take the lowest until key and position to the next set.
if( bUntilKeyGreaterThan)
{
f_memcpy( &pCurDestSet->untilKey, &pSrcSet->untilKey, sizeof( KEYPOS));
pSrcSet = pSrcSet->pNext;
}
else
{
f_memcpy( &pCurDestSet->untilKey, &pInputSet->untilKey, sizeof( KEYPOS));
pInputSet = pInputSet->pNext;
}
}
}
// We went to the trouble of having a default set allocated with this class.
// Undo the last allocation. if( pDestSet) then pCurDestSet can be used.
freeSets();
if( pDestSet)
{
f_memcpy( &m_DefaultSet, pCurDestSet, sizeof( KEYSET));
if( pCurDestSet->pPrev)
{
pCurDestSet->pPrev->pNext = &m_DefaultSet;
m_pFirstSet = pDestSet;
}
else
{
m_pFirstSet = &m_DefaultSet;
}
f_free( &pCurDestSet);
}
m_bAtBOF = TRUE;
m_pCurSet = NULL;
// If this is a positioning index we need to setup the FROM/UNTIL
// btrees to get the FROM/UNTIL reference positions.
if( m_pIxd->uiFlags & IXD_POSITIONING)
{
if( RC_BAD( rc = setupForPositioning( pDb)))
{
goto Exit;
}
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Specific compare for a key range against the key ranges in this
cursor.
****************************************************************************/
FLMBOOL FSIndexCursor::compareKeyRange( // Returns TRUE if keys overlap.
FLMBYTE * pFromKey,
FLMUINT uiFromKeyLen,
FLMBOOL bExclusiveFrom,
FLMBYTE * pUntilKey,
FLMUINT uiUntilKeyLen,
FLMBOOL bExclusiveUntil,
FLMBOOL * pbUntilKeyInSet, // Truth Table: T F F
FLMBOOL * pbUntilGreaterThan) // F T F
{
FLMBOOL bKeysOverlap = FALSE;
KEYSET * pSrcSet; // Current source set
FLMINT iFromCmp;
FLMINT iUntilCmp;
FLMINT iFromUntilCmp;
FLMINT iUntilFromCmp;
for( pSrcSet = m_pFirstSet; pSrcSet; pSrcSet = pSrcSet->pNext)
{
iFromCmp = FSCompareKeys( FALSE, pFromKey,
uiFromKeyLen,
bExclusiveFrom, FALSE,
pSrcSet->fromKey.pKey,
pSrcSet->fromKey.uiKeyLen,
pSrcSet->fromKey.bExclusiveKey);
if( iFromCmp < 0)
{
// Move from left-most to right-most to see where the overlap is.
iUntilFromCmp = FSCompareKeys( TRUE,
pUntilKey, uiUntilKeyLen,
bExclusiveUntil,
FALSE,
pSrcSet->fromKey.pKey,
pSrcSet->fromKey.uiKeyLen,
pSrcSet->fromKey.bExclusiveKey);
if( iUntilFromCmp < 0)
{
*pbUntilKeyInSet = FALSE;
*pbUntilGreaterThan = FALSE;
goto Exit;
}
if( iUntilFromCmp == 0)
{
bKeysOverlap = TRUE;
*pbUntilKeyInSet = TRUE;
*pbUntilGreaterThan = FALSE;
goto Exit;
}
// UNTIL > pSrcSet->fromKey
iUntilCmp = FSCompareKeys( TRUE, pUntilKey, uiUntilKeyLen,
bExclusiveUntil, TRUE,
pSrcSet->untilKey.pKey,
pSrcSet->untilKey.uiKeyLen,
pSrcSet->untilKey.bExclusiveKey);
if( iUntilCmp <= 0)
{
bKeysOverlap = TRUE;
*pbUntilKeyInSet = TRUE;
*pbUntilGreaterThan = FALSE;
goto Exit;
}
bKeysOverlap = TRUE;
// Try the next source set to see if the UNTIL key is in a set.
}
else
{
// Move from left-most to right-most to see where the overlap is.
if( iFromCmp == 0)
{
bKeysOverlap = TRUE;
}
else
{
iFromUntilCmp = FSCompareKeys( FALSE, pFromKey, uiFromKeyLen,
bExclusiveFrom,
TRUE, pSrcSet->untilKey.pKey,
pSrcSet->untilKey.uiKeyLen,
pSrcSet->untilKey.bExclusiveKey);
if( iFromUntilCmp <= 0)
{
bKeysOverlap = TRUE;
}
else
{
continue;
}
}
iUntilCmp = FSCompareKeys( TRUE, pUntilKey, uiUntilKeyLen,
bExclusiveFrom,
TRUE, pSrcSet->untilKey.pKey,
pSrcSet->untilKey.uiKeyLen,
pSrcSet->untilKey.bExclusiveKey);
if( iUntilCmp <= 0)
{
bKeysOverlap = TRUE;
*pbUntilKeyInSet = TRUE;
*pbUntilGreaterThan = FALSE;
goto Exit;
}
}
}
*pbUntilKeyInSet = FALSE;
*pbUntilGreaterThan = TRUE;
Exit:
return bKeysOverlap;
}
/****************************************************************************
Desc: Compare two From/Until key positions.
****************************************************************************/
FLMBOOL FSIndexCursor::FSCompareKeyPos( // TRUE if keys overlap
KEYSET * pSet1,
KEYSET * pSet2,
FLMBOOL * pbFromKeyLessThan, // pSet1->from < pSet2->from
FLMBOOL * pbUntilKeyGreaterThan) // pSet1->until > pSet2->until
{
if( FS_COMPARE_KEYS( TRUE, &pSet1->untilKey, FALSE, &pSet2->fromKey) < 0)
{
*pbFromKeyLessThan = TRUE;
pbUntilKeyGreaterThan = FALSE;
return FALSE;
}
if( FS_COMPARE_KEYS( FALSE, &pSet1->fromKey, TRUE, &pSet2->untilKey) > 0)
{
*pbFromKeyLessThan = FALSE;
*pbUntilKeyGreaterThan = TRUE;
return FALSE;
}
// Keys overlap. Two more compares needed
*pbFromKeyLessThan = (FLMBOOL) ((FS_COMPARE_KEYS( FALSE, &pSet1->fromKey,
FALSE, &pSet2->fromKey) < 0) ? TRUE : FALSE);
*pbUntilKeyGreaterThan = (FLMBOOL) ((FS_COMPARE_KEYS( TRUE, &pSet1->untilKey,
TRUE, &pSet2->untilKey) > 0) ? TRUE : FALSE);
return (TRUE);
}
/****************************************************************************
Desc: Set information from the block into the KEYPOS structure.
****************************************************************************/
FINLINE void setKeyItemsFromBlock(
KEYPOS * pKeyPos)
{
pKeyPos->uiBlockAddr = pKeyPos->pStack->uiBlkAddr;
pKeyPos->uiCurElm = pKeyPos->pStack->uiCurElm;
pKeyPos->uiKeyLen = pKeyPos->pStack->uiKeyLen;
pKeyPos->uiBlockTransId = (pKeyPos->uiBlockAddr != BT_END)
? FB2UD( &pKeyPos->pStack->pBlk[ BH_TRANS_ID])
: 0;
}
/****************************************************************************
Desc: Set the key position given some KEYPOS structure.
Please note that the blocks in the stack may or may not be used.
****************************************************************************/
RCODE FSIndexCursor::setKeyPosition(
FDB * pDb,
FLMBOOL bGoingForward,
KEYPOS * pInKeyPos, // Input key position
KEYPOS * pOutKeyPos) // Output to setup the stack/key buffer.
// It is ok for Input==Output
{
RCODE rc;
FLMBYTE * pSearchKey;
FLMBYTE pTempKey[ MAX_KEY_SIZ + 4];
FLMUINT uiTargetRecordId = pInKeyPos->uiRecordId;
// May have to unuse the b-tree blocks. Then setup the stack.
if( !pOutKeyPos->bStackInUse)
{
FSInitStackCache( pOutKeyPos->Stack, BH_MAX_LEVELS);
pOutKeyPos->bStackInUse = TRUE;
}
if( pInKeyPos == pOutKeyPos)
{
pSearchKey = pTempKey;
f_memcpy( pTempKey, pInKeyPos->pKey, pInKeyPos->uiKeyLen);
}
else
{
pSearchKey = pInKeyPos->pKey;
}
// Setup the stack.
pOutKeyPos->pStack = pOutKeyPos->Stack;
pOutKeyPos->Stack[0].pKeyBuf = pOutKeyPos->pKey;
// All of the variables should be setup for the search.
if( RC_BAD( rc = FSBtSearch( pDb, m_pLFile, &pOutKeyPos->pStack,
pSearchKey, pInKeyPos->uiKeyLen,
uiTargetRecordId
? DRN_DOMAIN( uiTargetRecordId) + 1
: pInKeyPos->uiDomain)))
{
goto Exit;
}
pOutKeyPos->uiBlockAddr = pOutKeyPos->pStack->uiBlkAddr;
pOutKeyPos->uiCurElm = pOutKeyPos->pStack->uiCurElm;
if( pOutKeyPos->pStack->uiBlkAddr == BT_END)
{
pOutKeyPos->bStackInUse = FALSE;
rc = RC_SET( FERR_EOF_HIT);
goto Exit;
}
pOutKeyPos->uiKeyLen = pOutKeyPos->pStack->uiKeyLen;
if( bGoingForward)
{
if( pOutKeyPos->pStack->uiCmpStatus == BT_END_OF_DATA)
{
rc = RC_SET( FERR_EOF_HIT);
goto Exit;
}
}
else
{
BTSK * pStack;
// Going backwards or to the last. May have positioned too far.
if( pOutKeyPos->pStack->uiCmpStatus == BT_END_OF_DATA ||
FS_COMPARE_KEYS( TRUE, pOutKeyPos, TRUE, pInKeyPos) > 0)
{
uiTargetRecordId = 0;
pStack = pOutKeyPos->pStack;
// The stack should be set up and is pointing to a valid block.
if( pStack->uiCmpStatus != BT_END_OF_DATA)
{
while( BBE_NOT_FIRST( CURRENT_ELM( pStack)))
{
if( RC_BAD( rc = FSBtPrevElm( pDb, m_pLFile, pStack)))
{
if( rc == FERR_BT_END_OF_DATA)
{
rc = RC_SET( FERR_BTREE_ERROR);
}
goto Exit;
}
}
}
// Position to the last continuation element of the previous element.
if( RC_BAD( rc = FSBtPrevElm( pDb, m_pLFile, pStack)))
{
if( rc == FERR_BT_END_OF_DATA)
{
rc = RC_SET( FERR_BOF_HIT);
}
goto Exit;
}
}
}
// When using the positioning index, we must always have a complete stack.
if( !(m_pIxd->uiFlags & IXD_POSITIONING))
{
pOutKeyPos->pStack->uiFlags = NO_STACK;
}
// Get the record ID at the leaf level of the b-tree.
if( uiTargetRecordId)
{
pOutKeyPos->uiRecordId = pInKeyPos->uiRecordId;
rc = FSRefSearch( pOutKeyPos->pStack,
&pOutKeyPos->DinState, &pOutKeyPos->uiRecordId);
if( rc == FERR_FAILURE)
{
rc = FERR_OK;
}
}
else
{
if( bGoingForward)
{
pOutKeyPos->uiRecordId = FSRefFirst( pOutKeyPos->pStack,
&pOutKeyPos->DinState, &pOutKeyPos->uiDomain);
pOutKeyPos->uiDomain++;
}
else
{
pOutKeyPos->uiRecordId = FSRefLast( pOutKeyPos->pStack,
&pOutKeyPos->DinState, &pOutKeyPos->uiDomain);
}
}
Exit:
// Save state only on a good return value.
if( RC_OK( rc) ||
((rc == FERR_EOF_HIT || rc == FERR_BOF_HIT) && pOutKeyPos->bStackInUse))
{
setKeyItemsFromBlock( pOutKeyPos);
}
else
{
releaseKeyBlocks( pOutKeyPos);
}
return( rc);
}
/****************************************************************************
Desc: Return the current record and record id.
VISIT: We may want to return BOF/EOF when positioned on an endpoint.
****************************************************************************/
RCODE FSIndexCursor::currentKey(
FDB * pDb,
FlmRecord ** ppRecordKey, // Will replace what is there
FLMUINT * puiRecordId) // Set the record ID
{
RCODE rc;
FLMBOOL bKeyGone;
FLMBOOL bRefGone;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
if( m_bAtBOF)
{
rc = RC_SET( FERR_BOF_HIT);
goto Exit;
}
if( m_bAtEOF)
{
rc = RC_SET( FERR_EOF_HIT);
goto Exit;
}
if( !m_curKeyPos.bStackInUse)
{
if( RC_BAD( rc = reposition( pDb, FALSE, FALSE, &bKeyGone,
FALSE, FALSE, &bRefGone)))
{
// The current key is gone. Returns FERR_NOT_FOUND.
goto Exit;
}
}
// If this assert happens we have to code for it.
flmAssert( m_curKeyPos.uiRecordId != 0);
if( ppRecordKey)
{
if( RC_BAD( rc = flmIxKeyOutput( m_pIxd, m_curKeyPos.pKey,
m_curKeyPos.uiKeyLen, ppRecordKey, TRUE)))
{
goto Exit;
}
(*ppRecordKey)->setID( m_curKeyPos.uiRecordId);
}
if( puiRecordId)
{
*puiRecordId = m_curKeyPos.uiRecordId;
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Return the current record and record id.
VISIT: We may want to return BOF/EOF when positioned on an endpoint.
****************************************************************************/
RCODE FSIndexCursor::currentKeyBuf(
FDB * pDb,
F_Pool * pPool,
FLMBYTE ** ppKeyBuf,
FLMUINT * puiKeyLen,
FLMUINT * puiRecordId,
FLMUINT * puiContainerId)
{
RCODE rc = FERR_OK;
FLMBOOL bKeyGone;
FLMBOOL bRefGone;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
if( m_bAtBOF)
{
rc = RC_SET( FERR_BOF_HIT);
goto Exit;
}
if( m_bAtEOF)
{
rc = RC_SET( FERR_EOF_HIT);
goto Exit;
}
if( !m_curKeyPos.bStackInUse)
{
if( RC_BAD( rc = reposition( pDb, FALSE, FALSE, &bKeyGone,
FALSE, FALSE, &bRefGone)))
{
// The current key is gone. Returns FERR_NOT_FOUND.
goto Exit;
}
}
// If this assert happens we have to code for it.
flmAssert( m_curKeyPos.uiRecordId != 0);
if( ppKeyBuf)
{
// If they passed in a non-null key buffer pointer, they also
// need to pass in a non-null return length.
flmAssert( puiKeyLen != NULL);
if( (*puiKeyLen = m_curKeyPos.uiKeyLen) != 0)
{
if( RC_BAD( rc = pPool->poolAlloc( m_curKeyPos.uiKeyLen,
(void **)ppKeyBuf)))
{
goto Exit;
}
f_memcpy( *ppKeyBuf, m_curKeyPos.pKey, m_curKeyPos.uiKeyLen);
}
else
{
*ppKeyBuf = NULL;
}
}
if( puiRecordId)
{
*puiRecordId = m_curKeyPos.uiRecordId;
}
if (puiContainerId)
{
if ((*puiContainerId = m_pIxd->uiContainerNum) == 0)
{
flmAssert( m_curKeyPos.uiKeyLen > getIxContainerPartLen( m_pIxd));
*puiContainerId = getContainerFromKey( m_curKeyPos.pKey,
m_curKeyPos.uiKeyLen);
}
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Position to and return the first record.
This is hard because positioning using the first key may actually
position past or into another FROM/UNTIL set in the list.
****************************************************************************/
RCODE FSIndexCursor::firstKey(
FDB * pDb,
FlmRecord ** ppRecordKey, // Will replace what is there
FLMUINT * puiRecordId) // Set the record ID
{
RCODE rc;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
if( !m_pFirstSet)
{
m_bAtBOF = FALSE;
m_bAtEOF = TRUE;
rc = RC_SET( FERR_EOF_HIT);
goto Exit;
}
// If at BOF and stack is in use, the key is the first key!
// This should only happen when firstKey is called the first time.
if( m_bAtBOF && m_curKeyPos.bStackInUse && m_pCurSet)
{
m_bAtBOF = FALSE;
}
else
{
m_pCurSet = m_pFirstSet;
m_bAtBOF = m_bAtEOF = FALSE;
if( RC_BAD( rc = setKeyPosition( pDb, TRUE, &m_pCurSet->fromKey,
&m_curKeyPos)))
{
if( rc == FERR_EOF_HIT)
{
m_bAtEOF = TRUE;
}
goto Exit;
}
}
// Check to see if the key is within one of the FROM/UNTIL sets.
for(;;)
{
// Check to see if the current key <= UNTIL key.
if( FS_COMPARE_KEYS( FALSE, &m_curKeyPos, TRUE,
&m_pCurSet->untilKey) <= 0)
{
break;
}
// Nope - UntilKey < current key.
if( !m_pCurSet->pNext)
{
rc = RC_SET( FERR_EOF_HIT);
m_bAtEOF = TRUE;
goto Exit;
}
m_pCurSet = m_pCurSet->pNext;
// If (current key < FROM key of the next set) we need to reposition.
if( FS_COMPARE_KEYS( FALSE, &m_curKeyPos, FALSE, &m_pCurSet->fromKey) < 0)
{
if( RC_BAD( rc = setKeyPosition( pDb, TRUE, &m_pCurSet->fromKey,
&m_curKeyPos)))
{
if( rc == FERR_EOF_HIT)
{
m_bAtEOF = TRUE;
}
goto Exit;
}
}
}
if( puiRecordId)
{
*puiRecordId = m_curKeyPos.uiRecordId;
}
if( ppRecordKey)
{
if( RC_BAD( rc = flmIxKeyOutput( m_pIxd, m_curKeyPos.pKey,
m_curKeyPos.uiKeyLen, ppRecordKey, TRUE)))
{
goto Exit;
}
(*ppRecordKey)->setID( m_curKeyPos.uiRecordId);
}
Exit:
if( m_bAtEOF)
{
// The saved state is not pointing anywhere specific in the B-tree.
releaseKeyBlocks( &m_curKeyPos);
}
return( rc);
}
/****************************************************************************
Desc: Position to the next key and the first reference of that key.
****************************************************************************/
RCODE FSIndexCursor::nextKey(
FDB * pDb,
FlmRecord ** ppRecordKey,
FLMUINT * puiRecordId)
{
RCODE rc;
FLMBOOL bKeyGone;
FLMBOOL bRefGone;
BTSK * pStack;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
if( m_bAtEOF)
{
rc = RC_SET( FERR_EOF_HIT);
goto Exit;
}
if( m_bAtBOF)
{
rc = firstKey( pDb, ppRecordKey, puiRecordId);
goto Exit;
}
bKeyGone = bRefGone = FALSE;
// Takes care of any re-read of a block if we changed transactions.
if( !m_curKeyPos.bStackInUse)
{
if( RC_BAD( rc = reposition( pDb, TRUE, FALSE, &bKeyGone,
TRUE, FALSE, &bRefGone)))
{
if( rc == FERR_EOF_HIT)
{
m_bAtEOF = TRUE;
}
// May return FERR_EOF_HIT if all remaining keys are deleted.
goto Exit;
}
}
pStack = m_curKeyPos.pStack;
for(;;)
{
FLMINT iCmp;
if( !bKeyGone)
{
FLMBYTE * pCurElm;
pCurElm = CURRENT_ELM( pStack);
while( BBE_NOT_LAST( pCurElm))
{
if( RC_BAD( rc = FSBtNextElm( pDb, m_pLFile, pStack)))
{
// b-tree corrupt if FERR_BT_END_OF_DATA
if( rc == FERR_BT_END_OF_DATA)
{
rc = RC_SET( FERR_BTREE_ERROR);
}
goto Exit;
}
pCurElm = CURRENT_ELM( pStack);
}
// Now go to the next element.
if( RC_BAD( rc = FSBtNextElm( pDb, m_pLFile, pStack)))
{
if( rc == FERR_BT_END_OF_DATA)
{
m_bAtEOF = TRUE;
rc = RC_SET( FERR_EOF_HIT);
}
goto Exit;
}
bKeyGone = TRUE;
m_curKeyPos.uiKeyLen = m_curKeyPos.pStack->uiKeyLen;
}
// Could have positioned after the current sets until key before
// the FROM key of the next set.
iCmp = FS_COMPARE_KEYS( FALSE, &m_curKeyPos, TRUE, &m_pCurSet->untilKey);
if( iCmp <= 0)
{
setKeyItemsFromBlock( &m_curKeyPos);
m_curKeyPos.uiRecordId =
FSRefFirst( pStack, &m_curKeyPos.DinState, &m_curKeyPos.uiDomain);
break;
}
// Go to the next set if there is one.
if( !m_pCurSet->pNext)
{
m_bAtEOF = TRUE;
rc = RC_SET( FERR_EOF_HIT);
goto Exit;
}
m_pCurSet = m_pCurSet->pNext;
// The key may fit in the next set.
iCmp = FS_COMPARE_KEYS( FALSE, &m_curKeyPos, FALSE, &m_pCurSet->fromKey);
if( iCmp < 0)
{
// Reposition using the from key.
if( RC_BAD( rc = setKeyPosition( pDb, TRUE,
&m_pCurSet->fromKey, &m_curKeyPos)))
{
if( rc == FERR_EOF_HIT)
{
m_bAtEOF = TRUE;
}
goto Exit;
}
}
}
if( puiRecordId)
{
*puiRecordId = m_curKeyPos.uiRecordId;
}
if( ppRecordKey)
{
if( RC_BAD( rc = flmIxKeyOutput( m_pIxd, m_curKeyPos.pKey,
m_curKeyPos.uiKeyLen, ppRecordKey, TRUE)))
{
goto Exit;
}
(*ppRecordKey)->setID( m_curKeyPos.uiRecordId);
}
Exit:
if( m_bAtEOF)
{
// The saved state is not pointing anywhere specific in the B-tree.
releaseKeyBlocks( &m_curKeyPos);
}
return( rc);
}
/****************************************************************************
Desc: Position to the next referece of the current key.
****************************************************************************/
RCODE FSIndexCursor::nextRef( // FERR_OK, FERR_EOF_HIT or error
FDB * pDb,
FLMUINT * puiRecordId) // Set the record ID
{
RCODE rc;
FLMBOOL bKeyGone;
FLMBOOL bRefGone;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
flmAssert( m_pCurSet != NULL);
bKeyGone = bRefGone = FALSE;
if( !m_curKeyPos.bStackInUse)
{
// Take care of any re-read of a block if we changed transactions.
if( RC_BAD( rc = reposition( pDb, FALSE, FALSE, &bKeyGone,
TRUE, FALSE, &bRefGone)))
{
// May return FERR_EOF_HIT if all remaining references are deleted.
goto Exit;
}
flmAssert( !bKeyGone);
}
if( !bRefGone)
{
if( RC_BAD( rc = FSRefNext( pDb, m_pLFile, m_curKeyPos.pStack,
&m_curKeyPos.DinState, &m_curKeyPos.uiRecordId)))
{
if( rc == FERR_BT_END_OF_DATA)
{
rc = RC_SET( FERR_EOF_HIT);
}
goto Exit;
}
else
{
setKeyItemsFromBlock( &m_curKeyPos);
}
}
if( puiRecordId)
{
*puiRecordId = m_curKeyPos.uiRecordId;
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Position to and return the last record.
This is hard because positioning using the first key may actually
position past or into another FROM/UNTIL set in the list.
****************************************************************************/
RCODE FSIndexCursor::lastKey(
FDB * pDb,
FlmRecord ** ppRecordKey, // Will replace what is there
FLMUINT * puiRecordId) // Set the record ID
{
RCODE rc;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
m_pCurSet = m_pFirstSet;
if( !m_pCurSet)
{
m_bAtBOF = TRUE;
m_bAtEOF = FALSE;
rc = RC_SET( FERR_BOF_HIT);
goto Exit;
}
// Position to the last set.
while( m_pCurSet->pNext)
{
m_pCurSet = m_pCurSet->pNext;
}
m_bAtBOF = m_bAtEOF = FALSE;
for(;;)
{
if( RC_BAD( rc = setKeyPosition( pDb, FALSE, &m_pCurSet->untilKey,
&m_curKeyPos)))
{
// Returns an error or FERR_EOF_HIT.
if( rc != FERR_EOF_HIT)
{
goto Exit;
}
// Position to the previous key if possible.
if( m_curKeyPos.pStack->uiBlkAddr == BT_END)
{
m_bAtBOF = TRUE;
rc = RC_SET( FERR_BOF_HIT);
goto Exit;
}
// Went past the until key. Go back one.
if( RC_BAD( rc = FSBtPrevElm( pDb, m_pLFile, m_curKeyPos.pStack)))
{
if( rc == FERR_BT_END_OF_DATA)
{
rc = RC_SET( FERR_BOF_HIT);
}
goto Exit;
}
}
// We may have positioned before the FROM key of this set.
if( FS_COMPARE_KEYS( FALSE, &m_pCurSet->fromKey,
FALSE, &m_curKeyPos) <= 0)
{
break;
}
if( !m_pCurSet->pPrev)
{
rc = RC_SET( FERR_BOF_HIT);
m_bAtBOF = TRUE;
goto Exit;
}
m_pCurSet = m_pCurSet->pPrev;
}
// Now we are positioned somewhere. Return the key and first record id.
m_curKeyPos.uiRecordId = FSRefLast( m_curKeyPos.pStack,
&m_curKeyPos.DinState, &m_curKeyPos.uiDomain);
setKeyItemsFromBlock( &m_curKeyPos);
if( puiRecordId)
{
*puiRecordId = m_curKeyPos.uiRecordId;
}
if( ppRecordKey)
{
if( RC_BAD( rc = flmIxKeyOutput( m_pIxd, m_curKeyPos.pKey,
m_curKeyPos.uiKeyLen, ppRecordKey, TRUE)))
{
goto Exit;
}
(*ppRecordKey)->setID( m_curKeyPos.uiRecordId);
}
Exit:
if( rc == FERR_BOF_HIT)
{
// The saved state is not pointing anywhere specific in the B-tree.
releaseKeyBlocks( &m_curKeyPos);
}
return( rc);
}
/****************************************************************************
Desc: Position to the PREVIOUS key and the LAST reference of that key.
****************************************************************************/
RCODE FSIndexCursor::prevKey(
FDB * pDb,
FlmRecord ** ppRecordKey,
FLMUINT * puiRecordId)
{
RCODE rc;
FLMBOOL bKeyGone;
FLMBOOL bRefGone;
BTSK * pStack = m_curKeyPos.pStack;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
if( m_bAtBOF)
{
rc = RC_SET( FERR_BOF_HIT);
goto Exit;
}
if( !m_pCurSet || m_bAtEOF)
{
rc = lastKey( pDb, ppRecordKey, puiRecordId);
goto Exit;
}
bKeyGone = bRefGone = FALSE;
// Takes care of any re-read of a block if we changed transactions.
if( !m_curKeyPos.bStackInUse)
{
if( RC_BAD( rc = reposition( pDb, FALSE, TRUE, &bKeyGone,
FALSE, FALSE, &bRefGone)))
{
// May return FERR_EOF_HIT if all remaining keys are deleted.
if( rc != FERR_BOF_HIT && rc != FERR_EOF_HIT)
{
goto Exit;
}
m_bAtBOF = TRUE;
rc = RC_SET( FERR_BOF_HIT);
}
}
for(;;)
{
if( !bKeyGone)
{
FLMBYTE * pCurElm;
pCurElm = CURRENT_ELM( pStack);
while( BBE_NOT_FIRST( pCurElm))
{
if( RC_BAD( rc = FSBtPrevElm( pDb, m_pLFile, pStack)))
{
// b-tree corrupt if FERR_BT_END_OF_DATA
if( rc == FERR_BT_END_OF_DATA)
{
rc = RC_SET( FERR_BTREE_ERROR);
}
goto Exit;
}
pCurElm = CURRENT_ELM( pStack);
}
// Now go to the previous element.
if( RC_BAD(rc = FSBtPrevElm( pDb, m_pLFile, pStack)))
{
// b-tree corrupt if FERR_BT_END_OF_DATA
if( rc == FERR_BT_END_OF_DATA)
{
m_bAtBOF = TRUE;
rc = RC_SET( FERR_BOF_HIT);
}
goto Exit;
}
bKeyGone = TRUE;
m_curKeyPos.uiKeyLen = m_curKeyPos.pStack->uiKeyLen;
}
// Could have positioned after the current sets until key before
// the FROM key of the next set.
if( FS_COMPARE_KEYS( FALSE, &m_curKeyPos, TRUE, &m_pCurSet->fromKey) >= 0)
{
setKeyItemsFromBlock( &m_curKeyPos);
m_curKeyPos.uiRecordId =
FSRefLast( pStack, &m_curKeyPos.DinState, &m_curKeyPos.uiDomain);
break;
}
// Go to the previous set if there is one.
if( !m_pCurSet->pPrev)
{
m_bAtBOF = TRUE;
rc = RC_SET( FERR_BOF_HIT);
goto Exit;
}
m_pCurSet = m_pCurSet->pPrev;
// The key may fit in the previous set.
if( FS_COMPARE_KEYS( FALSE, &m_curKeyPos, FALSE, &m_pCurSet->fromKey) > 0)
{
// Reposition using the from key.
if( RC_BAD( rc = setKeyPosition( pDb, FALSE,
&m_pCurSet->untilKey, &m_curKeyPos)))
{
if( rc == FERR_EOF_HIT || rc == FERR_BOF_HIT)
{
m_bAtBOF = TRUE;
rc = RC_SET( FERR_BOF_HIT);
}
goto Exit;
}
}
}
if( puiRecordId)
{
*puiRecordId = m_curKeyPos.uiRecordId;
}
if( ppRecordKey)
{
if( RC_BAD( rc = flmIxKeyOutput( m_pIxd, m_curKeyPos.pKey,
m_curKeyPos.uiKeyLen, ppRecordKey, TRUE)))
{
goto Exit;
}
(*ppRecordKey)->setID( m_curKeyPos.uiRecordId);
}
Exit:
if( rc == FERR_BOF_HIT)
{
// The saved state is not pointing anywhere specific in the B-tree.
releaseKeyBlocks( &m_curKeyPos);
}
return( rc);
}
/****************************************************************************
Desc: Position to the previous referece of the current key.
****************************************************************************/
RCODE FSIndexCursor::prevRef(
FDB * pDb,
FLMUINT * puiRecordId) // Set the record ID
{
RCODE rc;
FLMBOOL bKeyGone;
FLMBOOL bRefGone;
flmAssert( m_pCurSet != NULL);
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
bKeyGone = bRefGone = FALSE;
if( !m_curKeyPos.bStackInUse)
{
// Take care of any re-read of a block if we changed transactions.
if( RC_BAD( rc = reposition( pDb, FALSE, FALSE, &bKeyGone,
FALSE, TRUE, &bRefGone)))
{
// May return FERR_EOF_HIT if all preceeding references are deleted.
if( rc == FERR_EOF_HIT)
{
rc = RC_SET( FERR_BOF_HIT);
}
goto Exit;
}
flmAssert( !bKeyGone);
}
if( !bRefGone)
{
if( RC_BAD( rc = FSRefPrev( pDb, m_pLFile, m_curKeyPos.pStack,
&m_curKeyPos.DinState, &m_curKeyPos.uiRecordId)))
{
if( rc == FERR_BT_END_OF_DATA)
{
rc = RC_SET( FERR_BOF_HIT);
}
goto Exit;
}
else
{
setKeyItemsFromBlock( &m_curKeyPos);
}
}
if( puiRecordId)
{
*puiRecordId = m_curKeyPos.uiRecordId;
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Reposition to the current key + recordId. If the current key
is gone we may reposition past the UNTIL key and should check.
****************************************************************************/
RCODE FSIndexCursor::reposition(
FDB * pDb,
FLMBOOL bCanPosToNextKey, // May be TRUE if bPosToPrevKey is FALSE
FLMBOOL bCanPosToPrevKey, // May be TRUE if bPosToNextKey is FALSE
FLMBOOL * pbKeyGone, // [out] cannot be NULL
FLMBOOL bCanPosToNextRef, // May be TRUE if bPosToPrevRef is FALSE
FLMBOOL bCanPosToPrevRef, // May be TRUE if bPosToNextRef is FALSE
FLMBOOL * pbRefGone) // [out] cannot be NULL
{
RCODE rc = FERR_OK;
FLMUINT uiBlkTransId = 0;
FLMBOOL bReread = FALSE;
FLMUINT uiTargetRecordId;
uiTargetRecordId = m_curKeyPos.uiRecordId;
// May have to unuse the b-tree blocks. Then setup the stack again.
flmAssert( !m_curKeyPos.bStackInUse);
*pbKeyGone = *pbRefGone = FALSE;
// Re-read the block and see if it is the same block.
if( m_curKeyPos.uiBlockAddr == BT_END)
{
bReread = TRUE;
}
else
{
if( RC_BAD( rc = FSGetBlock( pDb, m_pLFile,
m_curKeyPos.uiBlockAddr, m_curKeyPos.pStack)))
{
if( rc != FERR_DATA_ERROR)
{
goto Exit;
}
rc = FERR_OK;
bReread = TRUE;
}
else
{
uiBlkTransId = FB2UD( &m_curKeyPos.pStack->pBlk[ BH_TRANS_ID]);
m_curKeyPos.bStackInUse = TRUE;
}
}
if( m_curKeyPos.uiBlockTransId != uiBlkTransId)
{
bReread = TRUE;
}
else if( pDb->uiTransType == FLM_UPDATE_TRANS)
{
bReread = TRUE;
}
if( bReread)
{
FLMBYTE pKey [MAX_KEY_SIZ + 4];
FLMUINT uiKeyLen = m_curKeyPos.uiKeyLen;
FLMUINT uiSaveRecId = m_curKeyPos.uiRecordId;
f_memcpy( pKey, m_curKeyPos.pKey, uiKeyLen);
// This may be a new read transaction. Call BTSearch.
// The current reference or current key may go away on
if( RC_BAD( rc = setKeyPosition( pDb,
bCanPosToPrevKey ? FALSE : TRUE, &m_curKeyPos, &m_curKeyPos)))
{
if( rc != FERR_EOF_HIT && rc != FERR_BOF_HIT)
{
goto Exit;
}
}
if( RC_BAD( rc) ||
uiKeyLen != m_curKeyPos.uiKeyLen ||
f_memcmp( pKey, m_curKeyPos.pKey, uiKeyLen))
{
// It is OK that we may not be positioned inside of the current set.
*pbKeyGone = TRUE;
*pbRefGone = TRUE;
if( !bCanPosToNextKey && !bCanPosToPrevKey)
{
if( uiKeyLen)
{
f_memcpy( m_curKeyPos.pKey, pKey, uiKeyLen);
}
m_curKeyPos.uiKeyLen = uiKeyLen;
m_curKeyPos.uiRecordId = uiSaveRecId;
releaseKeyBlocks( &m_curKeyPos);
m_curKeyPos.uiBlockAddr = BT_END;
if( bCanPosToNextKey || bCanPosToNextRef)
{
rc = RC_SET( FERR_EOF_HIT);
}
else if( bCanPosToPrevKey || bCanPosToPrevRef)
{
rc = RC_SET( FERR_BOF_HIT);
}
else
{
rc = RC_SET( FERR_NOT_FOUND);
}
}
goto Exit;
}
}
else
{
m_curKeyPos.bStackInUse = TRUE;
}
if (uiTargetRecordId &&
uiTargetRecordId != m_curKeyPos.uiRecordId)
{
*pbRefGone = TRUE;
if( bCanPosToPrevRef && m_curKeyPos.uiRecordId < uiTargetRecordId)
{
if (RC_OK( rc = FSRefPrev( pDb, m_pLFile, m_curKeyPos.pStack,
&m_curKeyPos.DinState, &m_curKeyPos.uiRecordId)))
{
setKeyItemsFromBlock( &m_curKeyPos);
}
}
else if( !bCanPosToNextRef)
{
// We have an error positioning. Return NOT_FOUND
rc = RC_SET( FERR_NOT_FOUND);
}
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Save the current key position.
****************************************************************************/
void FSIndexCursor::saveCurrKeyPos(
KEYPOS * pSaveKeyPos)
{
f_memcpy( pSaveKeyPos->pKey, m_curKeyPos.pKey, m_curKeyPos.uiKeyLen);
pSaveKeyPos->uiKeyLen = m_curKeyPos.uiKeyLen;
pSaveKeyPos->uiRecordId = m_curKeyPos.uiRecordId;
pSaveKeyPos->uiDomain = m_curKeyPos.uiDomain;
}
/****************************************************************************
Desc: Restore the current key position.
****************************************************************************/
void FSIndexCursor::restoreCurrKeyPos(
KEYPOS * pSaveKeyPos)
{
f_memcpy( m_curKeyPos.pKey, pSaveKeyPos->pKey, pSaveKeyPos->uiKeyLen);
m_curKeyPos.uiKeyLen = pSaveKeyPos->uiKeyLen;
m_curKeyPos.uiRecordId = pSaveKeyPos->uiRecordId;
m_curKeyPos.uiDomain = pSaveKeyPos->uiDomain;
}
/****************************************************************************
Desc: Find the key set for the passed in key.
****************************************************************************/
RCODE FSIndexCursor::getKeySet(
FLMBYTE * pKey,
FLMUINT uiKeyLen,
KEYSET ** ppKeySet)
{
RCODE rc = FERR_OK;
KEYSET * pKeySet;
pKeySet = m_pFirstSet;
while (pKeySet)
{
// Compare this key against the from key. If it is less than the
// from key, we are not inside one of the key ranges.
if( FSCompareKeys( FALSE, pKey, uiKeyLen, FALSE,
FALSE, pKeySet->fromKey.pKey,
pKeySet->fromKey.uiKeyLen,
pKeySet->fromKey.bExclusiveKey) < 0)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
// Key is >= from key, see how it compares to until key.
if( FSCompareKeys( FALSE, pKey, uiKeyLen, FALSE,
TRUE, pKeySet->untilKey.pKey,
pKeySet->untilKey.uiKeyLen,
pKeySet->untilKey.bExclusiveKey) <= 0)
{
break;
}
// Go to the next key range.
pKeySet = pKeySet->pNext;
}
if( !pKeySet)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
Exit:
*ppKeySet = pKeySet;
return( rc);
}
/****************************************************************************
Desc: Position to the input key + recordId.
****************************************************************************/
RCODE FSIndexCursor::positionTo(
FDB * pDb,
FLMBYTE * pKey,
FLMUINT uiKeyLen,
FLMUINT uiRecordId)
{
RCODE rc;
FLMBOOL bKeyGone;
FLMBOOL bRefGone;
KEYSET * pKeySet;
KEYPOS * pSaveKeyPos = NULL;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
// A key with a non-zero key length must be passed in.
flmAssert( uiKeyLen != 0);
// Make sure we fall inside one of the key ranges and
// save the current key position so we can restore it
// if the reposition call fails.
if( RC_BAD( rc = f_alloc( sizeof( KEYPOS),
&pSaveKeyPos)))
{
goto Exit;
}
if (RC_BAD( rc = getKeySet( pKey, uiKeyLen, &pKeySet)))
{
goto Exit;
}
saveCurrKeyPos( pSaveKeyPos);
releaseKeyBlocks( &m_curKeyPos);
m_curKeyPos.uiKeyLen = uiKeyLen;
f_memcpy( m_curKeyPos.pKey, pKey, uiKeyLen);
m_curKeyPos.uiRecordId = uiRecordId;
m_curKeyPos.uiDomain = DRN_DOMAIN( uiRecordId) + 1;
m_curKeyPos.uiBlockAddr = BT_END;
if (RC_BAD( rc = reposition( pDb, FALSE, FALSE, &bKeyGone,
FALSE, FALSE, &bRefGone)))
{
restoreCurrKeyPos( pSaveKeyPos);
goto Exit;
}
m_bAtEOF = FALSE;
m_bAtBOF = FALSE;
m_pCurSet = pKeySet;
Exit:
if (pSaveKeyPos)
{
f_free( &pSaveKeyPos);
}
return( rc);
}
/****************************************************************************
Desc: Position to the input key + domain
****************************************************************************/
RCODE FSIndexCursor::positionToDomain(
FDB * pDb,
FLMBYTE * pKey,
FLMUINT uiKeyLen,
FLMUINT uiDomain)
{
RCODE rc;
FLMBOOL bKeyGone;
FLMBOOL bRefGone;
KEYSET * pKeySet;
KEYPOS * pSaveKeyPos = NULL;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
// A key with a non-zero key length must be passed in.
flmAssert( uiKeyLen != 0);
// Make sure we fall inside one of the key ranges and
// save the current key position so we can restore it
// if the reposition call fails.
if( RC_BAD( rc = f_alloc( sizeof( KEYPOS), &pSaveKeyPos)))
{
goto Exit;
}
if (RC_BAD( rc = getKeySet( pKey, uiKeyLen, &pKeySet)))
{
goto Exit;
}
saveCurrKeyPos( pSaveKeyPos);
releaseKeyBlocks( &m_curKeyPos);
m_curKeyPos.uiKeyLen = uiKeyLen;
f_memcpy( m_curKeyPos.pKey, pKey, uiKeyLen);
m_curKeyPos.uiRecordId = 0;
m_curKeyPos.uiDomain = uiDomain;
m_curKeyPos.uiBlockAddr = BT_END;
if (RC_BAD( rc = reposition( pDb, FALSE, FALSE, &bKeyGone,
FALSE, FALSE, &bRefGone)))
{
restoreCurrKeyPos( pSaveKeyPos);
goto Exit;
}
m_bAtEOF = FALSE;
m_bAtBOF = FALSE;
m_pCurSet = pKeySet;
Exit:
if (pSaveKeyPos)
{
f_free( &pSaveKeyPos);
}
return( rc);
}
/****************************************************************************
Desc: Save the current position.
****************************************************************************/
RCODE FSIndexCursor::savePosition( void)
{
RCODE rc = FERR_OK;
if( !m_pSavedPos)
{
if( RC_BAD( rc = f_calloc( sizeof( KEYPOS), &m_pSavedPos)))
{
goto Exit;
}
}
f_memcpy( m_pSavedPos, &m_curKeyPos, sizeof( KEYPOS));
m_curKeyPos.bStackInUse = FALSE;
Exit:
return( rc);
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE FSIndexCursor::restorePosition( void)
{
if( m_pSavedPos)
{
releaseKeyBlocks( &m_curKeyPos);
f_memcpy( &m_curKeyPos, m_pSavedPos, sizeof(KEYPOS));
}
return (FERR_OK);
}
/****************************************************************************
Desc: Compare two key positions as they would be ordered in the index.
****************************************************************************/
FSTATIC FLMINT FSCompareKeys( // negative is '<', 0 is '=', position='>'
FLMBOOL bKey1IsUntilKey, // TRUE (until key) or FALSE (from key)
FLMBYTE * pKey1,
FLMUINT uiKeyLen1,
FLMBOOL bExclusiveKey1,
FLMBOOL bKey2IsUntilKey,
FLMBYTE * pKey2,
FLMUINT uiKeyLen2,
FLMBOOL bExclusiveKey2)
{
FLMINT iCmp;
// Handle the first key and last key issues.
if( !uiKeyLen1) // FROM or UNTIL key at end point?
{
if( !bKey1IsUntilKey) // FROM key
{
iCmp = !uiKeyLen2 && !bKey2IsUntilKey ? 0 : -1;
}
else // UNTIL key
{
iCmp = !bKey2IsUntilKey ? 1 : (!uiKeyLen2 ? 0 : 1);
}
}
else if( !uiKeyLen2)
{
if( !bKey2IsUntilKey) // FROM key
{
iCmp = !uiKeyLen1 && !bKey1IsUntilKey ? 0 : 1;
}
else // UNTIL key
{
iCmp = !bKey1IsUntilKey ? -1 : (!uiKeyLen1 ? 0 : -1);
}
}
else if( uiKeyLen1 > uiKeyLen2)
{
// Compare the key buffers. No FIRST or LAST key now.
if( (iCmp = f_memcmp( pKey1, pKey2, uiKeyLen2)) == 0)
{
iCmp = 1;
}
}
else if( uiKeyLen1 < uiKeyLen2)
{
if( (iCmp = f_memcmp( pKey1, pKey2, uiKeyLen1)) == 0)
{
iCmp = -1;
}
}
else
{
if( (iCmp = f_memcmp( pKey1, pKey2, uiKeyLen1)) == 0)
{
// The keys are EQUAL.
// bExclusiveKey ONLY applies to an UNTIL key.
// Check the exclusive flag and THEN if needed the uiRecordId.
if( !bKey1IsUntilKey)
{
if( bKey2IsUntilKey && bExclusiveKey2)
{
iCmp = 1;
}
}
else if( !bKey2IsUntilKey)
{
if( bKey1IsUntilKey && bExclusiveKey1)
{
iCmp = -1;
}
}
else // both are until keys.
{
if( bExclusiveKey1 != bExclusiveKey2)
{
iCmp = bExclusiveKey1 ? -1 : 1;
}
}
}
}
return (iCmp);
}
/****************************************************************************
Desc: Allocate and return the first and last keys in an index.
****************************************************************************/
RCODE FSIndexCursor::getFirstLastKeys(
FLMBYTE ** ppFirstKey,
FLMUINT * puiFirstKeyLen,
FLMBYTE ** ppLastKey,
FLMUINT * puiLastKeyLen,
FLMBOOL * pbLastKeyExclusive)
{
RCODE rc = FERR_OK;
KEYSET * pCurSet = m_pFirstSet;
if( !pCurSet)
{
*ppFirstKey = *ppLastKey = NULL;
*puiFirstKeyLen = 0;
*pbLastKeyExclusive = TRUE;
goto Exit;
}
if( RC_BAD( rc = f_alloc( pCurSet->fromKey.uiKeyLen,
ppFirstKey)))
{
goto Exit;
}
*puiFirstKeyLen = pCurSet->fromKey.uiKeyLen;
f_memcpy( *ppFirstKey, pCurSet->fromKey.pKey, *puiFirstKeyLen);
while( pCurSet->pNext)
{
pCurSet = pCurSet->pNext;
}
if( RC_BAD( rc = f_alloc( pCurSet->untilKey.uiKeyLen,
ppLastKey)))
{
if( *ppFirstKey)
{
f_free( ppFirstKey);
}
goto Exit;
}
*puiLastKeyLen = pCurSet->untilKey.uiKeyLen;
f_memcpy( *ppLastKey, pCurSet->untilKey.pKey, *puiLastKeyLen);
*pbLastKeyExclusive = pCurSet->untilKey.bExclusiveKey;
Exit:
return( rc);
}
/****************************************************************************
Desc: Set the absolute position in a positioning index relative to the
FROM/UNTIL keys in all of the key sets. Supports multiple key sets.
****************************************************************************/
RCODE FSIndexCursor::setAbsolutePosition(
FDB * pDb,
FLMUINT uiRefPosition) // 0 -> BOF, -1 -> EOF points, one based
{
RCODE rc = FERR_OK;
FLMUINT uiBtreeRefPosition;
KEYSET * pTempSet;
if( !isAbsolutePositionable())
{
flmAssert(0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
// Zero value position to BOF
if( uiRefPosition == 0 || uiRefPosition == 1)
{
// Go to the first reference.
if( RC_OK( rc = firstKey( pDb, NULL, NULL)))
{
if( uiRefPosition == 0)
{
// Should return FERR_BOF_HIT
rc = prevKey( pDb, NULL, NULL);
}
}
goto Exit;
}
// High-values value position to EOF
if( uiRefPosition == (FLMUINT) -1)
{
// Position to EOF
if( RC_OK( rc = lastKey( pDb, NULL, NULL)))
{
// Should return FERR_EOF_HIT
rc = nextKey( pDb, NULL, NULL);
}
goto Exit;
}
// Find the set that contains this absolute position.
uiBtreeRefPosition = 0;
for( pTempSet = m_pFirstSet; pTempSet; pTempSet = pTempSet->pNext)
{
FLMUINT uiTotalInSet;
uiTotalInSet = pTempSet->untilKey.uiRefPosition -
pTempSet->fromKey.uiRefPosition;
if( uiTotalInSet < uiRefPosition)
{
uiRefPosition -= uiTotalInSet;
}
else
{
m_pCurSet = pTempSet;
uiBtreeRefPosition = pTempSet->fromKey.uiRefPosition + uiRefPosition - 1;
break;
}
}
if( !uiBtreeRefPosition)
{
// Position to EOF
if( RC_OK( rc = lastKey( pDb, NULL, NULL)))
{
// Should return FERR_EOF_HIT
rc = nextKey( pDb, NULL, NULL);
}
goto Exit;
}
m_curKeyPos.pStack = m_curKeyPos.Stack;
RESET_DINSTATE( m_curKeyPos.DinState);
m_curKeyPos.Stack[0].pKeyBuf = m_curKeyPos.pKey;
if( RC_BAD( rc = FSPositionSearch( pDb, m_pLFile, uiBtreeRefPosition,
&m_curKeyPos.pStack, &m_curKeyPos.uiRecordId,
&m_curKeyPos.uiDomain, &m_curKeyPos.DinState)))
{
goto Exit;
}
m_curKeyPos.bStackInUse = TRUE;
setKeyItemsFromBlock( &m_curKeyPos);
m_bAtBOF = m_bAtEOF = FALSE;
Exit:
return( rc);
}
/****************************************************************************
Desc: Get the absolute position in a positioning index.
Supports multiple sets.
****************************************************************************/
RCODE FSIndexCursor::getAbsolutePosition(
FDB * pDb,
FLMUINT * puiRefPosition) // 0 -> BOF, -1 -> EOF points, one based
{
RCODE rc = FERR_OK;
FLMUINT uiRefPosition = 0; // Position relative to the FROM key sets.
FLMUINT uiBtreeRefPosition; // True absolute position in the btree.
KEYSET * pTempSet;
if( !isAbsolutePositionable())
{
flmAssert(0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
if( m_bAtBOF)
{
*puiRefPosition = 0;
goto Exit;
}
if( m_bAtEOF)
{
*puiRefPosition = (FLMUINT) -1;
goto Exit;
}
if( !m_curKeyPos.bStackInUse)
{
FLMBOOL bKeyGone;
FLMBOOL bRefGone;
if( RC_BAD( rc = reposition( pDb, FALSE, FALSE, &bKeyGone,
FALSE, FALSE, &bRefGone)))
{
if( rc != FERR_NOT_FOUND)
goto Exit;
rc = FERR_OK;
}
}
// Compute where we are relative the the reference position of the current set.
if( RC_BAD( rc = FSGetBtreeRefPosition( pDb, m_curKeyPos.pStack,
&m_curKeyPos.DinState, &uiBtreeRefPosition)))
{
goto Exit;
}
uiRefPosition = (uiBtreeRefPosition - m_pCurSet->fromKey.uiRefPosition) + 1;
for( pTempSet = m_pCurSet->pPrev; pTempSet; pTempSet = pTempSet->pPrev)
{
FLMUINT uiTemp;
uiTemp = pTempSet->untilKey.uiRefPosition - pTempSet->fromKey.uiRefPosition;
uiRefPosition += uiTemp;
}
Exit:
if( RC_OK( rc))
{
*puiRefPosition = uiRefPosition;
}
return( rc);
}
/****************************************************************************
Desc: Get the total number of reference for all of the sets.
****************************************************************************/
RCODE FSIndexCursor::getTotalReferences(
FDB * pDb,
FLMUINT * puiTotalRefs,
FLMBOOL * pbTotalsEstimated)
{
RCODE rc = FERR_OK;
KEYSET * pKeySet; // Current source set
KEYSET * pTempSet = NULL;
FLMUINT uiTotalRefs = 0;
FLMUINT uiRefCount;
FLMUINT uiStackPos;
if( RC_BAD( rc = checkTransaction( pDb)))
{
goto Exit;
}
*pbTotalsEstimated = FALSE;
// We have to be careful not to change the current position in any way.
for( pKeySet = m_pFirstSet; pKeySet; pKeySet = pKeySet->pNext)
{
// If this is an positioning index, the ref positions MAY be set up.
if( pKeySet->fromKey.uiRefPosition && pKeySet->untilKey.uiRefPosition)
{
uiTotalRefs += pKeySet->untilKey.uiRefPosition -
pKeySet->fromKey.uiRefPosition;
continue;
}
else if( !pTempSet)
{
if( RC_BAD( rc = f_calloc( sizeof( KEYSET), &pTempSet)))
{
goto Exit;
}
}
// Compute the counts the old fashion way.
f_memcpy( pTempSet, pKeySet, sizeof( KEYSET));
for( uiStackPos = 0; uiStackPos < BH_MAX_LEVELS; uiStackPos++)
{
pTempSet->fromKey.Stack[uiStackPos].pSCache = NULL;
pTempSet->fromKey.Stack[uiStackPos].pBlk = NULL;
pTempSet->untilKey.Stack[uiStackPos].pSCache = NULL;
pTempSet->untilKey.Stack[uiStackPos].pBlk = NULL;
}
pTempSet->fromKey.bStackInUse = FALSE;
pTempSet->untilKey.bStackInUse = FALSE;
// Search down the tree and get the counts.
if( RC_OK( rc = setKeyPosition( pDb, TRUE,
&pTempSet->fromKey, &pTempSet->fromKey)))
{
// All keys bewteen low and high may be gone.
if( FS_COMPARE_KEYS( FALSE, &pTempSet->fromKey,
TRUE, &pKeySet->untilKey) > 0)
{
rc = RC_SET( FERR_BOF_HIT);
}
else
{
rc = setKeyPosition( pDb, FALSE,
&pTempSet->untilKey, &pTempSet->untilKey);
}
}
if( RC_BAD( rc))
{
// Empty tree case.
if( rc == FERR_EOF_HIT || rc == FERR_BOF_HIT)
{
rc = FERR_OK;
}
else
{
goto Exit;
}
}
else
{
if( RC_BAD( rc = FSComputeIndexCounts( pTempSet->fromKey.pStack,
pTempSet->untilKey.pStack, NULL, NULL,
&uiRefCount, pbTotalsEstimated)))
{
goto Exit;
}
uiTotalRefs += uiRefCount;
}
releaseKeyBlocks( &pTempSet->fromKey);
releaseKeyBlocks( &pTempSet->untilKey);
}
Exit:
if( pTempSet)
{
releaseKeyBlocks( &pTempSet->fromKey);
releaseKeyBlocks( &pTempSet->untilKey);
f_free( &pTempSet);
}
if( RC_OK(rc))
{
*puiTotalRefs = uiTotalRefs;
}
return( rc);
}
Reference in New Issue View Git Blame Copy Permalink