//------------------------------------------------------------------------------
// Desc:	Check logical integrity of indexes.
// Tabs:	3
//
// Copyright (c) 1992, 1994-2007 Novell, Inc. All Rights Reserved.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version 2.1
// of the License.
//
// This library 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
// Library Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; 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$
//------------------------------------------------------------------------------

#include "flaimsys.h"

/********************************************************************
Desc:	This routine builds a key tree from a collated key
********************************************************************/
RCODE F_DbCheck::keyToVector(
	FLMBYTE *			pucKey,
	FLMUINT				uiKeyLen,
	IF_DataVector **	ppKeyRV
	)
{
	RCODE	rc = NE_XFLM_OK;

	// Generate the key tree

	if ((*ppKeyRV = f_new F_DataVector) == NULL)
	{
		rc = RC_SET( NE_XFLM_MEM);
		goto Exit;
	}

	(*ppKeyRV)->reset();

	rc = (*ppKeyRV)->inputKey( m_pDb, m_pIxd->uiIndexNum, pucKey, uiKeyLen);

Exit:

	return( rc);
}

/********************************************************************
Desc: Retrieves the next key from the sorted result set
*********************************************************************/
RCODE F_DbCheck::chkGetNextRSKey( void)
{
	RCODE			rc = NE_XFLM_OK;
	RS_IX_KEY *	pCurrRSKey;

	// Swap current and last key pointers - this allows us to always keep
	// the last key without having to memcpy the keys.

	pCurrRSKey = m_pCurrRSKey;
	m_pCurrRSKey = m_pPrevRSKey;
	m_pPrevRSKey = pCurrRSKey;
	pCurrRSKey = m_pCurrRSKey;

	if (pCurrRSKey == NULL)
	{
		rc = RC_SET( NE_XFLM_EOF_HIT);
		goto Exit;
	}

	// Get the next key - call getFirst because we are deleting the
	// entry after we process it.
	
	if (RC_BAD( rc = m_pIxRSet->getFirst( m_pDb, m_pIxd, NULL,
										pCurrRSKey->pucRSKeyBuf,
										XFLM_MAX_KEY_SIZE,
										&pCurrRSKey->uiRSKeyLen,
										pCurrRSKey->pucRSDataBuf,
										XFLM_MAX_KEY_SIZE,
										&pCurrRSKey->uiRSDataLen)))
	{
		goto Exit;
	}

	// Verify that the key meets the minimum length requirements

	flmAssert( pCurrRSKey->uiRSKeyLen);

Exit:

	return( rc);

}

