Database Class Reference

Database defines the top-level database object, which is the unit of self-contained storage and recovery. More...

#include <Database.h>

Inheritance diagram for Database:

List of all members.

Public Member Functions
virtual	~Database ()
const ConfigMap &	getConfigMap () const
SharedCache	getCache () const
SharedSegmentFactory	getSegmentFactory () const
SharedSegment	getDataSegment () const
SharedSegment	getTempSegment () const
SharedCheckpointThread	getCheckpointThread () const
virtual SharedSegment	getSegmentById (SegmentId segmentId, SharedSegment pDataSegment)
	Finds a segment by its SegmentId.
virtual void	writeStats (StatsTarget &target)
	Writes a current stats snapshot to a StatsTarget.
SharedLogicalTxnLog	getTxnLog () const
StoredTypeDescriptorFactory const &	getTypeFactory () const
bool	isRecoveryRequired () const
bool	shouldForceTxns () const
bool	areSnapshotsEnabled () const
void	recoverOnline ()
void	recover (LogicalTxnParticipantFactory &txnParticipantFactory)
void	checkpointImpl (CheckpointType=CHECKPOINT_FLUSH_ALL)
void	requestCheckpoint (CheckpointType checkpointType, bool async)
	Receives request for a checkpoint.
void	deallocateOldPages (TxnId oldestLabelCsn)
	Deallocates old snapshot pages that are no longer referenced by any active transactions, as well as active labels marking snapshots in time.
void	setLastCommittedTxnId (TxnId txnId)
	Saves the id of the last committed transaction.
TxnId	getLastCommittedTxnId ()
	Returns: the id of the last committed, write transaction
TxnId	initiateBackup (const std::string &backupFilePathname, bool checkSpaceRequirements, FileSize spacePadding, TxnId lowerBoundCsn, const std::string &compressionProgram, FileSize &dataDeviceSize, const volatile bool &aborted)
	Initiates a backup of the data segment.
void	completeBackup (TxnId lowerBoundCsn, TxnId upperBoundCsn, const volatile bool &aborted)
	Completes the remainder of a backup by backing up the data pages that have allocationCsn's in between two specified bounds.
void	abortBackup ()
	Aborts a backup that may or may not have been previously initiated.
void	restoreFromBackup (const std::string &backupFilePathname, FileSize newSize, const std::string &compressionProgram, TxnId lowerBoundCsn, TxnId upperBoundCsn, const volatile bool &aborted)
	Restores the data segment from a backup file.
bool	isClosed () const
	Returns: whether the object has been closed
void	close ()
	Closes this object, releasing any unallocated resources.
virtual void	initTraceSource (SharedTraceTarget pTraceTarget, std::string name)
	For use when initialization has to be deferred until after construction.
void	trace (TraceLevel level, std::string message) const
	Records a trace message.
bool	isTracing () const
	Returns: true iff tracing is enabled for this source
bool	isTracingLevel (TraceLevel level) const
	Determines whether a particular level is being traced.
TraceTarget &	getTraceTarget () const
	Returns: the TraceTarget for this source
SharedTraceTarget	getSharedTraceTarget () const
	Returns: the SharedTraceTarget for this source
std::string	getTraceSourceName () const
	Gets the name of this source.
void	setTraceSourceName (std::string const &n)
	Sets the name of this source.
TraceLevel	getMinimumTraceLevel () const
void	disableTracing ()
Static Public Member Functions
static SharedDatabase	newDatabase (SharedCache pCache, ConfigMap const &configMap, DeviceMode openMode, SharedTraceTarget pTraceTarget, SharedPseudoUuidGenerator pUuidGenerator=SharedPseudoUuidGenerator())
Static Public Attributes
static ParamName	paramDatabaseDir
static ParamName	paramResourceDir
static ParamName	paramForceTxns
static ParamName	paramDisableSnapshots
static ParamName	paramDatabasePrefix
static ParamName	paramTempPrefix
static ParamName	paramShadowLogPrefix
static ParamName	paramTxnLogPrefix
static ParamName	paramInitSizeSuffix
static ParamName	paramMaxSizeSuffix
static ParamName	paramIncSizeSuffix
static ParamVal	valLogAllocLinear
static ParamVal	valLogAllocCircular
static const SegmentId	DEFAULT_DATA_SEGMENT_ID
static const SegmentId	TEMP_SEGMENT_ID
Protected Attributes
bool	needsClose
StrictMutex	mutex
LocalCondition	condition
Private Member Functions
	Database (SharedCache pCache, ConfigMap const &configMap, DeviceMode openMode, SharedTraceTarget pTraceTarget, SharedPseudoUuidGenerator pUuidGenerator)
virtual void	closeImpl ()
	Must be implemented by derived class to release any resources.
void	init ()
void	createTxnLog (DeviceMode)
SharedSegment	createTxnLogSegment (DeviceMode, PageId)
SharedSegment	createShadowLog (DeviceMode)
void	createDataDevice (LinearDeviceSegmentParams &)
void	createDataSegment (SharedSegment, LinearDeviceSegmentParams &)
void	createTempSegment ()
void	allocateHeader ()
void	writeHeader ()
void	loadHeader (bool)
void	closeDevices ()
void	deleteLogs ()
void	openSegments ()
void	prepareForRecovery ()
void	recoverPhysical (CheckpointType)
void	readDeviceParams (std::string paramNamePrefix, DeviceMode deviceMode, LinearDeviceSegmentParams &deviceParams)
void	cleanupBackupRestore (bool isBackup)
Private Attributes
DeviceId	dataDeviceId
SharedRandomAccessDevice	pDataDevice
DeviceId	tempDeviceId
DeviceId	shadowDeviceId
DeviceId	txnLogDeviceId
std::string	dataDeviceName
std::string	tempDeviceName
std::string	shadowDeviceName
std::string	txnLogDeviceName
SharedCache	pCache
SharedSegmentFactory	pSegmentFactory
SharedSegment	pHeaderSegment
SharedSegment	pDataSegment
SharedSegment	pTempSegment
VersionedSegment *	pVersionedSegment
SharedLogicalTxnLog	pTxnLog
PageId	headerPageId1
PageId	headerPageId2
DatabaseHeader	header
LogicalTxnParticipantFactory *	pTxnParticipantFactory
bool	forceTxns
bool	disableSnapshots
bool	recoveryRequired
DeviceMode	openMode
ConfigMap	configMap
StandardTypeDescriptorFactory	typeFactory
SharedCheckpointThread	pCheckpointThread
SharedPseudoUuidGenerator	pUuidGenerator
uint	nCheckpointsStat
	Cumulative counter cleared whenever writeStats is called.
uint	nCheckpoints
	Cumulative counter.
bool	disableDeallocateOld
	If true, ALTER SYSTEM DEALLOCATE OLD is a no-op.
SharedSegPageBackupRestoreDevice	pBackupRestoreDevice
	Device used to read and write the backup file during backup and restore.
SegmentAccessor	scratchAccessor
	Scratch accessor used during backup and restore.

---

Detailed Description

Database defines the top-level database object, which is the unit of self-contained storage and recovery.

Definition at line 49 of file Database.h.

---

Constructor & Destructor Documentation

Database::Database	(	SharedCache	pCache,
		ConfigMap const &	configMap,
		DeviceMode	openMode,
		SharedTraceTarget	pTraceTarget,
		SharedPseudoUuidGenerator	pUuidGenerator
	)			[explicit, private]

Definition at line 96 of file Database.cpp.

References disableDeallocateOld, and openMode.

Referenced by newDatabase().

    : TraceSource(pTraceTarget,"database"),
      pCache(pCacheInit),
      configMap(configMapInit),
      pUuidGenerator(pUuidGeneratorInit)
{
    openMode = openModeInit;
    disableDeallocateOld = false;
}

Database::~Database

(

)

[virtual]

Definition at line 242 of file Database.cpp.

{
}

---

Member Function Documentation

void Database::closeImpl

(

)

[private, virtual]

Must be implemented by derived class to release any resources.

Implements ClosableObject.

Definition at line 246 of file Database.cpp.

References areSnapshotsEnabled(), checkpointImpl(), closeDevices(), deleteLogs(), VersionedRandomAllocationSegment::freeTempPages(), header, isRecoveryRequired(), pCheckpointThread, pDataSegment, pTempSegment, pTxnLog, TRACE_INFO, and DatabaseHeader::versionNumber.

{
    FENNEL_TRACE(
        TRACE_INFO,
        "closing database");
    if (pCheckpointThread) {
        pCheckpointThread->close();
    }

    // Free any leftover temp pages used for page versioning
    if (pDataSegment && areSnapshotsEnabled()) {
        VersionedRandomAllocationSegment *pVersionedRandomSegment =
            SegmentFactory::dynamicCast<VersionedRandomAllocationSegment *>(
                pDataSegment);
        pVersionedRandomSegment->freeTempPages();
    }

    // Verify that no garbage temp pages remain allocated.
    if (pTempSegment) {
        assert(pTempSegment->getAllocatedSizeInPages() == 0);
    }

    if (isRecoveryRequired()) {
        closeDevices();
    } else {
        // NOTE jvs 14-Nov-2006:  In case we're auto-closing after
        // a failed startup, skip checkpoint if we don't have
        // everything we need for it.
        if (pTxnLog && pDataSegment) {
            checkpointImpl();
        }
        closeDevices();
        deleteLogs();
    }
    FENNEL_TRACE(
        TRACE_INFO,
        "database closed; page version = "
        << header.versionNumber);
}

void Database::init

(

)

[private]

Definition at line 111 of file Database.cpp.

References configMap, DeviceMode::create, dataDeviceId, dataDeviceName, disableSnapshots, FileSystem::doesFileExist(), forceTxns, ConfigMap::getBoolParam(), Segment::getLinearPageId(), TraceSource::getSharedTraceTarget(), ConfigMap::getStringParam(), header, headerPageId1, headerPageId2, DatabaseHeader::MAGIC_NUMBER, StoredNode::magicNumber, nCheckpoints, nCheckpointsStat, SegmentFactory::newSegmentFactory(), openMode, openSegments(), paramDatabaseDir, paramDisableSnapshots, paramForceTxns, paramResourceDir, prepareForRecovery(), pSegmentFactory, recoveryRequired, shadowDeviceId, shadowDeviceName, tempDeviceId, tempDeviceName, txnLogDeviceId, txnLogDeviceName, and DatabaseHeader::versionNumber.

