Database.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/db/Database.h#21 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2005-2009 SQLstream, Inc.
// Copyright (C) 2005-2009 LucidEra, Inc.
// Portions Copyright (C) 1999-2009 John V. Sichi
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_Database_Included
#define Fennel_Database_Included

#include "fennel/device/DeviceMode.h"
#include "fennel/common/TraceSource.h"
#include "fennel/common/StatsSource.h"
#include "fennel/common/ConfigMap.h"
#include "fennel/common/ClosableObject.h"
#include "fennel/db/DatabaseHeader.h"
#include "fennel/tuple/StandardTypeDescriptor.h"
#include "fennel/segment/SegmentMap.h"
#include "fennel/synch/SynchMonitoredObject.h"

#include <boost/utility.hpp>

FENNEL_BEGIN_NAMESPACE

class LogicalTxnParticipantFactory;
class VersionedSegment;
class LinearDeviceSegmentParams;

class FENNEL_DB_EXPORT Database
    : public boost::noncopyable,
        public ClosableObject,
        public TraceSource,
        public SegmentMap,
        public StatsSource,
        public SynchMonitoredObject
{
    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;

    uint nCheckpoints;

    bool disableDeallocateOld;

    SharedSegPageBackupRestoreDevice pBackupRestoreDevice;

    SegmentAccessor scratchAccessor;

    explicit Database(
        SharedCache pCache,
        ConfigMap const &configMap,
        DeviceMode openMode,
        SharedTraceTarget pTraceTarget,
        SharedPseudoUuidGenerator pUuidGenerator);

    // implement ClosableObject
    virtual void closeImpl();

// ----------------------------------------------------------------------
// internal helper methods
// ----------------------------------------------------------------------

    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);

public:
    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;

    static SharedDatabase newDatabase(
        SharedCache pCache,
        ConfigMap const &configMap,
        DeviceMode openMode,
        SharedTraceTarget pTraceTarget,
        SharedPseudoUuidGenerator pUuidGenerator = SharedPseudoUuidGenerator());

    virtual ~Database();

    const ConfigMap& getConfigMap() const;

    SharedCache getCache() const;

    SharedSegmentFactory getSegmentFactory() const;

    SharedSegment getDataSegment() const;

    SharedSegment getTempSegment() const;

    SharedCheckpointThread getCheckpointThread() const;

    // implement SegmentMap
    virtual SharedSegment getSegmentById(
        SegmentId segmentId,
        SharedSegment pDataSegment);

    // implement StatsSource
    virtual void writeStats(StatsTarget &target);

    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);

    void deallocateOldPages(TxnId oldestLabelCsn);

    void setLastCommittedTxnId(TxnId txnId);

    TxnId getLastCommittedTxnId();

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

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

    void abortBackup();

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

FENNEL_END_NAMESPACE

#endif

// End Database.h

---