/********************************************************************
Desc: Verifies the current index key against the result set.
*********************************************************************/
RCODE F_DbCheck::verifyIXRSet(
	STATE_INFO *	pStateInfo)
{
	RCODE			rc = NE_XFLM_OK;
	FLMINT		iCmpVal = 0;
	FLMUINT		uiIteration = 0;
	FLMBOOL		bRSetEmpty = FALSE;
	RS_IX_KEY *	pCurrRSKey;
	RS_IX_KEY *	pPrevRSKey;

	if (!m_pCurrRSKey)
	{
		m_pCurrRSKey = &m_IxKey1;
		m_pPrevRSKey = &m_IxKey2;
	}

	// Compare index and result set keys
	
	while (!bRSetEmpty)
	{
		if (m_bGetNextRSKey)
		{

			// Get the next key from the result set.  If the result set
			// is empty, then m_uiRSKeyLen will be set to
			// zero, forcing the problem to be resolved below.

			if (RC_BAD( rc = chkGetNextRSKey()))
			{
				if (rc == NE_XFLM_EOF_HIT || rc == NE_XFLM_NOT_FOUND)
				{

					// Set bRSetEmpty to TRUE so that the loop will exit after the
					// current key is resolved.  Otherwise, conflict resolution on
					// the current key will be repeated forever (infinite loop).

					bRSetEmpty = TRUE;
					rc = NE_XFLM_OK;
				}
				else
				{
					goto Exit;
				}
			}
			else
			{

				// Update statistics
				
				m_Progress.ui64NumKeysExamined++;
			}
		}
		pCurrRSKey = m_pCurrRSKey;
		pPrevRSKey = m_pPrevRSKey;

		if (pCurrRSKey->uiRSKeyLen == 0 || bRSetEmpty)
		{

			// We don't have a key because we got an EOF when
			// reading the result set.  Need to resolve the
			// fact that the result set does not have a key
			// that is found in the index.  Set iCmpVal to
			// 1 to force this resolution.

			iCmpVal = 1;
		}
		else
		{

			// Compare the index key and result set key.
			
			if (RC_BAD( rc = ixKeyCompare( m_pDb, m_pIxd, NULL, NULL, NULL,
										TRUE, TRUE,
										pCurrRSKey->pucRSKeyBuf,
										pCurrRSKey->uiRSKeyLen,
										pStateInfo->pucElmKey,
										pStateInfo->uiElmKeyLen, &iCmpVal)))
			{
				goto Exit;
			}
		}

		if (iCmpVal < 0)
		{

			// The result set key is less than the index key.  This could mean
			// that the result set key needs to be added to the index.

			if ( RC_BAD( rc = resolveIXMissingKey( pStateInfo)))
			{

				// If the key was added to the index (bReposition == TRUE)
				// or we got some other error, we don't want to get the next
				// result set key.

				m_bGetNextRSKey = (bRSetEmpty ? TRUE : FALSE);
				goto Exit;
			}
			else
			{

				// False alarm.  The index is missing the key because of
				// a concurrent update.  We want to get the next RS key.

				m_bGetNextRSKey = TRUE;
				
				// Delete the current key in the result set so we don't hit it again.
				
				if (RC_BAD( rc = m_pIxRSet->deleteEntry( m_pDb, m_pIxd,
										pCurrRSKey->pucRSKeyBuf, pCurrRSKey->uiRSKeyLen)))
				{
					goto Exit;
				}
			}
		}
		else if (iCmpVal > 0)
		{

			// The result set key is greater than the index key.  This could mean
			// that the index key needs to be deleted from the index.  Whether we
			// delete the index key or not, we don't need to get the next result
			// set key, but we do want to reposition and get the next index key.

			m_bGetNextRSKey = (bRSetEmpty ? TRUE : FALSE);
			if ( RC_BAD( rc = resolveRSetMissingKey( pStateInfo)))
			{
				goto Exit;
			}
			break;
		}
		else
		{

			// The index and result set keys are equal.  We want to get
			// the next result set key.

			m_bGetNextRSKey = TRUE;

			// Delete the current key in the result set so we don't hit it again.
			
			if (RC_BAD( rc = m_pIxRSet->deleteEntry( m_pDb, m_pIxd,
									pCurrRSKey->pucRSKeyBuf, pCurrRSKey->uiRSKeyLen)))
			{
				goto Exit;
			}

			break;
		}

		// Call the yield function periodically

		uiIteration++;
		if (!(uiIteration & 0x1F) )
		{
			f_yieldCPU();
		}
	}

Exit:

	return( rc);
}