{
    forceTxns = configMap.getBoolParam(paramForceTxns);
    disableSnapshots = configMap.getBoolParam(paramDisableSnapshots);

    // NOTE:  do this early in case other initialization throws exceptions
    // (and to prevent thread-safety issues later on)
    std::string resourceDir = configMap.getStringParam(paramResourceDir);
    if (resourceDir == "") {
        // If we weren't told explicitly where to find resources, make sure
        // we can rely on an environment variable setting.  TODO:
        // instead of pre-checking this, get information back from
        // FennelResource to tell us whether it was successfully initialized.
        assert(getenv("FENNEL_HOME"));
    } else {
        FennelResource::setResourceFileLocation(resourceDir);
    }
    FennelResource::instance();

    dataDeviceId = DeviceId(1);
    shadowDeviceId = DeviceId(2);
    txnLogDeviceId = DeviceId(3);
    tempDeviceId = DeviceId(4);

    headerPageId1 = Segment::getLinearPageId(0);
    headerPageId2 = Segment::getLinearPageId(1);

    header.versionNumber = SegVersionNum(0);
    recoveryRequired = false;

    // REVIEW:  Have to do this so that later assignments from header to stored
    // data work correctly.  But it breaks encapsulation.  Find a better way.
    header.magicNumber = DatabaseHeader::MAGIC_NUMBER;

    // TODO:  use boost filesystem library for platform-independent path
    // manipulation
    std::string databaseDir = configMap.getStringParam(paramDatabaseDir);
    // TODO:  real excn
    assert(databaseDir != "");

    dataDeviceName = databaseDir + "/db.dat";
    shadowDeviceName = databaseDir + "/shadowlog.dat";
    txnLogDeviceName = databaseDir + "/txnlog.dat";
    tempDeviceName = databaseDir + "/temp.dat";

    nCheckpoints = nCheckpointsStat = 0;

    pSegmentFactory = SegmentFactory::newSegmentFactory(
        configMap,getSharedTraceTarget());

    if (!openMode.create) {
        // TODO:  real excn
        assert(FileSystem::doesFileExist(dataDeviceName.c_str()));
        if (FileSystem::doesFileExist(shadowDeviceName.c_str())) {
            prepareForRecovery();
            return;
        }
    }

    openSegments();
}

void Database::createTxnLog

(

DeviceMode

)

[private]

Definition at line 382 of file Database.cpp.

References createTxnLogSegment(), header, LogicalTxnLog::newLogicalTxnLog(), NULL_PAGE_ID, DatabaseHeader::onlineUuid, pCache, pSegmentFactory, pTxnLog, and DatabaseHeader::txnLogCheckpointMemento.

Referenced by openSegments().

{
    SharedSegment pTxnLogSegment = createTxnLogSegment(
        txnLogMode,NULL_PAGE_ID);
    SegmentAccessor segmentAccessor(pTxnLogSegment,pCache);
    pTxnLog = LogicalTxnLog::newLogicalTxnLog(
        segmentAccessor,
        header.onlineUuid,
        pSegmentFactory);
    pTxnLog->checkpoint(header.txnLogCheckpointMemento);
}

SharedSegment Database::createTxnLogSegment	(	DeviceMode	,
		PageId
	)			[private]

Definition at line 347 of file Database.cpp.

References LinearDeviceSegmentParams::firstBlockId, forceTxns, MAXU, LinearDeviceSegmentParams::nPagesAllocated, LinearDeviceSegmentParams::nPagesIncrement, LinearDeviceSegmentParams::nPagesMax, LinearDeviceSegmentParams::nPagesMin, paramTxnLogPrefix, pCache, pCheckpointThread, pSegmentFactory, readDeviceParams(), CompoundId::setBlockNum(), CompoundId::setDeviceId(), txnLogDeviceId, and txnLogDeviceName.

Referenced by createTxnLog(), and recover().

{
    SharedRandomAccessDevice pTxnLogDevice(
        new RandomAccessFileDevice(txnLogDeviceName,txnLogMode));
    pCache->registerDevice(txnLogDeviceId,pTxnLogDevice);

    LinearDeviceSegmentParams deviceParams;
    readDeviceParams(paramTxnLogPrefix,txnLogMode,deviceParams);
    CompoundId::setDeviceId(deviceParams.firstBlockId,txnLogDeviceId);
    CompoundId::setBlockNum(deviceParams.firstBlockId,0);
    if (forceTxns) {
        deviceParams.nPagesAllocated = 0;
    } else {
        deviceParams.nPagesAllocated = MAXU;
        deviceParams.nPagesIncrement = 0;
        deviceParams.nPagesMax = deviceParams.nPagesMin;
    }

    SharedSegment pLinearSegment =
        pSegmentFactory->newLinearDeviceSegment(
            pCache,
            deviceParams);

    SharedSegment pTxnLogSegment;
    if (forceTxns) {
        pTxnLogSegment = pLinearSegment;
    } else {
        pTxnLogSegment = pSegmentFactory->newCircularSegment(
            pLinearSegment,pCheckpointThread,oldestPageId);
    }

    return pTxnLogSegment;
}

SharedSegment Database::createShadowLog

(

DeviceMode

)

[private]

Definition at line 394 of file Database.cpp.

References DeviceMode::create, LinearDeviceSegmentParams::firstBlockId, forceTxns, header, MAXU, LinearDeviceSegmentParams::nPagesAllocated, LinearDeviceSegmentParams::nPagesIncrement, LinearDeviceSegmentParams::nPagesMax, LinearDeviceSegmentParams::nPagesMin, NULL_PAGE_ID, paramShadowLogPrefix, pCache, pCheckpointThread, pSegmentFactory, readDeviceParams(), CompoundId::setBlockNum(), CompoundId::setDeviceId(), shadowDeviceId, shadowDeviceName, and DatabaseHeader::shadowRecoveryPageId.

Referenced by openSegments(), and prepareForRecovery().

{
    SharedRandomAccessDevice pShadowDevice(
        new RandomAccessFileDevice(shadowDeviceName,shadowLogMode));
    pCache->registerDevice(shadowDeviceId,pShadowDevice);

    LinearDeviceSegmentParams deviceParams;
    readDeviceParams(paramShadowLogPrefix,shadowLogMode,deviceParams);
    CompoundId::setDeviceId(deviceParams.firstBlockId,shadowDeviceId);
    CompoundId::setBlockNum(deviceParams.firstBlockId,0);

    if (forceTxns) {
        if (shadowLogMode.create) {
            // start allocating from beginning of device
            deviceParams.nPagesAllocated = 0;
        } else {
            // treat entire device as pre-allocated because we're
            // going to scan it during recovery
            deviceParams.nPagesAllocated = MAXU;
        }
    } else {
        deviceParams.nPagesAllocated = MAXU;
        deviceParams.nPagesIncrement = 0;
        deviceParams.nPagesMax = deviceParams.nPagesMin;
    }

    SharedSegment pShadowSegment =
        pSegmentFactory->newLinearDeviceSegment(
            pCache,
            deviceParams);

    PageId oldestPageId = NULL_PAGE_ID;
    if (!shadowLogMode.create) {
        oldestPageId = header.shadowRecoveryPageId;
    }

    if (!forceTxns) {
        pShadowSegment = pSegmentFactory->newCircularSegment(
            pShadowSegment,
            pCheckpointThread,
            oldestPageId);
    }

    return pSegmentFactory->newWALSegment(pShadowSegment);
}

void Database::createDataDevice

(

LinearDeviceSegmentParams &

)

[private]

Definition at line 440 of file Database.cpp.

References dataDeviceId, dataDeviceName, LinearDeviceSegmentParams::nPagesMin, openMode, paramDatabasePrefix, pCache, pDataDevice, readDeviceParams(), and shouldForceTxns().

Referenced by openSegments(), and prepareForRecovery().

{
    readDeviceParams(paramDatabasePrefix,openMode,deviceParams);

    FileSize initialSize = FileSize(0);
    if (shouldForceTxns()) {
        // include +2 for the database header pages
        initialSize = (deviceParams.nPagesMin + 2) * pCache->getPageSize();
    }

    pDataDevice =
        SharedRandomAccessDevice(
            new RandomAccessFileDevice(
                dataDeviceName,
                openMode,
                initialSize));
    pCache->registerDevice(dataDeviceId,pDataDevice);
}

void Database::createDataSegment	(	SharedSegment	,
		LinearDeviceSegmentParams &
	)			[private]

Definition at line 459 of file Database.cpp.

References areSnapshotsEnabled(), DeviceMode::create, dataDeviceId, LinearDeviceSegmentParams::firstBlockId, header, MAXU, LinearDeviceSegmentParams::nPagesAllocated, DatabaseHeader::onlineUuid, openMode, pCache, pDataSegment, pSegmentFactory, pTempSegment, pVersionedSegment, recoveryRequired, CompoundId::setBlockNum(), CompoundId::setDeviceId(), and DatabaseHeader::versionNumber.

Referenced by openSegments(), and prepareForRecovery().

{
    // first data BlockId is located after the two database header pages
    CompoundId::setDeviceId(deviceParams.firstBlockId,dataDeviceId);
    CompoundId::setBlockNum(deviceParams.firstBlockId,2);

    deviceParams.nPagesAllocated = MAXU;

    SharedSegment pDataDeviceSegment =
        pSegmentFactory->newLinearDeviceSegment(
            pCache,
            deviceParams);

    SharedSegment pVersionedDataSegment =
        pSegmentFactory->newVersionedSegment(
            pDataDeviceSegment,
            pShadowLogSegment,
            header.onlineUuid,
            header.versionNumber + (recoveryRequired ? 0 : 1));

    pVersionedSegment = SegmentFactory::dynamicCast<VersionedSegment *>(
        pVersionedDataSegment);

    // If recovery is required, defer initializing the data segment for use
    // until after recovery has completed.
    if (areSnapshotsEnabled()) {
        pDataSegment =
            pSegmentFactory->newVersionedRandomAllocationSegment(
                pVersionedDataSegment,
                pTempSegment,
                openMode.create,
                recoveryRequired);
    } else {
        pDataSegment =
            pSegmentFactory->newRandomAllocationSegment(
                pVersionedDataSegment,
                openMode.create,
                recoveryRequired);
    }
}

