//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1991 - 2000.
//
// File: IDXTAB.CXX
//
// Contents: Index Manager
//
// Classes: CIndexTable
//
// History: 22-Mar-91 BartoszM Created.
// 12-Feb-92 AmyA Hacked all methods for FAT.
// 01-Jul-93 BartoszM Rewrote to use memory mapped file
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <cistore.hxx>
#include <idxtab.hxx>
#include <eventlog.hxx>
#include <imprsnat.hxx>
//+---------------------------------------------------------------------------
//----------------------------------------------------------------------------
CWriteIndexFile::CWriteIndexFile ( PRcovStorageObj & rcovObj ) :
_rcovObj(rcovObj),
_xact(rcovObj),
_iter(_xact, sizeof(CIndexRecord)),
_xactPtr(0)
{
}
//+---------------------------------------------------------------------------
//----------------------------------------------------------------------------
void CWriteIndexFile::BackUp()
{
ciAssert(_xactPtr > 0);
_xactPtr--;
_iter.Seek( _xactPtr );
}
//+---------------------------------------------------------------------------
//----------------------------------------------------------------------------
BOOL CWriteIndexFile::ReadRecord ( CIndexRecord * pRecord )
{
ULONG ulRecCnt = _rcovObj.GetHeader().GetCount(_rcovObj.GetHeader().GetBackup());
if (_xactPtr >= ulRecCnt)
return(FALSE);
_iter.GetRec( pRecord );
_xactPtr++;
return(TRUE);
}
//+---------------------------------------------------------------------------
//----------------------------------------------------------------------------
void CWriteIndexFile::WriteRecord ( CIndexRecord* pRecord )
{
_iter.SetRec( pRecord );
_xactPtr++;
ULONG ulRecCnt = _rcovObj.GetHeader().GetCount(_rcovObj.GetHeader().GetBackup());
if (ulRecCnt < _xactPtr)
_rcovObj.GetHeader().SetCount(_rcovObj.GetHeader().GetBackup(), _xactPtr);
}
//+---------------------------------------------------------------------------
//
// Member: CWriteIndexFile::IncrMMergeSeqNum
//
// Synopsis: Increments the master merge sequence number in the header.
//
// History: 3-21-97 srikants Created
//
//----------------------------------------------------------------------------
void CWriteIndexFile::IncrMMergeSeqNum()
{
CRcovStorageHdr & storageHdr = _rcovObj.GetHeader();
CRcovUserHdr usrHdr;
CIndexTableUsrHdr * pIdxUsrHdr = (CIndexTableUsrHdr *) &usrHdr;
storageHdr.GetUserHdr( storageHdr.GetPrimary(), usrHdr );
ciDebugOut(( DEB_ITRACE, "Current MMerge Seq Num = %d \n",
pIdxUsrHdr->GetMMergeSeqNum() ));
pIdxUsrHdr->IncrMMergeSeqNum();
ciDebugOut(( DEB_ITRACE, "New MMerge Seq Num = %d \n",
pIdxUsrHdr->GetMMergeSeqNum() ));
storageHdr.SetUserHdr( storageHdr.GetBackup(), usrHdr );
}
//+---------------------------------------------------------------------------
//----------------------------------------------------------------------------
CReadIndexFile::CReadIndexFile ( PRcovStorageObj & rcovObj ) :
_rcovObj(rcovObj),
_xact(rcovObj),
_iter(_xact, sizeof(CIndexRecord)),
_xactPtr(0)
{
}
//+---------------------------------------------------------------------------
//----------------------------------------------------------------------------
void CReadIndexFile::BackUp()
{
ciAssert(_xactPtr > 0);
_xactPtr--;
_iter.Seek( _xactPtr );
}
//+---------------------------------------------------------------------------
//----------------------------------------------------------------------------
BOOL CReadIndexFile::ReadRecord ( CIndexRecord * pRecord )
{
ULONG ulRecCnt = _rcovObj.GetHeader().GetCount(_rcovObj.GetHeader().GetPrimary());
if (_xactPtr >= ulRecCnt)
return(FALSE);
_iter.GetRec( pRecord );
_xactPtr++;
return(TRUE);
}
//+---------------------------------------------------------------------------
//
// Member: CAddReplaceIndexRecord::CAddReplaceIndexRecord, public
//
// Synopsis: Rewinds the file pointer indFile, then reads in IndexRecords until
// either a record with INDEXID iid is found or EOF is reached.
//
// Notes: Whether or not a record with INDEXID iid is found can be
// determined by calling Found().
//
// History: 16-Mar-92 AmyA Created.
//
//----------------------------------------------------------------------------
CAddReplaceIndexRecord::CAddReplaceIndexRecord ( CWriteIndexFile & indFile,
INDEXID iid )
: _indFile( indFile )
{
_indFile.Rewind();
do
{
_found = _indFile.ReadRecord ( this );
} while (_found && Iid() != iid);
}
//+---------------------------------------------------------------------------
//
// Member: CAddReplaceIndexRecord::Write()
//
// Synopsis: Writes the information from CIndexRecord out to the file--
// either replacing the record that was found in the constructor
// (if there was one found) or appending to the end of the file
// indicated by _indFile.
//
// History: 28-Feb-95 DwightKr Created.
//
//----------------------------------------------------------------------------
inline void CAddReplaceIndexRecord::WriteRecord()
{
if ( Found() )
{
_indFile.BackUp();
}
_indFile.WriteRecord( this );
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTable::CIndexTable, public
//
// Synopsis: Constructor.
//
// History: 28-Mar-91 BartoszM Created.
//
//----------------------------------------------------------------------------
CIndexTable::CIndexTable ( CiStorage& storage, CTransaction& xact )
: _storage(storage), _pRcovObj(0)
{
_pRcovObj = _storage.QueryIdxTableObject();
Win4Assert( 0 != _pRcovObj );
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTable::~CIndexTable, public
//
// Synopsis: Destructor.
//
// History: 28-May-92 BartoszM Created.
//
//----------------------------------------------------------------------------
CIndexTable::~CIndexTable ()
{
delete _pRcovObj;
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTableIter::CIndexTableIter
//
// Synopsis: Constructor.
//
// History: 28-May-92 BartoszM Created.
//
//----------------------------------------------------------------------------
CIndexTabIter::CIndexTabIter ( CIndexTable& idxTable )
: _idxTable(idxTable),
_indFile( idxTable.GetIndexTableObj() )
{
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTabIter::Begin, public
//
// Synopsis: Position cursor at the beginning of table
//
// History: 28-Mar-91 BartoszM Created.
//
//----------------------------------------------------------------------------
BOOL CIndexTabIter::Begin ()
{
CNextIndexRecord rec(_indFile);
if (!rec.Found())
return FALSE;
_indFile.Rewind();
return TRUE;
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTabIter::NextRecord, public
//
// Synopsis: Called during startup. Reads next record
//
// Arguments: [indexRecord] -- record to be filled
//
// History: 28-Mar-91 BartoszM Created.
//
//----------------------------------------------------------------------------
BOOL CIndexTabIter::NextRecord ( CIndexRecord& indexRecord )
{
CNextIndexRecord rec(_indFile);
if (!rec.Found())
return(FALSE);
if ( rec.VersionStamp() < _idxTable._storage.GetStorageVersion() )
{
Win4Assert ( !"Corrupt index table" );
PStorage & storage = GetStorage();
storage.ReportCorruptComponent ( L"IndexTable1" );
THROW( CException ( STATUS_INTERNAL_DB_CORRUPTION ));
}
else if ( rec.VersionStamp() > _idxTable._storage.GetStorageVersion() )
{
ciAssert ( !"Unknown index format: upgrade index software" );
PStorage & storage = GetStorage();
storage.ReportCorruptComponent ( L"IndexTable2" );
THROW( CException ( STATUS_INTERNAL_DB_CORRUPTION ));
}
indexRecord._objectId = rec.ObjectId();
indexRecord._iid = rec.Iid();
indexRecord._type = rec.Type();
indexRecord._maxWorkId = rec.MaxWorkId();
return TRUE;
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTabIter::~CIndexTabIter, public
//
// Synopsis: Iteration finished
//
// History: 28-Mar-91 BartoszM Created.
//
//----------------------------------------------------------------------------
CIndexTabIter::~CIndexTabIter()
{
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTable::SwapIndexes, public
//
// Synopsis: Replaces old indexes with a new one after merge
//
// Arguments: [pIndexNew] -- new index
// [cIndexOld] -- count of old indexes to be removed
// [aIidOld] -- array of old index id's
//
// Notes: ResMan LOCKED
//
// History: 02-May-91 BartoszM Created.
//
//----------------------------------------------------------------------------
void CIndexTable::SwapIndexes ( CShadowMergeSwapInfo & info )
{
CIndexRecord & record = info._recNewIndex;
ciDebugOut (( DEB_ITRACE, "IndexManager: Adding index %lx, maxWid %ld\n",
record.Iid(), record.MaxWorkId() ));
CWriteIndexFile indFile( GetIndexTableObj() );
// Mark old indexes deleted
for ( unsigned i = 0; i < info._cIndexOld; i++ )
{
CIndexId idFull = info._aIidOld[i];
if ( idFull.IsPersistent())
{
CAddReplaceIndexRecord rec(indFile, info._aIidOld[i]);
if (!rec.Found())
{
//
// We have a persistent index which was not found in the
// index list. This must be an index corruption.
//
ciDebugOut(( DEB_ERROR, "Can't find index 0x%lx\n",
info._aIidOld[i] ));
Win4Assert( !"Corrupt index table" );
_storage.ReportCorruptComponent( L"IndexTable3" );
THROW( CException ( CI_CORRUPT_DATABASE ));
}
rec.SetType(itZombie); // And one more....
rec.WriteRecord();
}
}
//
// Add record for the new index.
//
if ( widInvalid != record.ObjectId() )
AddRecord ( indFile,
record.Iid(),
record.Type(),
record.MaxWorkId(),
record.ObjectId() );
//
// Replace the old fresh test entry with the new fresh test entry.
//
DeleteObject( indFile, partidDefault, itFreshLog, info._widOldFreshLog );
AddRecord( indFile, CIndexId( 0, partidDefault ), itFreshLog,
0, info._widNewFreshLog );
indFile.Commit();
}
//+---------------------------------------------------------------------------
//
// Function: SwapIndexes
//
// Synopsis: This method marks the old indexes as "zombie" in the index
// table, deletes the MMLog, MMFreshLog and NewMasterIndex
// entries. It then adds an entry making the NewMaster the
// current master.
//
// This is done as a single TRANSACTION - either the entire
// step succeeds or the previous state is retained.
//
// Effects: All the indexes that participated in the master merge will
// be deleted from the index list and the new master will be
// made the only master index.
//
// Arguments: [partid] -- Partition Id where the master merge just
// completed.
// [cIndexOld] -- Count of the indexes in aIidOld.
// [aIidOld] -- Array of index ids to be marked zombie.
// [recNewMaster] -- CIndexRecord for the new master index.
// [widMMLog] -- WorkId of the MMLog object.
//
// History: 4-04-94 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CIndexTable::SwapIndexes ( CMasterMergeSwapInfo & info )
{
CIndexRecord & recNewMaster = info._recNewIndex;
CIndexRecord & recNewKeyList = info._recNewKeyList;
ciDebugOut (( DEB_ITRACE, "Master Merge Completed\n"));
CWriteIndexFile indFile( GetIndexTableObj() );
//
// Mark old indexes as "Zombie".
//
for ( unsigned i = 0; i < info._cIndexOld; i++ )
{
CIndexId idFull = info._aIidOld[i];
Win4Assert( idFull.IsPersistent() );
Win4Assert( idFull.PartId() == info._partid );
CAddReplaceIndexRecord rec(indFile, info._aIidOld[i]);
if (!rec.Found())
{
//
// We have a persistent index which was not found in the
// index list. This must be an index corruption.
//
ciDebugOut(( DEB_ERROR, "Can't find index 0x%lx\n",
info._aIidOld[i] ));
Win4Assert( !"Corrupt index table" );
_storage.ReportCorruptComponent( L"IndexTable4" );
THROW( CException ( CI_CORRUPT_DATABASE ));
}
rec.SetType(itZombie); // And one more....
rec.WriteRecord();
}
//
// Delete the MMLog entry.
//
DeleteObject( indFile, info._partid, itMMLog, info._widMMLog );
//
// Delete the itMMKeyList entry.
//
DeleteObject( indFile, partidKeyList, itMMKeyList,
recNewKeyList.ObjectId() );
//
// Delete the old itKeyList entry and add an entry for the new
// key list.
//
{
//
// DeleteRecord assumes that the record is found. When we create
// the key list for the first time, it may not be present.
//
CAddReplaceIndexRecord rec( indFile, info._iidOldKeyList );
if ( rec.Found() )
{
rec.SetIid( CIndexId(iidInvalid,partidInvalid) );
rec.WriteRecord();
}
}
AddRecord( indFile, recNewKeyList.Iid(),
recNewKeyList.Type(),
recNewKeyList.MaxWorkId(),
recNewKeyList.ObjectId()
);
//
// Delete the entry for the new master index and make it the
// current master index.
//
DeleteRecord( indFile, recNewMaster.Iid() );
AddRecord (
indFile,
recNewMaster.Iid(),
itMaster, // Note the change from itNewMaster to itMaster
recNewMaster.MaxWorkId(),
recNewMaster.ObjectId());
//
// Replace the old fresh test entry with the new fresh test entry.
//
DeleteObject( indFile, partidDefault, itFreshLog, info._widOldFreshLog );
AddRecord( indFile, CIndexId( 0, partidDefault ), itFreshLog, 0,
info._widNewFreshLog );
//
// Increment the master merge sequence number.
//
indFile.IncrMMergeSeqNum();
indFile.Commit();
}
PIndexTabIter* CIndexTable::QueryIterator()
{
return new CIndexTabIter ( *this );
}
PStorage& CIndexTable::GetStorage()
{
return(_storage);
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTable::RemoveIndex, public
//
// Synopsis: Removes index from table
//
// Arguments: [iid] -- index id
//
// Notes: ResMan LOCKED
//
// History: 02-May-91 BartoszM Created.
//
//----------------------------------------------------------------------------
#pragma optimize( "", off )
void CIndexTable::RemoveIndex ( INDEXID iid )
{
CImpersonateSystem impersonate;
CWriteIndexFile indFile( GetIndexTableObj() );
DeleteRecord( indFile, iid );
indFile.Commit();
}
#pragma optimize( "", on )
//+---------------------------------------------------------------------------
//
// Function: AddObject
//
// Synopsis: Appends a record for the specified object to the
// index table.
//
// Arguments: [partid] -- Id of the partition to which the object
// belongs.
// [it] -- Index type of the object.
// [wid] -- WorkId of the object.
//
// History: 2-18-94 srikants Created
//
//----------------------------------------------------------------------------
void CIndexTable::AddObject( PARTITIONID partid, IndexType it, WORKID wid )
{
CWriteIndexFile indFile( GetIndexTableObj() );
AddRecord ( indFile, CIndexId ( 0, partid ), it, 0, wid );
indFile.Commit();
}
//+---------------------------------------------------------------------------
//
// Function: AddMMergeObjects
//
// Synopsis: This method adds records for the NewMaster Index,
// and MasterMerge Log to the index table.
//
// Arguments: [partid] -- Partition id of the partition in which
// master merge is being done.
// [recNewMaster] -- The index record for the new master index.
// [widMMLog] -- WorkId of the MasterMerge Log.
// [deletedIndex] -- Index id for the current index
//
// History: 4-04-94 srikants Created
//
// Notes: The recNewMaster must be fully initialized with the correct
// indexType, WorkId and MaxWorkId.
//
//----------------------------------------------------------------------------
void CIndexTable::AddMMergeObjects( PARTITIONID partid,
CIndexRecord & recNewMaster,
WORKID widMMLog,
WORKID widMMKeyList,
INDEXID iidDelOld,
INDEXID iidDelNew )
{
CWriteIndexFile indFile( GetIndexTableObj() );
Win4Assert( recNewMaster.Type() == itNewMaster );
Win4Assert( iidDeleted1 == iidDelOld && iidDeleted2 == iidDelNew ||
iidDeleted2 == iidDelOld && iidDeleted1 == iidDelNew );
#if CIDBG == 1
CIndexId iid( recNewMaster.Iid() );
Win4Assert( iid.PartId() == partid );
#endif // CIDBG == 1
AddRecord( indFile, recNewMaster.Iid(), itNewMaster,
recNewMaster.MaxWorkId(), recNewMaster.ObjectId() );
AddRecord( indFile, CIndexId( 0, partid ), itMMLog, 0,widMMLog );
AddRecord( indFile, CIndexId( 0, partidKeyList ), itMMKeyList, 0, widMMKeyList );
DeleteRecord( indFile, iidDelOld );
AddRecord( indFile, iidDelNew, itDeleted, 0, 0 );
indFile.Commit();
}
inline BOOL IsMatched( const CIndexRecord & rec,
INDEXID iid, IndexType it, WORKID wid )
{
return rec.Type() == (ULONG) it && rec.Iid() == iid && rec.ObjectId() == wid ;
}
//+---------------------------------------------------------------------------
//
// Function: DeleteObject
//
// Synopsis: Deletes the record for the specified object by marking
// it as "iidInvalid". The record will be deleted only
// if there is an exact match with the partid, it and wid.
//
// Arguments: [partid] -- Partition Id.
// [it] -- Index type of the object.
// [wid] -- Work Id to match on.
//
// History: 2-18-94 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CIndexTable::DeleteObject( PARTITIONID partid, IndexType it, WORKID wid )
{
CWriteIndexFile indFile( GetIndexTableObj() );
DeleteObject( indFile, partid, it, wid );
indFile.Commit();
}
void CIndexTable::DeleteObject( CWriteIndexFile & indFile,
PARTITIONID partid, IndexType it, WORKID wid )
{
CIndexRecord rec;
BOOL found;
indFile.Rewind();
do
{
found = indFile.ReadRecord ( &rec );
}
while ( found && !IsMatched( rec, CIndexId(0, partid), it, wid) );
if ( found ) {
indFile.BackUp();
rec._iid = (INDEXID) CIndexId(iidInvalid, partidInvalid);
rec._objectId = widInvalid;
indFile.WriteRecord( &rec );
}
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTable::AddRecord, private
//
// Synopsis: Adds new record to table
//
// Arguments: [iid] -- index id
// [type] -- type of record
// [maxWorkId] -- max work id in the index
// [objectId] -- id of the index object
//
// Notes: ResMan LOCKED
//
// History: 02-May-91 BartoszM Created.
//
//----------------------------------------------------------------------------
void CIndexTable::AddRecord( CWriteIndexFile & indFile,
INDEXID iid,
ULONG type,
WORKID maxWorkId,
WORKID objectId )
{
ciDebugOut (( DEB_ITRACE, "Indexes: AddRecord %lx, %ld %s\n",
iid, maxWorkId, (type == itMaster)? "master": "not-master" ));
CAddReplaceIndexRecord rec(indFile, CIndexId(iidInvalid,partidInvalid) );
rec.SetIid(iid);
rec.SetType(type);
rec.SetWid(maxWorkId);
rec.SetObjectId ( objectId );
rec.WriteRecord();
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTable::AddIndex, public
//
// Synopsis: Adds new index to table
//
// Arguments: [iid] -- index id
// [type] -- type of record
// [maxWorkId] -- max work id in the index
// [objectId] -- id of the index object
//
// Notes: ResMan LOCKED
//
// History: 14-Jul-94 DwightKr Created.
//
//----------------------------------------------------------------------------
void CIndexTable::AddIndex( INDEXID iid,
IndexType type,
WORKID maxWorkId,
WORKID objectId )
{
CWriteIndexFile indFile( GetIndexTableObj() );
AddRecord( indFile, iid, type, maxWorkId, objectId );
indFile.Commit();
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTable::LokEmpty, public
//
// Synopsis: Deleted everything from the index table
//
// Notes: ResMan LOCKED
//
// History: 16-Aug-94 DwightKr Created
//
//----------------------------------------------------------------------------
void CIndexTable::LokEmpty()
{
PRcovStorageObj & rcovObj = GetIndexTableObj();
CRcovStrmWriteTrans xact( rcovObj );
rcovObj.GetHeader().SetCount( rcovObj.GetHeader().GetBackup(), 0 );
xact.Empty();
xact.Seek(0);
xact.Commit();
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTable::LokMakeBackupCopy
//
// Synopsis: Makes a backup copy of the index table.
//
// Arguments: [storage] - Storage to use for creation of the
// destination index table.
// [fFullSave] - Set to TRUE if a full save is being performed.
// [progressTracker] - Progress tracker.
//
// History: 3-18-97 srikants Created
//
//----------------------------------------------------------------------------
void CIndexTable::LokMakeBackupCopy( PStorage & storage,
BOOL fFullSave,
PSaveProgressTracker & progressTracker )
{
//
// Create a new index table object using the storage provided.
//
PRcovStorageObj * pDstObj = storage.QueryIdxTableObject();
XPtr<PRcovStorageObj> xDstObj( pDstObj );
PRcovStorageObj & srcObj = GetIndexTableObj();
//
// Copy the contents of source to destination.
//
CCopyRcovObject copier( *pDstObj, srcObj );
NTSTATUS status = copier.DoIt();
if ( STATUS_SUCCESS != status )
{
THROW(CException(status) );
}
//
// Set the Full/Partial Save bit appropriately.
//
CRcovStrmAppendTrans xact( *pDstObj );
CRcovStorageHdr & storageHdr = pDstObj->GetHeader();
CRcovUserHdr usrHdr;
CIndexTableUsrHdr * pIdxUsrHdr = (CIndexTableUsrHdr *) &usrHdr;
storageHdr.GetUserHdr( storageHdr.GetBackup(), usrHdr );
if ( fFullSave )
pIdxUsrHdr->SetFullSave();
else pIdxUsrHdr->ClearFullSave();
storageHdr.SetUserHdr( storageHdr.GetBackup(), usrHdr );
xact.Commit();
}
//+---------------------------------------------------------------------------
//
// Member: CIndexTable::GetUserHdrInfo
//
// Synopsis: Retrieves the information in the user header.
//
// Arguments: [mMergeSeqNum] - Master Merge sequence number.
// [fFullSave] - Set to TRUE if a full save was performed.
//
// History: 3-21-97 srikants Created
//
//----------------------------------------------------------------------------
void CIndexTable::GetUserHdrInfo( unsigned & mMergeSeqNum, BOOL & fFullSave )
{
PRcovStorageObj & obj = GetIndexTableObj();
CRcovUserHdr usrHdr;
CIndexTableUsrHdr * pIdxUsrHdr = (CIndexTableUsrHdr *) &usrHdr;
CRcovStorageHdr & storageHdr = obj.GetHeader();
storageHdr.GetUserHdr( storageHdr.GetPrimary(), usrHdr );
ciDebugOut(( DEB_ERROR, "Current MMerge Seq Num = %d \n",
pIdxUsrHdr->GetMMergeSeqNum() ));
mMergeSeqNum = pIdxUsrHdr->GetMMergeSeqNum();
fFullSave = pIdxUsrHdr->IsFullSave();
}