/********************************************************************
Desc: Resolves the case of a key found in the result set but not in
		the current index.
*********************************************************************/
RCODE F_DbCheck::resolveIXMissingKey(
	STATE_INFO *	pStateInfo)
{
	FLMBOOL					bKeyInDoc;
	FLMBOOL					bKeyInIndex;
	RCODE						rc = NE_XFLM_OK;
	FLMBOOL					bFixCorruption = FALSE;
	RS_IX_KEY *				pCurrRSKey = m_pCurrRSKey;
	XFLM_INDEX_STATUS		ixStatus;

	// Determine if the record generates the key and if the
	// key is found in the index.

	if (RC_BAD( rc = getKeySource( pCurrRSKey->pucRSKeyBuf,
											 pCurrRSKey->uiRSKeyLen,
											 &bKeyInDoc, &bKeyInIndex)))
	{
		if (rc == NE_XFLM_INDEX_OFFLINE)
		{
			rc = NE_XFLM_OK;
		}
		goto Exit;
	}

	// If the record does not generate the key or the key+ref is in the index,
	// the index is not corrupt.

	if (!bKeyInDoc || bKeyInIndex)
	{
		m_Progress.ui64NumConflicts++;
		goto Exit;
	}

	// Otherwise, the index is corrupt.

	// Update statistics
	
	m_Progress.ui64NumDocKeysNotFound++;
	m_pDbInfo->m_uiLogicalCorruptions++;

	// Report the error
	
	if (RC_BAD( rc = reportIxError( pStateInfo,
											  FLM_KEY_NOT_IN_KEY_REFSET,
											  pCurrRSKey->pucRSKeyBuf,
											  pCurrRSKey->uiRSKeyLen,
											  &bFixCorruption)))
	{
		goto Exit;
	}

	// Exit if the application does not want to repair the corruption.

	if (!bFixCorruption)
	{

		// Set the logical corruption flag

		m_bIndexCorrupt = TRUE;
		goto Exit;
	}

	// Fix the corruption
	
	if (RC_BAD( rc = m_pDb->indexStatus( m_pIxd->uiIndexNum, &ixStatus)))
	{
		goto Exit;
	}
	
	if (ixStatus.ui64LastDocumentIndexed == (FLMUINT64)~0 &&
		 ixStatus.eState != XFLM_INDEX_SUSPENDED)
	{

		// Update statistics

		m_pDbInfo->m_uiLogicalRepairs++;
			
		// Add the key
		
		if (RC_OK( rc = addDelKeyRef( pCurrRSKey->pucRSKeyBuf,
												pCurrRSKey->uiRSKeyLen,
												FALSE)))
		{
			goto Exit;
		}
		else
		{

			// Set the logical corruption flag

			m_bIndexCorrupt = TRUE;
		}
	}
	else
	{

		// Set the logical corruption flag

		m_bIndexCorrupt = TRUE;
	}

Exit:

	return( rc);
}


/********************************************************************
Desc: Resolves the case of a key found in the current index but not
		in the result set.
*********************************************************************/
RCODE F_DbCheck::resolveRSetMissingKey(
	STATE_INFO *	pStateInfo)
{
	RCODE						rc = NE_XFLM_OK;
	FLMBOOL					bKeyInDoc;
	FLMBOOL					bKeyInIndex;
	FLMBOOL					bFixCorruption = FALSE;
	XFLM_INDEX_STATUS		ixStatus;

	// See if the key is found in the index and/or generated
	// by the document.
	
	if (RC_BAD( rc = getKeySource( pStateInfo->pucElmKey,
											 pStateInfo->uiElmKeyLen,
											 &bKeyInDoc, &bKeyInIndex)))
	{
		if (rc == NE_XFLM_INDEX_OFFLINE)
		{
			rc = NE_XFLM_OK;
		}
		goto Exit;
	}

	// If the key is generated by the record or the key is not found
	// in the index, the index is not corrupt.
	
	if (bKeyInDoc || !bKeyInIndex)
	{
		m_Progress.ui64NumConflicts++;
		goto Exit;
	}

	// Otherwise, the index is corrupt.

	// Update statistics
	
	m_Progress.ui64NumKeysNotFound++;
	m_pDbInfo->m_uiLogicalCorruptions++;

	// Report the error

	if (RC_BAD( rc = reportIxError( pStateInfo,
											  FLM_IX_KEY_NOT_FOUND_IN_REC, 
											  pStateInfo->pucElmKey,
											  pStateInfo->uiElmKeyLen,
											  &bFixCorruption)))
	{
		goto Exit;
	}

	// Exit if the application does not want to repair the corruption.

	if (!bFixCorruption)
	{

		// Set the logical corruption flag

		m_bIndexCorrupt = TRUE;
		goto Exit;
	}

	// Fix the corruption

	if (RC_BAD( rc = m_pDb->indexStatus( m_pIxd->uiIndexNum, &ixStatus)))
	{
		goto Exit;
	}
	
	if (ixStatus.ui64LastDocumentIndexed == (FLMUINT64)~0 &&
		 ixStatus.eState != XFLM_INDEX_SUSPENDED)
	{

		// Update statistics

		m_pDbInfo->m_uiLogicalRepairs++;
			
		// Delete the reference from the index
		
		if (RC_BAD( rc = addDelKeyRef( pStateInfo->pucElmKey,
												pStateInfo->uiElmKeyLen,
												TRUE)))
		{
			// Set the logical corruption flag

			m_bIndexCorrupt = TRUE;
		}
		goto Exit;
	}
	else
	{

		// Set the logical corruption flag

		m_bIndexCorrupt = TRUE;
	}

Exit:

	return( rc);
}