void Database::createTempSegment

(

)

[private]

Definition at line 502 of file Database.cpp.

References DeviceMode::create, FileSystem::doesFileExist(), openMode, paramTempPrefix, pCache, pSegmentFactory, pTempSegment, readDeviceParams(), CompoundId::setBlockNum(), CompoundId::setDeviceId(), shouldForceTxns(), tempDeviceId, and tempDeviceName.

Referenced by openSegments(), and prepareForRecovery().

{
    // If the temp device file already exists, use it; otherwise, create it.
    // There's no point in recreating it on every startup.  But REVIEW:  sizing
    // issues.
    DeviceMode tempMode = openMode;
    tempMode.create = !FileSystem::doesFileExist(tempDeviceName.c_str());

    LinearDeviceSegmentParams deviceParams;
    readDeviceParams(paramTempPrefix,tempMode,deviceParams);
    FileSize initialSize = FileSize(0);
    if (shouldForceTxns()) {
        initialSize = deviceParams.nPagesMin * pCache->getPageSize();
    }

    SharedRandomAccessDevice pTempDevice(
        new RandomAccessFileDevice(tempDeviceName,tempMode,initialSize));
    pCache->registerDevice(tempDeviceId,pTempDevice);

    // This forces the full device size to be used.
    tempMode.create = false;

    // no header for temp device
    CompoundId::setDeviceId(deviceParams.firstBlockId,tempDeviceId);
    CompoundId::setBlockNum(deviceParams.firstBlockId,0);

    SharedSegment pTempDeviceSegment =
        pSegmentFactory->newLinearDeviceSegment(
            pCache,
            deviceParams);

    // Reformat any existing temp data.
    pTempSegment =
        pSegmentFactory->newRandomAllocationSegment(
            pTempDeviceSegment,
            true);
}

void Database::allocateHeader

(

)

[private]

Definition at line 591 of file Database.cpp.

References SegNodeLock< Node >::allocatePage(), dataDeviceId, FIRST_TXN_ID, LinearDeviceSegmentParams::firstBlockId, SegNodeLock< Node >::getNodeForWrite(), header, headerPageId1, headerPageId2, pCache, pHeaderSegment, pSegmentFactory, pTxnLog, CompoundId::setBlockNum(), CompoundId::setDeviceId(), and SegPageLock::unlock().

Referenced by openSegments().

{
    LinearDeviceSegmentParams deviceParams;
    CompoundId::setDeviceId(deviceParams.firstBlockId,dataDeviceId);
    CompoundId::setBlockNum(deviceParams.firstBlockId,0);
    pHeaderSegment =
        pSegmentFactory->newLinearDeviceSegment(
            pCache,
            deviceParams);

    SegmentAccessor segmentAccessor(pHeaderSegment,pCache);
    DatabaseHeaderPageLock headerPageLock(segmentAccessor);

    PageId pageId;
    pTxnLog->setNextTxnId(FIRST_TXN_ID);
    pageId = headerPageLock.allocatePage();
    assert(pageId == headerPageId1);
    headerPageLock.getNodeForWrite() = header;
    pageId = headerPageLock.allocatePage();
    assert(pageId == headerPageId2);
    headerPageLock.getNodeForWrite() = header;
    headerPageLock.unlock();
    pHeaderSegment->checkpoint();
}

void Database::writeHeader

(

)

[private]

Definition at line 741 of file Database.cpp.

References SegNodeLock< Node >::getNodeForWrite(), SegPageLock::getPage(), header, headerPageId1, headerPageId2, SegPageLock::lockExclusive(), pCache, and pHeaderSegment.

Referenced by checkpointImpl(), prepareForRecovery(), and recoverPhysical().

{
    // TODO:  crc

    // NOTE:  use synchronous writes to guarantee that first write completes
    // before second one starts (otherwise a crash could leave both copies
    // corrupted)

    SegmentAccessor segmentAccessor(pHeaderSegment,pCache);
    DatabaseHeaderPageLock headerPageLock(segmentAccessor);

    headerPageLock.lockExclusive(headerPageId1);
    headerPageLock.getNodeForWrite() = header;
    pCache->flushPage(headerPageLock.getPage(),false);

    headerPageLock.lockExclusive(headerPageId2);
    headerPageLock.getNodeForWrite() = header;
    pCache->flushPage(headerPageLock.getPage(),false);
}

void Database::loadHeader

(

bool

)

[private]

Definition at line 616 of file Database.cpp.

References SegNodeLock< Node >::checkMagicNumber(), dataDeviceId, LinearDeviceSegmentParams::firstBlockId, SegNodeLock< Node >::getNodeForRead(), header, headerPageId1, headerPageId2, SegPageLock::lockShared(), LogicalTxnLogCheckpointMemento::nextTxnId, LinearDeviceSegmentParams::nPagesAllocated, LinearDeviceSegmentParams::nPagesMax, pCache, pHeaderSegment, pSegmentFactory, pTxnLog, CompoundId::setBlockNum(), CompoundId::setDeviceId(), DatabaseHeader::txnLogCheckpointMemento, and DatabaseHeader::versionNumber.

Referenced by openSegments(), prepareForRecovery(), and restoreFromBackup().

{
    LinearDeviceSegmentParams deviceParams;
    CompoundId::setDeviceId(deviceParams.firstBlockId,dataDeviceId);
    CompoundId::setBlockNum(deviceParams.firstBlockId,0);
    deviceParams.nPagesAllocated = 2;
    deviceParams.nPagesMax = 2;
    pHeaderSegment =
        pSegmentFactory->newLinearDeviceSegment(
            pCache,
            deviceParams);

    SegmentAccessor segmentAccessor(pHeaderSegment,pCache);
    DatabaseHeaderPageLock headerPageLock1(segmentAccessor);
    headerPageLock1.lockShared(headerPageId1);
    if (!headerPageLock1.checkMagicNumber()) {
        throw DataFormatExcn();
    }

    DatabaseHeaderPageLock headerPageLock2(segmentAccessor);
    headerPageLock2.lockShared(headerPageId2);
    if (!headerPageLock2.checkMagicNumber()) {
        throw DataFormatExcn();
    }

    DatabaseHeader const &header1 = headerPageLock1.getNodeForRead();
    DatabaseHeader const &header2 = headerPageLock2.getNodeForRead();
    if (recovery) {
        // TODO:  crc
        if (header2.versionNumber < header1.versionNumber) {
            header = header2;
        } else {
            header = header1;
        }
    } else {
        assert(header1.versionNumber == header2.versionNumber);
        // REVIEW:  should assert other fields equal as well?
        header = header1;
    }
    if (pTxnLog) {
        TxnId nextTxnId = header.txnLogCheckpointMemento.nextTxnId;
        pTxnLog->setNextTxnId(nextTxnId);
    }
}

void Database::closeDevices

(

)

[private]

Definition at line 286 of file Database.cpp.

References dataDeviceId, pCache, pDataSegment, pHeaderSegment, pTempSegment, pTxnLog, pVersionedSegment, shadowDeviceId, tempDeviceId, and txnLogDeviceId.

Referenced by closeImpl(), and recover().

{
    pVersionedSegment = NULL;
    pTxnLog.reset();
    // REVIEW: have to explicitly close in case someone (like a recovery
    // factory) else still has a segment reference; should probably find a
    // better way to deal with this
    if (pDataSegment) {
        pDataSegment->close();
        pDataSegment.reset();
    }
    pHeaderSegment.reset();
    if (pTempSegment) {
        pTempSegment->close();
        pTempSegment.reset();
    }

    // for incomplete recovery or startup, these devices may not have been
    // opened yet
    if (pCache) {
        if (pCache->getDevice(txnLogDeviceId)) {
            pCache->unregisterDevice(txnLogDeviceId);
        }
        if (pCache->getDevice(shadowDeviceId)) {
            pCache->unregisterDevice(shadowDeviceId);
        }
        if (pCache->getDevice(dataDeviceId)) {
            pCache->unregisterDevice(dataDeviceId);
        }
        if (pCache->getDevice(tempDeviceId)) {
            pCache->unregisterDevice(tempDeviceId);
        }
    }
}

void Database::deleteLogs

(

)

[private]

Definition at line 321 of file Database.cpp.

References FileSystem::remove(), shadowDeviceName, and txnLogDeviceName.

Referenced by closeImpl(), and recover().

{
    FileSystem::remove(shadowDeviceName.c_str());
    FileSystem::remove(txnLogDeviceName.c_str());

    // TODO jvs 25-June-2005:  here and in LogicalRecoveryLog, we should
    // be using ConfigMap to determine where to store txn logs
    // instead of current_path()
    directory_iterator end_itr;
    for (directory_iterator itr(current_path()); itr != end_itr; ++itr) {
        std::string filename = itr->path().filename();
        // TODO jvs 25-June-2005:  encapsulate filename parsing in
        // LogicalRecoveryLog
        if (filename.length() < 4) {
            continue;
        }
        if (filename.substr(0, 3) != "txn") {
            continue;
        }
        if (filename.substr(filename.length() - 4, 4) != ".dat") {
            continue;
        }
        FileSystem::remove(filename.c_str());
    }
}

void Database::openSegments

(

)

[private]

Definition at line 186 of file Database.cpp.

References allocateHeader(), checkpointImpl(), DeviceMode::create, createDataDevice(), createDataSegment(), createShadowLog(), createTempSegment(), createTxnLog(), DeviceMode::direct, header, loadHeader(), DatabaseHeader::onlineUuid, openMode, pCheckpointThread, pUuidGenerator, TRACE_INFO, and DatabaseHeader::versionNumber.

Referenced by init(), and recover().

{
#ifdef NDEBUG
    FENNEL_TRACE(TRACE_INFO, "Fennel build:  --with-optimization");
#else
    FENNEL_TRACE(TRACE_INFO, "Fennel build:  --without-optimization");
#endif
    FENNEL_TRACE(TRACE_INFO, "opening database; process ID = " << getpid());

    pCheckpointThread = SharedCheckpointThread(
        new CheckpointThread(*this),
        ClosableObjectDestructor());

    createTempSegment();

    pUuidGenerator->generateUuid(header.onlineUuid);
    FENNEL_TRACE(TRACE_INFO, "online UUID = " << header.onlineUuid);

    DeviceMode txnLogMode = openMode;
    txnLogMode.create = true;
    txnLogMode.direct = true;
    createTxnLog(txnLogMode);

    LinearDeviceSegmentParams dataDeviceParams;
    createDataDevice(dataDeviceParams);

    if (openMode.create) {
        // online UUID will be written out by allocateHeader
        allocateHeader();
    } else {
        PseudoUuid newOnlineUuid = header.onlineUuid;
        loadHeader(false);
        // overwrite old online UUID; new one will be written out
        // by checkpoint below
        header.onlineUuid = newOnlineUuid;
    }

    DeviceMode shadowMode = openMode;
    shadowMode.create = true;
    shadowMode.direct = true;

    SharedSegment pShadowLogSegment = createShadowLog(shadowMode);
    createDataSegment(pShadowLogSegment, dataDeviceParams);

    FENNEL_TRACE(
        TRACE_INFO,
        "database opened; page version = "
        << header.versionNumber);

    if (!openMode.create) {
        checkpointImpl();
    }

    pCheckpointThread->start();
}

void Database::prepareForRecovery

(

)

[private]

Definition at line 173 of file Database.cpp.

References createDataDevice(), createDataSegment(), createShadowLog(), createTempSegment(), loadHeader(), openMode, recoveryRequired, TRACE_WARNING, and writeHeader().

Referenced by init().

{
    FENNEL_TRACE(TRACE_WARNING, "recovery required");
    recoveryRequired = true;
    createTempSegment();
    LinearDeviceSegmentParams dataDeviceParams;
    createDataDevice(dataDeviceParams);
    loadHeader(true);
    writeHeader();
    SharedSegment pShadowLogSegment = createShadowLog(openMode);
    createDataSegment(pShadowLogSegment,dataDeviceParams);
}

void Database::recoverPhysical

(

CheckpointType

)

[private]

Definition at line 819 of file Database.cpp.

References CHECKPOINT_FLUSH_AND_UNMAP, DeviceMode::create, VersionedSegment::deallocateCheckpointedLog(), VersionedSegment::getVersionNumber(), header, isRecoveryRequired(), NULL_PAGE_ID, openMode, pDataSegment, pVersionedSegment, VersionedSegment::recover(), recoveryRequired, DatabaseHeader::shadowRecoveryPageId, TRACE_INFO, DatabaseHeader::versionNumber, and writeHeader().

Referenced by recover(), and recoverOnline().

{
    assert(!openMode.create);
    assert(isRecoveryRequired());
    recoveryRequired = false;

    FENNEL_TRACE(
        TRACE_INFO,
        "recovery beginning; page version = "
        << header.versionNumber);

    if (header.shadowRecoveryPageId != NULL_PAGE_ID) {
        pVersionedSegment->recover(
            pDataSegment,
            header.shadowRecoveryPageId,
            header.versionNumber);
        pDataSegment->checkpoint(checkpointType);
        header.versionNumber = pVersionedSegment->getVersionNumber();
        header.shadowRecoveryPageId = NULL_PAGE_ID;
        writeHeader();
        pVersionedSegment->deallocateCheckpointedLog(
            CHECKPOINT_FLUSH_AND_UNMAP);
    }
}

void Database::readDeviceParams	(	std::string	paramNamePrefix,
		DeviceMode	deviceMode,
		LinearDeviceSegmentParams &	deviceParams
	)			[private]

Definition at line 849 of file Database.cpp.

References configMap, DeviceMode::create, ConfigMap::getIntParam(), ConfigMap::isParamSet(), MAXU, LinearDeviceSegmentParams::nPagesAllocated, LinearDeviceSegmentParams::nPagesIncrement, LinearDeviceSegmentParams::nPagesMax, LinearDeviceSegmentParams::nPagesMin, paramIncSizeSuffix, paramInitSizeSuffix, and paramMaxSizeSuffix.

Referenced by createDataDevice(), createShadowLog(), createTempSegment(), and createTxnLogSegment().

{
    deviceParams.nPagesMin = configMap.getIntParam(
        paramNamePrefix + paramInitSizeSuffix);
    if (configMap.isParamSet(paramNamePrefix + paramIncSizeSuffix)) {
        deviceParams.nPagesIncrement = configMap.getIntParam(
            paramNamePrefix + paramIncSizeSuffix);
    }
    deviceParams.nPagesMax = configMap.getIntParam(
        paramNamePrefix + paramMaxSizeSuffix);
    if (!deviceParams.nPagesMax) {
        deviceParams.nPagesMax = MAXU;
    }
    if (deviceMode.create) {
        deviceParams.nPagesAllocated = 0;
    } else {
        deviceParams.nPagesAllocated = MAXU;
    }
}

void Database::cleanupBackupRestore

(

bool

isBackup

)

[private]

Definition at line 1233 of file Database.cpp.

References disableDeallocateOld, pBackupRestoreDevice, pCheckpointThread, SegmentAccessor::pSegment, SegmentAccessor::reset(), and scratchAccessor.

Referenced by abortBackup(), completeBackup(), initiateBackup(), and restoreFromBackup().

{
    if (pBackupRestoreDevice) {
        pBackupRestoreDevice.reset();
    }
    if (scratchAccessor.pSegment) {
        scratchAccessor.reset();
    }
    if (isBackup) {
        SXMutexSharedGuard actionMutexGuard(
            pCheckpointThread->getActionMutex());
        disableDeallocateOld = false;
    }
}

SharedDatabase Database::newDatabase	(	SharedCache	pCache,
		ConfigMap const &	configMap,
		DeviceMode	openMode,
		SharedTraceTarget	pTraceTarget,
		SharedPseudoUuidGenerator	pUuidGenerator = SharedPseudoUuidGenerator()
	)			[static]

Definition at line 76 of file Database.cpp.

References Database().

Referenced by BackupRestoreTest::createSnapshotData(), DatabaseTest::loadDatabase(), BTreeTxnTest::testCaseSetUp(), DatabaseTest::testCreateEmpty(), BTreeTxnTest::testTxns(), and CmdInterpreter::visit().

{
    if (!pUuidGenerator) {
        pUuidGenerator.reset(new PseudoUuidGenerator());
    }
    SharedDatabase pDb =
        SharedDatabase(
            new Database(
                pCacheInit, configMapInit, openModeInit, pTraceTarget,
                pUuidGenerator),
            ClosableObjectDestructor());
    pDb->init();
    return pDb;
}

const ConfigMap & Database::getConfigMap

(

)

const

Definition at line 540 of file Database.cpp.

References configMap.

{
    return configMap;
}

SharedCache Database::getCache

(

)

const

Definition at line 545 of file Database.cpp.

References pCache.

{
    return pCache;
}

SharedSegmentFactory Database::getSegmentFactory

(

)

const

Definition at line 581 of file Database.cpp.

References pSegmentFactory.

{
    return pSegmentFactory;
}

SharedSegment Database::getDataSegment

(

)

const

Definition at line 550 of file Database.cpp.

References pDataSegment.

Referenced by getSegmentById().

{
    return pDataSegment;
}

SharedSegment Database::getTempSegment

(

)

const

Definition at line 555 of file Database.cpp.

References pTempSegment.

Referenced by getSegmentById().

{
    return pTempSegment;
}

SharedCheckpointThread Database::getCheckpointThread

(

)

const

Definition at line 560 of file Database.cpp.

References pCheckpointThread.

{
    return pCheckpointThread;
}

SharedSegment Database::getSegmentById	(	SegmentId	segmentId,
		SharedSegment	pDataSegment
	)			[virtual]

Finds a segment by its SegmentId.

Parameters:

	segmentId	the SegmentId to find
	pDataSegment	the specific segment associated with a statement, if a specific segment must be used

Returns:

loaded segment, or a singular SharedSegment if not found

Implements SegmentMap.

Definition at line 565 of file Database.cpp.

References DEFAULT_DATA_SEGMENT_ID, getDataSegment(), getTempSegment(), and TEMP_SEGMENT_ID.

{
    if (segmentId == TEMP_SEGMENT_ID) {
        return getTempSegment();
    } else {
        assert(segmentId == DEFAULT_DATA_SEGMENT_ID);
        if (pDataSegment) {
            return pDataSegment;
        } else {
            return getDataSegment();
        }
    }
}

void Database::writeStats

(

StatsTarget &

target

)

[virtual]

Writes a current stats snapshot to a StatsTarget.

Parameters:

target

receives the stats

Implements StatsSource.

Definition at line 877 of file Database.cpp.

References SynchMonitoredObject::mutex, nCheckpoints, nCheckpointsStat, pCache, pDataSegment, pTempSegment, and StatsTarget::writeCounter().

{
    pCache->writeStats(target);

    StrictMutexGuard mutexGuard(mutex);
    target.writeCounter(
        "DatabaseCheckpoints", nCheckpointsStat);
    target.writeCounter(
        "DatabaseCheckpointsSinceInit", nCheckpoints);
    if (pDataSegment) {
        target.writeCounter(
            "DatabasePagesAllocated", pDataSegment->getAllocatedSizeInPages());
        // +2 for the database header pages
        target.writeCounter(
            "DatabasePagesOccupiedHighWaterSinceInit",
            pDataSegment->getNumPagesOccupiedHighWater() + 2);
        target.writeCounter(
            "DatabasePagesExtendedSinceInit",
            pDataSegment->getNumPagesExtended());
    }
    if (pTempSegment) {
        target.writeCounter(
            "TempPagesAllocated", pTempSegment->getAllocatedSizeInPages());
        target.writeCounter(
            "TempPagesOccupiedHighWaterSinceInit",
            pTempSegment->getNumPagesOccupiedHighWater());
        target.writeCounter(
            "TempPagesExtendedSinceInit",
            pTempSegment->getNumPagesExtended());
    }
    nCheckpointsStat = 0;
}

SharedLogicalTxnLog Database::getTxnLog

(

)

const

Definition at line 586 of file Database.cpp.

References pTxnLog.

{
    return pTxnLog;
}

StoredTypeDescriptorFactory const & Database::getTypeFactory

(

)

const

Definition at line 872 of file Database.cpp.

References typeFactory.

{
    return typeFactory;
}