/********************************************************************
Desc: Verifies that a key component is actually in the document.
*********************************************************************/
RCODE F_DbCheck::verifyComponentInDoc(
	ICD *				pIcd,
	FLMUINT			uiComponent,
	F_DataVector *	pKey,
	FLMBOOL *		pbInDoc
	)
{
	RCODE				rc = NE_XFLM_OK;
	F_DOMNode *		pDOMNode = NULL;
	FLMUINT64		ui64NodeId;
	FLMUINT			uiNameId;
	
	// Get the nodeId.
	
	if ((ui64NodeId = pKey->getID( uiComponent)) != 0)
	{
		if (RC_BAD( rc = m_pDb->getNode( m_pIxd->uiCollectionNum, ui64NodeId,
												 &pDOMNode)))
		{
			if (rc == NE_XFLM_DOM_NODE_NOT_FOUND)
			{
				rc = NE_XFLM_OK;
			}
			*pbInDoc = FALSE;
			goto Exit;
		}
		
		// No need to verify the name ID if it is an element root tag.
		
		if( pIcd->uiFlags & ICD_IS_ATTRIBUTE)
		{
			if( RC_BAD( rc = pDOMNode->hasAttribute( m_pDb, pIcd->uiDictNum)))
			{
				if( rc == NE_XFLM_DOM_NODE_NOT_FOUND)
				{
					rc = NE_XFLM_OK;
				}

				*pbInDoc = FALSE;
				goto Exit;
			}
		}
		else if( pIcd->uiDictNum != ELM_ROOT_TAG)
		{
			if (RC_BAD( rc = pDOMNode->getNameId( m_pDb, &uiNameId)))
			{
				goto Exit;
			}
	
			if (uiNameId != pIcd->uiDictNum)
			{
				*pbInDoc = FALSE;
				goto Exit;
			}
		}

		// Make sure these are the same type.
		
		if ((pKey->isAttr( uiComponent) && !(pIcd->uiFlags & ICD_IS_ATTRIBUTE)) ||
			 (!pKey->isAttr( uiComponent) && (pIcd->uiFlags & ICD_IS_ATTRIBUTE)))
		{
			goto Exit;
		}

		// Verify that the node belongs to the document.
		
		if (pKey->getDocumentID() != pDOMNode->getDocumentId())
		{
			*pbInDoc = FALSE;
			goto Exit;
		}
	}
	
Exit:

	if (pDOMNode)
	{
		pDOMNode->Release();
	}

	return( rc);
}