bool Database::isRecoveryRequired

(

)

const

Definition at line 844 of file Database.cpp.

References recoveryRequired.

Referenced by checkpointImpl(), closeImpl(), and recoverPhysical().

{
    return recoveryRequired;
}

bool Database::shouldForceTxns

(

)

const

Definition at line 910 of file Database.cpp.

References forceTxns.

Referenced by createDataDevice(), and createTempSegment().

{
    return forceTxns;
}

bool Database::areSnapshotsEnabled

(

)

const

Definition at line 915 of file Database.cpp.

References disableSnapshots, and forceTxns.

Referenced by closeImpl(), createDataSegment(), initiateBackup(), and restoreFromBackup().

{
    return (forceTxns && !disableSnapshots);
}

void Database::recoverOnline

(

)

Definition at line 761 of file Database.cpp.

References CHECKPOINT_FLUSH_ALL, checkpointImpl(), forceTxns, VersionedSegment::getOnlineRecoveryPageId(), header, VersionedSegment::prepareOnlineRecovery(), pVersionedSegment, recoverPhysical(), recoveryRequired, and DatabaseHeader::shadowRecoveryPageId.

{
    // REVIEW jvs 8-Aug-2006:  This procedure has one questionable aspect,
    // which is that it leaves images of newly allocated pages in cache.
    // Updated pages are handled by recovery from the log, but newly allocated
    // pages are not.  They will be clean, so they shouldn't really cause any
    // trouble, but their presence could be, at a minimum, confusing.

    assert(forceTxns);
    header.shadowRecoveryPageId =
        pVersionedSegment->getOnlineRecoveryPageId();
    pVersionedSegment->prepareOnlineRecovery();
    recoveryRequired = true;

    // after recovery, flush recovered data pages; no need to discard them
    recoverPhysical(CHECKPOINT_FLUSH_ALL);

    // this will bump up version number to be used by further page writes
    checkpointImpl(CHECKPOINT_FLUSH_ALL);
}

void Database::recover

(

LogicalTxnParticipantFactory &

txnParticipantFactory

)

Definition at line 782 of file Database.cpp.

References CHECKPOINT_FLUSH_AND_UNMAP, closeDevices(), createTxnLogSegment(), deleteLogs(), CompoundId::getPageId(), header, LogicalTxnLogCheckpointMemento::logPosition, LogicalRecoveryLog::newLogicalRecoveryLog(), DatabaseHeader::onlineUuid, openMode, openSegments(), pCache, pSegmentFactory, recoverPhysical(), SegmentAccessor::reset(), SegStreamPosition::segByteId, TRACE_INFO, and DatabaseHeader::txnLogCheckpointMemento.

{
    recoverPhysical(CHECKPOINT_FLUSH_AND_UNMAP);

    // REVIEW:  are shadows being correctly logged during recovery?  They have
    // to be, otherwise we can't re-recover after a failed recovery.

    // TODO:  encapsulate memento->PageId translation in txn somewhere
    SharedSegment pTxnLogSegment = createTxnLogSegment(
        openMode,
        CompoundId::getPageId(
            header.txnLogCheckpointMemento.logPosition.segByteId));

    SegmentAccessor logSegmentAccessor(pTxnLogSegment,pCache);

    SharedLogicalRecoveryLog pRecoveryLog =
        LogicalRecoveryLog::newLogicalRecoveryLog(
            txnParticipantFactory,
            logSegmentAccessor,
            header.onlineUuid,
            pSegmentFactory);
    logSegmentAccessor.reset();

    pRecoveryLog->recover(header.txnLogCheckpointMemento);
    assert(pRecoveryLog.unique());
    pRecoveryLog.reset();
    assert(pTxnLogSegment.unique());
    pTxnLogSegment.reset();

    closeDevices();
    deleteLogs();
    FENNEL_TRACE(TRACE_INFO, "recovery completed");

    openSegments();
}

void Database::checkpointImpl

(

CheckpointType

= CHECKPOINT_FLUSH_ALL

)

Definition at line 666 of file Database.cpp.

References CHECKPOINT_DISCARD, CHECKPOINT_FLUSH_FUZZY, SynchMonitoredObject::condition, VersionedSegment::deallocateCheckpointedLog(), forceTxns, VersionedSegment::getOnlineRecoveryPageId(), VersionedSegment::getRecoveryPageId(), VersionedSegment::getVersionNumber(), header, isRecoveryRequired(), SynchMonitoredObject::mutex, nCheckpoints, nCheckpointsStat, pDataSegment, pTxnLog, pVersionedSegment, recoveryRequired, DatabaseHeader::shadowRecoveryPageId, DatabaseHeader::txnLogCheckpointMemento, DatabaseHeader::versionNumber, and writeHeader().

Referenced by closeImpl(), openSegments(), recoverOnline(), and CheckpointThread::run().

{
    assert(!isRecoveryRequired());

    if (checkpointType == CHECKPOINT_DISCARD) {
        recoveryRequired = true;
        // NOTE jvs 6-Mar-2006:  record this BEFORE anything else,
        // since pDataSegment->checkpoint(CHECKPOINT_DISCARD) will
        // destroy it
        header.shadowRecoveryPageId =
            pVersionedSegment->getOnlineRecoveryPageId();
        pDataSegment->checkpoint(checkpointType);
        if (!forceTxns) {
            // REVIEW jvs 8-Mar-2006:  I put in the forceTxns test
            // because when forceTxn is true, we actually use
            // CHECKPOINT_DISCARD for rollback, and there we DON'T
            // want to remove the other uncommitted transactions,
            // which is a side-effect of LogicalTxnLog::checkpoint(DISCARD).
            // Really, for forceTxns, we shouldn't be using
            // LogicalTxnLog at all.  And we should discriminate
            // between CHECKPOINT_DISCARD used to simulate a crash in
            // tests and CHECKPOINT_DISCARD used to implement rollback
            // as part of forceTxns.
            LogicalTxnLogCheckpointMemento crashMemento;
            pTxnLog->checkpoint(crashMemento,checkpointType);
        }
        return;
    }

    header.versionNumber = pVersionedSegment->getVersionNumber();
    if (checkpointType == CHECKPOINT_FLUSH_FUZZY) {
        header.versionNumber--;
    }
    pDataSegment->checkpoint(checkpointType);
    header.shadowRecoveryPageId = pVersionedSegment->getRecoveryPageId();
    pTxnLog->checkpoint(
        header.txnLogCheckpointMemento,
        checkpointType);
    writeHeader();
    pVersionedSegment->deallocateCheckpointedLog(checkpointType);
    pTxnLog->deallocateCheckpointedLog(
        header.txnLogCheckpointMemento,checkpointType);

    StrictMutexGuard mutexGuard(mutex);
    // TODO:  provide a counter which records the amount of data flushed by the
    // checkpoint
    ++nCheckpointsStat;
    ++nCheckpoints;
    condition.notify_all();
}

void Database::requestCheckpoint	(	CheckpointType	checkpointType,
		bool	async
	)

Receives request for a checkpoint.

Parameters:

	checkpointType	must be CHECKPOINT_FLUSH_FUZZY or CHECKPOINT_FLUSH_ALL
	async	if true, just schedule checkpoint and return; if false, wait for completion

Definition at line 717 of file Database.cpp.

References CHECKPOINT_FLUSH_ALL, CHECKPOINT_FLUSH_FUZZY, SynchMonitoredObject::condition, forceTxns, SynchMonitoredObject::mutex, nCheckpoints, and pCheckpointThread.

Referenced by deallocateOldPages().

{
    StrictMutexGuard mutexGuard(mutex);
    uint nCheckpointsBefore = nCheckpoints;
    mutexGuard.unlock();

    if (forceTxns && (checkpointType == CHECKPOINT_FLUSH_FUZZY)) {
        // fuzzy checkpoints aren't meaningful in forceTxns mode,
        // so treat them as sharp
        checkpointType = CHECKPOINT_FLUSH_ALL;
    }

    pCheckpointThread->requestCheckpoint(checkpointType);

    if (async) {
        return;
    }

    mutexGuard.lock();
    while (nCheckpoints == nCheckpointsBefore) {
        condition.wait(mutexGuard);
    }
}

void Database::deallocateOldPages

(

TxnId

oldestLabelCsn

)

Deallocates old snapshot pages that are no longer referenced by any active transactions, as well as active labels marking snapshots in time.

Parameters:

oldestLabelCsn

the csn of the oldest active label; set to NULL_TXN_ID if there are no active labels

Definition at line 920 of file Database.cpp.

References CHECKPOINT_FLUSH_ALL, VersionedRandomAllocationSegment::deallocateOldPages(), disableDeallocateOld, VersionedRandomAllocationSegment::getOldPageIds(), min(), NULL_TXN_ID, pCheckpointThread, pDataSegment, pTxnLog, and requestCheckpoint().

{
    uint iSegAlloc = 0;
    ExtentNum extentNum = 0;
    // REVIEW zfong 3/12/07 - Determine a good value for numPages.  This
    // corresponds to the number of pages we will deallocate during a single
    // iteration.  We will be holding the checkpoint mutex for the duration
    // of an iteration so we don't want to make the value too big.  But at
    // the same time, we don't want to make it too small either, because it
    // would then require a large number of iterations to clean out all old
    // pages.
    uint numPages = 100;

    // Determine the oldest active txnId.
    TxnId oldestActiveTxnId = pTxnLog->getOldestActiveTxnId();

    // Take the minimum of the oldest active txnId and the
    // oldest active label + 1, if there are any active labels.
    // +1 because txns using that label will have ids bigger than that
    // label's csn.
    TxnId oldestTxnId;
    if (oldestLabelCsn == NULL_TXN_ID) {
        oldestTxnId = oldestActiveTxnId;
    } else {
        oldestTxnId = std::min(oldestActiveTxnId, oldestLabelCsn + 1);
    }

    // Gather a batch of old pageIds and then deallocate them.  After each
    // deallocation, issue a checkpoint to flush the modified allocation
    // node pages.  Continue this in a loop until we've read through all
    // allocation node pages.

    PageSet oldPageSet;
    VersionedRandomAllocationSegment *pVersionedRandomSegment =
        SegmentFactory::dynamicCast<VersionedRandomAllocationSegment *>(
            pDataSegment);
    bool morePages = true;
    do {
        morePages =
            pVersionedRandomSegment->getOldPageIds(
                iSegAlloc,
                extentNum,
                oldestTxnId,
                numPages,
                oldPageSet);

        // Hold the checkpoint mutex while deallocating old pages, if there
        // are pages to deallocate.
        if (!oldPageSet.empty()) {
            SXMutexSharedGuard actionMutexGuard(
                pCheckpointThread->getActionMutex());
            if (disableDeallocateOld) {
                return;
            }
            pVersionedRandomSegment->deallocateOldPages(
                oldPageSet,
                oldestTxnId);

            actionMutexGuard.unlock();
            requestCheckpoint(CHECKPOINT_FLUSH_ALL, false);
            oldPageSet.clear();
        }
    } while (morePages);
}

void Database::setLastCommittedTxnId

(

TxnId

txnId

)

Saves the id of the last committed transaction.

Parameters:

txnId

id of the last committed transaction

TxnId Database::getLastCommittedTxnId

(

)

Returns:

the id of the last committed, write transaction

Definition at line 661 of file Database.cpp.

References header, LogicalTxnLogCheckpointMemento::nextTxnId, and DatabaseHeader::txnLogCheckpointMemento.

Referenced by initiateBackup(), and restoreFromBackup().

{
    return header.txnLogCheckpointMemento.nextTxnId - 1;
}

TxnId Database::initiateBackup	(	const std::string &	backupFilePathname,
		bool	checkSpaceRequirements,
		FileSize	spacePadding,
		TxnId	lowerBoundCsn,
		const std::string &	compressionProgram,
		FileSize &	dataDeviceSize,
		const volatile bool &	aborted
	)

Initiates a backup of the data segment.

Backs up the header pages and the allocation node pages.

Parameters:

	backupFilePathname	pathname of the backup file
	checkSpaceRequirements	if true, make sure file system space is available to perform the backup of data pages
	spacePadding	if non-zero, the amount of padding to add to the space requirements for the backup to proceed
	lowerBoundCsn	the lower bound allocation csn that determines which pages need to be backed up; if the lower bound is set to NULL_TXN_ID, then that indicates that there is no lower bound; otherwise, the lower bound is exclusive
	compressionProgram	if non-empty string, the name of the program used to compress the backup file
	dataDeviceSize	returns the size of the data device in bytes
	aborted	reference to a flag indicating whether the backup should be aborted

Returns:

the txnId of the last committed write txn at the start of the backup; i.e., the upper bound allocationCsn for the backup

Definition at line 985 of file Database.cpp.

References areSnapshotsEnabled(), cleanupBackupRestore(), disableDeallocateOld, FileSystem::getDiskFreeSpace(), getLastCommittedTxnId(), headerPageId1, headerPageId2, SegPageBackupRestoreDevice::newSegPageBackupRestoreDevice(), pBackupRestoreDevice, pCache, pCheckpointThread, pDataDevice, pDataSegment, pHeaderSegment, pSegmentFactory, scratchAccessor, and TRACE_FINE.

{
    FENNEL_TRACE(TRACE_FINE, "Started Fennel metadata backup");

    // Snapshots must be enabled
    if (!areSnapshotsEnabled()) {
        throw FennelExcn(
            FennelResource::instance().unsupportedOperation("System backup"));
    }

    // Hold the checkpoint mutex while backing up the header and allocation
    // node pages
    SXMutexSharedGuard actionMutexGuard(pCheckpointThread->getActionMutex());

    // Another backup should not have already been initiated
    assert(!disableDeallocateOld);
    assert(pBackupRestoreDevice == NULL);

    // The upper bound csn for this backup is the txnId of the last committed,
    // write txn.  Note that the next txnId to be assigned may be a larger
    // value because of read-only txns.  But we don't care about read-only
    // txns.  We just want the txnId that's in sync with what's reflected in
    // the header.
    TxnId upperBoundCsn = getLastCommittedTxnId();

    disableDeallocateOld = true;
    dataDeviceSize = pDataDevice->getSizeInBytes();

    // Use the prefetch setting to determine how many scratch pages to
    // allocate.  Note that these scratch pages are not being accounted
    // for in the resource governor and come from the reserve pool that
    // the resource governor currently sets aside.
    uint nScratchPages, rate;
    pCache->getPrefetchParams(nScratchPages, rate);

    scratchAccessor = pSegmentFactory->newScratchSegment(pCache);
    pBackupRestoreDevice =
        SegPageBackupRestoreDevice::newSegPageBackupRestoreDevice(
             backupFilePathname,
#ifdef __MSVC__
             "wb",
#else
             "w",
#endif
             compressionProgram,
             nScratchPages,
             2,
             scratchAccessor,
             pCache->getDeviceAccessScheduler(*pDataDevice),
             pDataDevice);
    VersionedRandomAllocationSegment *pVRSegment =
        SegmentFactory::dynamicCast<VersionedRandomAllocationSegment *>(
            pDataSegment);

    try {
        pBackupRestoreDevice->backupPage(
            pHeaderSegment->translatePageId(headerPageId1));
        pBackupRestoreDevice->backupPage(
            pHeaderSegment->translatePageId(headerPageId2));
        // First wait for writes of the header pages to complete before backing
        // up the allocation node pages.
        pBackupRestoreDevice->waitForPendingWrites();
        BlockNum nDataPages =
            pVRSegment->backupAllocationNodes(
                pBackupRestoreDevice,
                checkSpaceRequirements,
                lowerBoundCsn,
                upperBoundCsn,
                aborted);

        // Verify space if specified, now that we know how many data pages
        // will be backed up
        if (checkSpaceRequirements) {
            FileSize spaceAvailable;
            FileSystem::getDiskFreeSpace(
                backupFilePathname.c_str(),
                spaceAvailable);
            FileSize spaceRequired =
                nDataPages * pDataSegment->getFullPageSize();
            // TODO zfong 9/16/08 - Revisit the compression factor after more
            // testing.  Set conservatively to 5, for now.
            if (compressionProgram.length() != 0) {
                spaceRequired /= 5;
            }
            spaceRequired += spacePadding;
            if (spaceAvailable < spaceRequired) {
                throw FennelExcn(FennelResource::instance().outOfBackupSpace());
            }
        }
    } catch (...) {
        cleanupBackupRestore(true);
        // abort exception takes precedence
        if (aborted) {
            FENNEL_TRACE(TRACE_FINE, "abort detected");
            throw AbortExcn();
        } else {
            throw;
        }
    }

    FENNEL_TRACE(TRACE_FINE, "Finished Fennel metadata backup");
    return upperBoundCsn;
}

void Database::completeBackup	(	TxnId	lowerBoundCsn,
		TxnId	upperBoundCsn,
		const volatile bool &	aborted
	)

Completes the remainder of a backup by backing up the data pages that have allocationCsn's in between two specified bounds.

If the lower bound is set to NULL_TXN_ID, then that indicates that there is no lower bound; otherwise, the lower bound is exclusive. There must always be an upper bound and it is inclusive.

Parameters:

	lowerBoundCsn	the lower bound allocation csn
	upperBoundCsn	the upper bound allocation csn
	aborted	reference to a flag indicating whether the backup should be aborted

Definition at line 1096 of file Database.cpp.

References VersionedRandomAllocationSegment::backupDataPages(), cleanupBackupRestore(), disableDeallocateOld, pBackupRestoreDevice, pDataSegment, and TRACE_FINE.

{
    FENNEL_TRACE(TRACE_FINE, "Started Fennel data page backup");
    assert(disableDeallocateOld);
    assert(pBackupRestoreDevice != NULL);

    VersionedRandomAllocationSegment *pVRSegment =
        SegmentFactory::dynamicCast<VersionedRandomAllocationSegment *>(
            pDataSegment);
    try {
        pVRSegment->backupDataPages(
            pBackupRestoreDevice,
            lowerBoundCsn,
            upperBoundCsn,
            aborted);
        cleanupBackupRestore(true);
    } catch (...) {
        cleanupBackupRestore(true);
        // abort exception takes precedence
        if (aborted) {
            FENNEL_TRACE(TRACE_FINE, "abort detected");
            throw AbortExcn();
        } else {
            throw;
        }
    }

    FENNEL_TRACE(TRACE_FINE, "Finished Fennel data page backup");
}

void Database::abortBackup

(

)

Aborts a backup that may or may not have been previously initiated.

This is necessary to perform cleanup on the backup in case an error occurred after the backup was initiated, but before there was a chance to complete it.

Definition at line 1129 of file Database.cpp.

References cleanupBackupRestore(), and TRACE_FINE.

{
    FENNEL_TRACE(TRACE_FINE, "Aborting Fennel backup");
    cleanupBackupRestore(true);
}

void Database::restoreFromBackup	(	const std::string &	backupFilePathname,
		FileSize	newSize,
		const std::string &	compressionProgram,
		TxnId	lowerBoundCsn,
		TxnId	upperBoundCsn,
		const volatile bool &	aborted
	)

Restores the data segment from a backup file.

The data pages in the backup file correspond to pages with allocationCsn's in between a lower and upper bound. If the lower bound is set to NULL_TXN_ID, then that indicates that there is no lower bound; otherwise, the lower bound is exclusive. There must always be an upper bound and it is inclusive.

Parameters:

	backupFilePathname	pathname of the backup file
	newSize	the size the data segment will be extended to by the restore
	compressionProgram	if non-empty string, the name of the program used to compress the backup file
	lowerBoundCsn	the lower bound allocation csn
	upperBoundCsn	the upper bound allocation csn
	aborted	reference to a flag indicating whether the restore should be aborted

Definition at line 1135 of file Database.cpp.

References areSnapshotsEnabled(), CHECKPOINT_FLUSH_AND_UNMAP, cleanupBackupRestore(), getLastCommittedTxnId(), header, headerPageId1, headerPageId2, loadHeader(), SegPageBackupRestoreDevice::newSegPageBackupRestoreDevice(), NULL_PAGE_ID, NULL_TXN_ID, DatabaseHeader::onlineUuid, pBackupRestoreDevice, pCache, pDataDevice, pDataSegment, pHeaderSegment, pSegmentFactory, pVersionedSegment, VersionedSegment::recover(), VersionedRandomAllocationSegment::restoreFromBackup(), scratchAccessor, TRACE_FINE, and DatabaseHeader::versionNumber.