/********************************************************************
Desc: Determines if a key is generated by the current document
		and/or if the key is found in the current index
*********************************************************************/
RCODE F_DbCheck::getKeySource(
	FLMBYTE *		pucKey,
	FLMUINT			uiKeyLen,
	FLMBOOL *		pbKeyInDoc,
	FLMBOOL *		pbKeyInIndex
	)
{
	RCODE				rc = NE_XFLM_OK;
	ICD *				pIcd;
	FLMUINT			uiComponent;
	F_DataVector	key;

	// Initialize return values.

	*pbKeyInDoc = FALSE;
	*pbKeyInIndex = FALSE;
	
	if (m_pIxd->uiFlags & IXD_OFFLINE)
	{
		rc = RC_SET( NE_XFLM_INDEX_OFFLINE);
		goto Exit;
	}
	
	// See if the key is in the index.
		
	if (RC_BAD( rc = chkVerifyKeyExists( pucKey, uiKeyLen, pbKeyInIndex)))
	{
		goto Exit;
	}

	// Put the key into a data vector structure.
	
	if (RC_BAD( rc = key.inputKey( m_pDb, m_pIxd->uiIndexNum, pucKey, uiKeyLen)))
	{
		goto Exit;
	}

	// See if all of the nodes referenced from the key actually are in the
	// document.  This includes data nodes and context nodes.

	*pbKeyInDoc = TRUE;
	uiComponent = 0;
	pIcd = m_pIxd->pFirstKey;
	while (pIcd)
	{
		if (RC_BAD( rc = verifyComponentInDoc( pIcd, uiComponent, &key, pbKeyInDoc)))
		{
			goto Exit;
		}
		if (!(*pbKeyInDoc))
		{
			goto Exit;
		}
		uiComponent++;
		pIcd = pIcd->pNextKeyComponent;
	}
	
	// Go through data components.
	
	pIcd = m_pIxd->pFirstData;
	while (pIcd)
	{
		if (RC_BAD( rc = verifyComponentInDoc( pIcd, uiComponent, &key, pbKeyInDoc)))
		{
			goto Exit;
		}
		if (!(*pbKeyInDoc))
		{
			goto Exit;
		}
		uiComponent++;
		pIcd = pIcd->pNextDataComponent;
	}
	
	// Go through context components

	pIcd = m_pIxd->pFirstContext;
	while (pIcd)
	{
		if (RC_BAD( rc = verifyComponentInDoc( pIcd, uiComponent, &key, pbKeyInDoc)))
		{
			goto Exit;
		}
		if (!(*pbKeyInDoc))
		{
			goto Exit;
		}
		uiComponent++;
		pIcd = pIcd->pNextKeyComponent;
	}
	
Exit:

	return( rc);
}

/********************************************************************
Desc: Verify that a key is (or is not) found in an index.
*********************************************************************/
RCODE F_DbCheck::chkVerifyKeyExists(
	FLMBYTE *		pucKey,
	FLMUINT			uiKeyLen,
	FLMBOOL *		pbFoundRV)
{
	RCODE				rc = NE_XFLM_OK;
	F_Btree *		pbtree = NULL;
	IXKeyCompare	compareObject;
	
	compareObject.setIxInfo( m_pDb, m_pIxd);
	compareObject.setCompareNodeIds( TRUE);
	compareObject.setCompareDocId( TRUE);

	*pbFoundRV = FALSE;

	// Get a btree
	
	if (RC_BAD( rc = gv_XFlmSysData.pBtPool->btpReserveBtree( &pbtree)))
	{
		goto Exit;
	}

	if( RC_BAD( rc = pbtree->btOpen( m_pDb, &m_pIxd->lfInfo, 
		(m_pIxd->uiFlags & IXD_ABS_POS) ? TRUE : FALSE, FALSE,
		&compareObject)))
	{
		goto Exit;
	}

	if( RC_BAD( rc = pbtree->btLocateEntry(
								pucKey, uiKeyLen, &uiKeyLen, XFLM_EXACT)))
	{
		if( rc == NE_XFLM_NOT_FOUND)
		{
			rc = NE_XFLM_OK;
		}
		goto Exit;
	}

	*pbFoundRV = TRUE;

Exit:

	if (pbtree)
	{
		gv_XFlmSysData.pBtPool->btpReturnBtree( &pbtree);
	}

	return( rc );
}