{
    FENNEL_TRACE(TRACE_FINE, "Started Fennel restore");

    // Snapshots must be enabled
    if (!areSnapshotsEnabled()) {
        throw FennelExcn(
            FennelResource::instance().unsupportedOperation("System restore"));
    }

    // Verify that the last committed csn in the database header matches the
    // lower bound csn.
    if (lowerBoundCsn != NULL_TXN_ID) {
        TxnId headerTxnId = getLastCommittedTxnId();
        if (headerTxnId != lowerBoundCsn) {
            throw FennelExcn(
                FennelResource::instance().mismatchedRestore());
        }
    }

    pDataDevice->setSizeInBytes(newSize);

    VersionedRandomAllocationSegment *pVRSegment =
        SegmentFactory::dynamicCast<VersionedRandomAllocationSegment *>(
            pDataSegment);

    uint nScratchPages, rate;
    pCache->getPrefetchParams(nScratchPages, rate);

    scratchAccessor =
        pSegmentFactory->newScratchSegment(pCache);
    pBackupRestoreDevice =
        SegPageBackupRestoreDevice::newSegPageBackupRestoreDevice(
             backupFilePathname,
#ifdef __MSVC__
             "rb",
#else
             "r",
#endif
             compressionProgram,
             nScratchPages,
             0,
             scratchAccessor,
             pCache->getDeviceAccessScheduler(*pDataDevice),
             pDataDevice);

    // Flush and unmap pages from the cache that will be restored, i.e., any
    // VersionedRandomAllocationSegment or database header pages, including
    // the header page just read above.  We need to unmap these pages to
    // ensure that the restore doesn't read old pages.
    MappedPageListenerPredicate dataPredicate(*pVRSegment);
    pCache->checkpointPages(dataPredicate, CHECKPOINT_FLUSH_AND_UNMAP);
    MappedPageListenerPredicate headerPredicate(*pHeaderSegment);
    pCache->checkpointPages(headerPredicate, CHECKPOINT_FLUSH_AND_UNMAP);

    try {
        // Restore the rest of the pages, including the database header pages
        pBackupRestoreDevice->restorePage(
            pHeaderSegment->translatePageId(headerPageId1));
        pBackupRestoreDevice->restorePage(
            pHeaderSegment->translatePageId(headerPageId2));
        pVRSegment->restoreFromBackup(
            pBackupRestoreDevice,
            lowerBoundCsn,
            upperBoundCsn,
            aborted);
        cleanupBackupRestore(false);
    } catch (...) {
        cleanupBackupRestore(false);
        // abort exception takes precedence
        if (aborted) {
            FENNEL_TRACE(TRACE_FINE, "abort detected");
            throw AbortExcn();
        } else {
            throw;
        }
    }

    // Reload the header pages so future checkpoints will flush the
    // restored data.  Issue a recover call on the versioned segment
    // to reset the version number and online uuid to the values that are
    // now in the header.
    loadHeader(false);
    pVersionedSegment->recover(
        pDataSegment,
        NULL_PAGE_ID,
        header.versionNumber,
        header.onlineUuid);

    FENNEL_TRACE(TRACE_FINE, "Finished Fennel restore");
}

bool ClosableObject::isClosed

(

)

const [inline, inherited]

Returns:

whether the object has been closed

Definition at line 58 of file ClosableObject.h.

    {
        return !needsClose;
    }

void ClosableObject::close

(

)

[inherited]

Closes this object, releasing any unallocated resources.

Reimplemented in CollectExecStream, CorrelationJoinExecStream, LcsClusterAppendExecStream, and LcsClusterReplaceExecStream.

Definition at line 39 of file ClosableObject.cpp.

References ClosableObject::closeImpl(), and ClosableObject::needsClose.

Referenced by CacheImpl< PageT, VictimPolicyT >::allocatePages(), LcsRowScanBaseExecStream::closeImpl(), ExecStreamGraphImpl::closeImpl(), FlatFileBuffer::open(), ClosableObjectDestructor::operator()(), and Segment::~Segment().

{
    if (!needsClose) {
        return;
    }
    needsClose = false;
    closeImpl();
}

void TraceSource::initTraceSource	(	SharedTraceTarget	pTraceTarget,
		std::string	name
	)			[virtual, inherited]

For use when initialization has to be deferred until after construction.

Parameters:

	pTraceTarget	the TraceTarget to which messages will be sent
	name	the name of this source

Definition at line 46 of file TraceSource.cpp.

References TraceSource::isTracing(), TraceSource::minimumLevel, TraceSource::name, TraceSource::pTraceTarget, and TRACE_OFF.

Referenced by TestBase::beforeTestCase(), TestBase::TestBase(), and TraceSource::TraceSource().

{
    assert(!pTraceTarget.get());

    pTraceTarget = pTraceTargetInit;
    name = nameInit;
    if (isTracing()) {
        minimumLevel = pTraceTarget->getSourceTraceLevel(name);
    } else {
        minimumLevel = TRACE_OFF;
    }
}

void TraceSource::trace	(	TraceLevel	level,
		std::string	message
	)			const [inherited]

Records a trace message.

Normally only called via FENNEL_TRACE.

Parameters:

	level	severity level of event being trace
	message	the text of the message

Definition at line 61 of file TraceSource.cpp.

References TraceSource::getTraceTarget(), TraceSource::isTracing(), TraceSource::name, and TraceTarget::notifyTrace().

Referenced by Calculator::exec(), and ExecStreamScheduler::traceStreamBufferContents().

{
    if (isTracing()) {
        getTraceTarget().notifyTrace(name,level,message);
    }
}

bool TraceSource::isTracing

(

)

const [inline, inherited]

Returns:

true iff tracing is enabled for this source

Definition at line 88 of file TraceSource.h.

Referenced by TraceSource::initTraceSource(), CalcExecStream::prepare(), and TraceSource::trace().

    {
        return pTraceTarget.get() ? true : false;
    }

bool TraceSource::isTracingLevel

(

TraceLevel

level

)

const [inline, inherited]

Determines whether a particular level is being traced.

Parameters:

level

trace level to test

Returns:

true iff tracing is enabled for the given level

Definition at line 100 of file TraceSource.h.

Referenced by ExecStreamScheduler::addGraph(), SimpleExecStreamGovernor::assignCachePages(), SimpleExecStreamGovernor::distributeCachePages(), Calculator::exec(), ExecStreamScheduler::ExecStreamScheduler(), LcsClusterNodeWriter::getLastClusterPageForWrite(), LcsClusterNodeWriter::moveFromTempToIndex(), JavaSinkExecStream::stuffByteBuffer(), and ExecStreamScheduler::traceStreamBuffers().

    {
        return level >= minimumLevel;
    }

TraceTarget& TraceSource::getTraceTarget

(

)

const [inline, inherited]

Returns:

the TraceTarget for this source

Definition at line 108 of file TraceSource.h.

Referenced by TraceSource::trace().

    {
        assert(isTracing());
        return *(pTraceTarget.get());
    }

SharedTraceTarget TraceSource::getSharedTraceTarget

(

)

const [inline, inherited]

Returns:

the SharedTraceTarget for this source

Definition at line 117 of file TraceSource.h.

Referenced by init(), LcsClusterAppendExecStream::initLoad(), and CalcExecStream::prepare().

    {
        return pTraceTarget;
    }

std::string TraceSource::getTraceSourceName

(

)

const [inline, inherited]

Gets the name of this source.

Useful to construct nested names for subcomponents that are also TraceSources.

Returns:

the name

Definition at line 127 of file TraceSource.h.

Referenced by LcsClusterAppendExecStream::initLoad().

    {
        return name;
    }

void TraceSource::setTraceSourceName

(

std::string const &

n

)

[inline, inherited]

Sets the name of this source.

Useful to construct dynamic names for fine-grained filtering.

Definition at line 136 of file TraceSource.h.

    {
        name = n;
    }

TraceLevel TraceSource::getMinimumTraceLevel

(

)

const [inline, inherited]

Definition at line 141 of file TraceSource.h.

    {
        return minimumLevel;
    }

void TraceSource::disableTracing

(

)

[inherited]

Definition at line 68 of file TraceSource.cpp.

References TraceSource::minimumLevel, TraceSource::pTraceTarget, and TRACE_OFF.

Referenced by TestBase::afterTestCase().

{
    pTraceTarget.reset();
    minimumLevel = TRACE_OFF;
}

---

Member Data Documentation

DeviceId Database::dataDeviceId [private]

Definition at line 57 of file Database.h.

Referenced by allocateHeader(), closeDevices(), createDataDevice(), createDataSegment(), init(), and loadHeader().

SharedRandomAccessDevice Database::pDataDevice [private]

Definition at line 59 of file Database.h.

Referenced by createDataDevice(), initiateBackup(), and restoreFromBackup().

DeviceId Database::tempDeviceId [private]

Definition at line 61 of file Database.h.

Referenced by closeDevices(), createTempSegment(), and init().

DeviceId Database::shadowDeviceId [private]

Definition at line 63 of file Database.h.

Referenced by closeDevices(), createShadowLog(), and init().

DeviceId Database::txnLogDeviceId [private]

Definition at line 65 of file Database.h.

Referenced by closeDevices(), createTxnLogSegment(), and init().

std::string Database::dataDeviceName [private]

Definition at line 67 of file Database.h.

Referenced by createDataDevice(), and init().

std::string Database::tempDeviceName [private]

Definition at line 69 of file Database.h.

Referenced by createTempSegment(), and init().

std::string Database::shadowDeviceName [private]

Definition at line 71 of file Database.h.

Referenced by createShadowLog(), deleteLogs(), and init().

std::string Database::txnLogDeviceName [private]

Definition at line 73 of file Database.h.

Referenced by createTxnLogSegment(), deleteLogs(), and init().

SharedCache Database::pCache [private]

Definition at line 75 of file Database.h.

Referenced by allocateHeader(), closeDevices(), createDataDevice(), createDataSegment(), createShadowLog(), createTempSegment(), createTxnLog(), createTxnLogSegment(), getCache(), initiateBackup(), loadHeader(), recover(), restoreFromBackup(), writeHeader(), and writeStats().

SharedSegmentFactory Database::pSegmentFactory [private]

Definition at line 77 of file Database.h.

Referenced by allocateHeader(), createDataSegment(), createShadowLog(), createTempSegment(), createTxnLog(), createTxnLogSegment(), getSegmentFactory(), init(), initiateBackup(), loadHeader(), recover(), and restoreFromBackup().

SharedSegment Database::pHeaderSegment [private]

Definition at line 79 of file Database.h.

Referenced by allocateHeader(), closeDevices(), initiateBackup(), loadHeader(), restoreFromBackup(), and writeHeader().

SharedSegment Database::pDataSegment [private]

Definition at line 81 of file Database.h.

Referenced by checkpointImpl(), closeDevices(), closeImpl(), completeBackup(), createDataSegment(), deallocateOldPages(), getDataSegment(), initiateBackup(), recoverPhysical(), restoreFromBackup(), and writeStats().

SharedSegment Database::pTempSegment [private]

Definition at line 83 of file Database.h.

Referenced by closeDevices(), closeImpl(), createDataSegment(), createTempSegment(), getTempSegment(), and writeStats().

VersionedSegment* Database::pVersionedSegment [private]

Definition at line 85 of file Database.h.

Referenced by checkpointImpl(), closeDevices(), createDataSegment(), recoverOnline(), recoverPhysical(), and restoreFromBackup().

SharedLogicalTxnLog Database::pTxnLog [private]

Definition at line 87 of file Database.h.

Referenced by allocateHeader(), checkpointImpl(), closeDevices(), closeImpl(), createTxnLog(), deallocateOldPages(), getTxnLog(), and loadHeader().

PageId Database::headerPageId1 [private]

Definition at line 89 of file Database.h.

Referenced by allocateHeader(), init(), initiateBackup(), loadHeader(), restoreFromBackup(), and writeHeader().

PageId Database::headerPageId2 [private]

Definition at line 91 of file Database.h.

Referenced by allocateHeader(), init(), initiateBackup(), loadHeader(), restoreFromBackup(), and writeHeader().

DatabaseHeader Database::header [private]

Definition at line 93 of file Database.h.

Referenced by allocateHeader(), checkpointImpl(), closeImpl(), createDataSegment(), createShadowLog(), createTxnLog(), getLastCommittedTxnId(), init(), loadHeader(), openSegments(), recover(), recoverOnline(), recoverPhysical(), restoreFromBackup(), and writeHeader().

LogicalTxnParticipantFactory* Database::pTxnParticipantFactory [private]

Definition at line 95 of file Database.h.

bool Database::forceTxns [private]

Definition at line 97 of file Database.h.

Referenced by areSnapshotsEnabled(), checkpointImpl(), createShadowLog(), createTxnLogSegment(), init(), recoverOnline(), requestCheckpoint(), and shouldForceTxns().

bool Database::disableSnapshots [private]

Definition at line 99 of file Database.h.

Referenced by areSnapshotsEnabled(), and init().

bool Database::recoveryRequired [private]

Definition at line 101 of file Database.h.

Referenced by checkpointImpl(), createDataSegment(), init(), isRecoveryRequired(), prepareForRecovery(), recoverOnline(), and recoverPhysical().

DeviceMode Database::openMode [private]

Definition at line 103 of file Database.h.

Referenced by createDataDevice(), createDataSegment(), createTempSegment(), Database(), init(), openSegments(), prepareForRecovery(), recover(), and recoverPhysical().

ConfigMap Database::configMap [private]

Definition at line 105 of file Database.h.

Referenced by getConfigMap(), init(), and readDeviceParams().

StandardTypeDescriptorFactory Database::typeFactory [private]

Definition at line 107 of file Database.h.

Referenced by getTypeFactory().

SharedCheckpointThread Database::pCheckpointThread [private]

Definition at line 109 of file Database.h.

Referenced by cleanupBackupRestore(), closeImpl(), createShadowLog(), createTxnLogSegment(), deallocateOldPages(), getCheckpointThread(), initiateBackup(), openSegments(), and requestCheckpoint().

SharedPseudoUuidGenerator Database::pUuidGenerator [private]

Definition at line 111 of file Database.h.

Referenced by openSegments().

uint Database::nCheckpointsStat [private]

Cumulative counter cleared whenever writeStats is called.

Definition at line 116 of file Database.h.

Referenced by checkpointImpl(), init(), and writeStats().

uint Database::nCheckpoints [private]

Cumulative counter.

Definition at line 121 of file Database.h.

Referenced by checkpointImpl(), init(), requestCheckpoint(), and writeStats().

bool Database::disableDeallocateOld [private]

If true, ALTER SYSTEM DEALLOCATE OLD is a no-op.

Definition at line 126 of file Database.h.

Referenced by cleanupBackupRestore(), completeBackup(), Database(), deallocateOldPages(), and initiateBackup().

SharedSegPageBackupRestoreDevice Database::pBackupRestoreDevice [private]

Device used to read and write the backup file during backup and restore.

Definition at line 131 of file Database.h.

Referenced by cleanupBackupRestore(), completeBackup(), initiateBackup(), and restoreFromBackup().

SegmentAccessor Database::scratchAccessor [private]

Scratch accessor used during backup and restore.

Definition at line 136 of file Database.h.

Referenced by cleanupBackupRestore(), initiateBackup(), and restoreFromBackup().

ParamName Database::paramDatabaseDir [static]

Definition at line 190 of file Database.h.

Referenced by DatabaseTest::DatabaseTest(), init(), BackupRestoreTest::testBackupCleanup(), BTreeTxnTest::testCaseSetUp(), and BackupRestoreTest::testHeaderBackupRestore().

ParamName Database::paramResourceDir [static]

Definition at line 191 of file Database.h.

Referenced by init().

ParamName Database::paramForceTxns [static]

Definition at line 192 of file Database.h.

Referenced by init().

ParamName Database::paramDisableSnapshots [static]

Definition at line 193 of file Database.h.

Referenced by init().

ParamName Database::paramDatabasePrefix [static]

Definition at line 194 of file Database.h.

Referenced by createDataDevice().

ParamName Database::paramTempPrefix [static]

Definition at line 195 of file Database.h.

Referenced by createTempSegment().

ParamName Database::paramShadowLogPrefix [static]

Definition at line 196 of file Database.h.

Referenced by createShadowLog().

ParamName Database::paramTxnLogPrefix [static]

Definition at line 197 of file Database.h.

Referenced by createTxnLogSegment().

ParamName Database::paramInitSizeSuffix [static]

Definition at line 198 of file Database.h.

Referenced by readDeviceParams().

ParamName Database::paramMaxSizeSuffix [static]

Definition at line 199 of file Database.h.

Referenced by readDeviceParams().

ParamName Database::paramIncSizeSuffix [static]

Definition at line 200 of file Database.h.

Referenced by readDeviceParams().

ParamVal Database::valLogAllocLinear [static]

Definition at line 202 of file Database.h.

ParamVal Database::valLogAllocCircular [static]

Definition at line 203 of file Database.h.

const SegmentId Database::DEFAULT_DATA_SEGMENT_ID [static]

Definition at line 205 of file Database.h.

Referenced by getSegmentById().

const SegmentId Database::TEMP_SEGMENT_ID [static]

Definition at line 206 of file Database.h.

Referenced by getSegmentById(), ExecStreamFactory::implementSortWithBTree(), and ExecStreamFactory::readBTreeParams().

bool ClosableObject::needsClose [protected, inherited]

Definition at line 44 of file ClosableObject.h.

Referenced by SegStreamAllocation::beginWrite(), ExecStreamGraphImpl::clear(), ClosableObject::ClosableObject(), ClosableObject::close(), FlatFileBuffer::open(), ExecStreamGraphImpl::open(), ExecStream::open(), and ClosableObject::~ClosableObject().

StrictMutex SynchMonitoredObject::mutex [protected, inherited]

Definition at line 38 of file SynchMonitoredObject.h.

Referenced by ParallelExecStreamScheduler::abort(), LogicalTxnLog::checkpoint(), checkpointImpl(), CheckpointThread::closeImpl(), LogicalTxnLog::commitTxn(), ParallelExecStreamScheduler::executeManager(), ParallelExecStreamScheduler::executeTask(), LogicalTxnLog::getOldestActiveTxnId(), LogicalTxnLog::newLogicalTxn(), ParallelExecStreamScheduler::readStream(), SXMutex::release(), GroupLock::release(), requestCheckpoint(), CheckpointThread::requestCheckpoint(), LogicalTxnLog::rollbackTxn(), TimerThread::run(), CheckpointThread::run(), ThreadPoolBase::runPooledThread(), SXMutex::setSchedulingPolicy(), TimerThread::signalImmediate(), ParallelExecStreamScheduler::signalSentinel(), ThreadPoolBase::start(), TimerThread::stop(), ThreadPoolBase::stop(), ParallelExecStreamScheduler::stop(), ThreadPool< RandomAccessRequest >::submitTask(), ParallelExecStreamScheduler::tryExecuteManager(), ParallelExecStreamScheduler::tryExecuteTask(), SXMutex::tryUpgrade(), SXMutex::waitFor(), GroupLock::waitFor(), and writeStats().

LocalCondition SynchMonitoredObject::condition [protected, inherited]

Definition at line 39 of file SynchMonitoredObject.h.

Referenced by ParallelExecStreamScheduler::abort(), checkpointImpl(), CheckpointThread::closeImpl(), LogicalTxnLog::commitTxnWithGroup(), ParallelExecStreamScheduler::executeTask(), ParallelExecStreamScheduler::readStream(), SXMutex::release(), GroupLock::release(), requestCheckpoint(), CheckpointThread::requestCheckpoint(), TimerThread::run(), CheckpointThread::run(), ThreadPoolBase::runPooledThread(), TimerThread::signalImmediate(), TimerThread::stop(), ThreadPoolBase::stop(), ParallelExecStreamScheduler::stop(), ThreadPool< RandomAccessRequest >::submitTask(), ParallelExecStreamScheduler::tryExecuteManager(), ParallelExecStreamScheduler::tryExecuteTask(), SXMutex::waitFor(), and GroupLock::waitFor().

---

The documentation for this class was generated from the following files:

• /home/pub/open/dev/fennel/db/Database.h
• /home/pub/open/dev/fennel/db/Database.cpp

---