/***************************************************************************
Desc:	This routine adds or deletes an index key and/or reference.
*****************************************************************************/
RCODE F_DbCheck::addDelKeyRef(
	FLMBYTE *		pucKey,
	FLMUINT			uiKeyLen,
	FLMBOOL			bDelete)
{
	RCODE				rc = NE_XFLM_OK;
	FLMBYTE			ucKeyBuf[ sizeof( KREF_ENTRY) + XFLM_MAX_KEY_SIZE];
	KREF_ENTRY *	pKrefEntry = (KREF_ENTRY *)(&ucKeyBuf[ 0]);
	FLMBOOL			bStartedUpdate = FALSE;
	FLMBOOL			bKeyInDoc;
	FLMBOOL			bKeyInIndex;

	// Start an update transaction, if necessary

	if (RC_BAD( rc = startUpdate()))
	{
		goto Exit;
	}
	bStartedUpdate = TRUE;
	
	// Verify that the state has not changed

	if (RC_BAD( rc = getKeySource( pucKey, uiKeyLen,
											 &bKeyInDoc, &bKeyInIndex)))
	{
		goto Exit;
	}

	if ((bKeyInIndex && bDelete) || (!bKeyInIndex && !bDelete))
	{
		// Setup the KrefEntry structure

		f_memcpy( &(ucKeyBuf[ sizeof( KREF_ENTRY)]), pucKey, uiKeyLen);
		pKrefEntry->ui16KeyLen = (FLMUINT16)uiKeyLen;
		pKrefEntry->uiDataLen = 0;
		pKrefEntry->ui16IxNum = (FLMUINT16)m_pIxd->uiIndexNum;
		pKrefEntry->uiSequence = 1;
		pKrefEntry->bDelete = bDelete;

		// Add or delete the key/reference.
		
		if (RC_BAD( rc = m_pDb->refUpdate( &m_pIxd->lfInfo, m_pIxd, pKrefEntry,
															FALSE)))
		{
			goto Exit;
		}

		// Update statistics

		m_Progress.ui32NumProblemsFixed++;
	}

Exit:

	// End the update

	if (bStartedUpdate)
	{
		RCODE	rc2;
		
		if (RC_BAD( rc2 = chkEndUpdate()))
		{
			if (RC_OK( rc))
			{
				rc = rc2;
			}
		}
	}

	return( rc);
}

/********************************************************************
Desc: Populates the XFLM_CORRUPT_INFO structure and calls the user's
		callback routine.
*********************************************************************/
RCODE F_DbCheck::reportIxError(
	STATE_INFO *	pStateInfo,
	FLMINT32			i32ErrCode,
	FLMBYTE *		pucErrKey,
	FLMUINT			uiErrKeyLen,
	FLMBOOL *		pbFixErrRV
	)
{
	RCODE						rc = NE_XFLM_OK;
	void *					pDbPoolMark = NULL;
	FLMBOOL					bResetKRef = FALSE;
	XFLM_CORRUPT_INFO		CorruptInfo;

	f_memset( &CorruptInfo, 0, sizeof( XFLM_CORRUPT_INFO));

	// Need to mark the DB's temporary pool.  The index code allocates
	// memory for new CDL entries from the DB pool.  If the pool is not
	// reset, it grows during the check and becomes VERY large.

	pDbPoolMark = m_pDb->m_tempPool.poolMark();

	// Set up the KRef so that flmGetRecKeys will work
	
	if (RC_BAD( rc = m_pDb->krefCntrlCheck()))
	{
		goto Exit;
	}
	bResetKRef = TRUE;

	// Fix corruptions by default unless the app says not to.

	CorruptInfo.ui32ErrLocale = XFLM_LOCALE_INDEX;
	CorruptInfo.i32ErrCode = i32ErrCode;
	CorruptInfo.ui32ErrLfNumber = (FLMUINT32)m_pIxd->uiIndexNum;
	CorruptInfo.ui32ErrElmOffset = (FLMUINT32)pStateInfo->uiElmOffset;

	// Generate the key tree using the key that caused the error

	if (RC_BAD( rc = keyToVector( pucErrKey, uiErrKeyLen, &CorruptInfo.ifpErrIxKey)))
	{
		goto Exit;
	}

	// Report the error

	*pbFixErrRV = FALSE;
	if (m_pDbCheckStatus && RC_OK( m_LastStatusRc))
	{
		m_LastStatusRc = m_pDbCheckStatus->reportCheckErr( &CorruptInfo, pbFixErrRV);
	}

Exit:

	if (CorruptInfo.ifpErrIxKey)
	{
		CorruptInfo.ifpErrIxKey->Release();
		CorruptInfo.ifpErrIxKey = NULL;
	}

	// Remove any keys added to the KRef
	
	if (bResetKRef)
	{
		m_pDb->krefCntrlFree(); // VISIT:  Is this correct?
	}

	// Reset the index check pool

	m_pDb->m_tempPool.poolReset(pDbPoolMark);

	return( rc);
}

/***************************************************************************
Desc:	Start an update transaction
*****************************************************************************/
RCODE F_DbCheck::startUpdate( void)
{
	RCODE		rc = NE_XFLM_OK;
	FLMBOOL	bAbortedReadTrans = FALSE;
	FLMUINT	uiSaveIndexNum = m_pIxd->uiIndexNum;

	// This routine should never be called unless
	// XFLM_ONLINE flag was passed in to the check.

	flmAssert( m_uiFlags & XFLM_ONLINE);
	
	if (m_pDb->getTransType() == XFLM_READ_TRANS)
	{

		// Free the KrefCntrl

		m_pDb->krefCntrlCheck();

		// Abort the read transaction

		m_pIxd = NULL;
		if (RC_BAD( rc = m_pDb->transAbort()))
		{
			goto Exit;
		}
		bAbortedReadTrans = TRUE;

		// Try to start an update transaction
	
		if (RC_BAD( rc = m_pDb->transBegin( XFLM_UPDATE_TRANS, FLM_NO_TIMEOUT,
													 XFLM_DONT_POISON_CACHE)))
		{
			goto Exit;
		}
		m_bStartedUpdateTrans = TRUE;
		
		// Must reget the IXD.
		
		if (RC_BAD( rc = m_pDb->getDict()->getIndex( uiSaveIndexNum, &m_pLFile,
										&m_pIxd, TRUE)))
		{
			goto Exit;
		}
	}

	if (RC_BAD( m_LastStatusRc))
	{
		rc = m_LastStatusRc;
		goto Exit;
	}

Exit:

	// If something went wrong after the update transaction was started,
	// abort the transaction.

	if (RC_BAD( rc))
	{
		if (m_bStartedUpdateTrans)
		{
			m_pDb->transAbort();
			m_bStartedUpdateTrans = FALSE;
		}
	}

	// Re-start the read transaction.
	
	if (bAbortedReadTrans && !m_bStartedUpdateTrans)
	{
		RCODE	rc2;
		
		m_pIxd = NULL;
		if (RC_BAD( rc2 = m_pDb->transBegin( XFLM_READ_TRANS, FLM_NO_TIMEOUT,
									  XFLM_DONT_POISON_CACHE)))
		{
			if (RC_OK( rc))
			{
				rc = rc2;
			}
		}
		else
		{
			if (RC_BAD( rc2 = m_pDb->getDict()->getIndex( uiSaveIndexNum, &m_pLFile,
												&m_pIxd, TRUE)))
			{
				if (RC_OK( rc))
				{
					rc = rc2;
				}
			}
		}
	}

	return( rc);
}

/***************************************************************************
Desc:	End an update transaction.
*****************************************************************************/
RCODE F_DbCheck::chkEndUpdate( void)
{
	RCODE		rc = NE_XFLM_OK;
	FLMUINT	uiSaveIndexNum = m_pIxd->uiIndexNum;

	if (m_bStartedUpdateTrans)
	{

		// Commit the update transaction that was started.  If the transaction
		// started by the application, do not commit it.

		m_pIxd = NULL;		
		m_bStartedUpdateTrans = FALSE;
		if (RC_BAD( rc = m_pDb->transCommit()))
		{
			goto Exit;
		}
	}

Exit:
	
	// Re-start read transaction
	
	if (m_pDb->getTransType() == XFLM_NO_TRANS)
	{
		RCODE	rc2;
		
		if (RC_BAD( rc2 = m_pDb->transBegin( 
			XFLM_READ_TRANS, FLM_NO_TIMEOUT, XFLM_DONT_POISON_CACHE)))
		{
			if (RC_OK( rc))
			{
				rc = rc2;
			}
		}
		else
		{
			if (RC_BAD( rc2 = m_pDb->getDict()->getIndex( uiSaveIndexNum, &m_pLFile,
												&m_pIxd, TRUE)))
			{
				if (RC_OK( rc))
				{
					rc = rc2;
				}
			}
		}
	}

	return( rc);
}