kv_engine.h

Go to the documentation of this file.

// kv_engine.h

#pragma once

#include <memory>
#include <string>
#include <vector>

#include "mongo/base/status.h"
#include "mongo/base/string_data.h"
#include "mongo/bson/timestamp.h"
#include "mongo/db/catalog/collection_options.h"
#include "mongo/db/storage/kv/kv_prefix.h"
#include "mongo/db/storage/record_store.h"

namespace mongo {

class IndexDescriptor;
class JournalListener;
class OperationContext;
class RecoveryUnit;
class SortedDataInterface;
class SnapshotManager;

class KVEngine {
public:
    virtual RecoveryUnit* newRecoveryUnit() = 0;

    // ---------

    virtual std::unique_ptr<RecordStore> getRecordStore(OperationContext* opCtx,
                                                        StringData ns,
                                                        StringData ident,
                                                        const CollectionOptions& options) = 0;

    virtual std::unique_ptr<RecordStore> getGroupedRecordStore(OperationContext* opCtx,
                                                               StringData ns,
                                                               StringData ident,
                                                               const CollectionOptions& options,
                                                               KVPrefix prefix) {
        invariant(prefix == KVPrefix::kNotPrefixed);
        return getRecordStore(opCtx, ns, ident, options);
    }

    virtual SortedDataInterface* getSortedDataInterface(OperationContext* opCtx,
                                                        StringData ident,
                                                        const IndexDescriptor* desc) = 0;

    virtual SortedDataInterface* getGroupedSortedDataInterface(OperationContext* opCtx,
                                                               StringData ident,
                                                               const IndexDescriptor* desc,
                                                               KVPrefix prefix) {
        invariant(prefix == KVPrefix::kNotPrefixed);
        return getSortedDataInterface(opCtx, ident, desc);
    }

    virtual Status createRecordStore(OperationContext* opCtx,
                                     StringData ns,
                                     StringData ident,
                                     const CollectionOptions& options) = 0;

    virtual Status createGroupedRecordStore(OperationContext* opCtx,
                                            StringData ns,
                                            StringData ident,
                                            const CollectionOptions& options,
                                            KVPrefix prefix) {
        invariant(prefix == KVPrefix::kNotPrefixed);
        return createRecordStore(opCtx, ns, ident, options);
    }

    virtual Status createSortedDataInterface(OperationContext* opCtx,
                                             StringData ident,
                                             const IndexDescriptor* desc) = 0;

    virtual Status createGroupedSortedDataInterface(OperationContext* opCtx,
                                                    StringData ident,
                                                    const IndexDescriptor* desc,
                                                    KVPrefix prefix) {
        invariant(prefix == KVPrefix::kNotPrefixed);
        return createSortedDataInterface(opCtx, ident, desc);
    }

    virtual int64_t getIdentSize(OperationContext* opCtx, StringData ident) = 0;

    virtual Status repairIdent(OperationContext* opCtx, StringData ident) = 0;

    virtual Status dropIdent(OperationContext* opCtx, StringData ident) = 0;

    virtual void alterIdentMetadata(OperationContext* opCtx,
                                    StringData ident,
                                    const IndexDescriptor* desc){};

    // optional
    virtual int flushAllFiles(OperationContext* opCtx, bool sync) {
        return 0;
    }

    virtual Status beginBackup(OperationContext* opCtx) {
        return Status(ErrorCodes::CommandNotSupported,
                      "The current storage engine doesn't support backup mode");
    }

    virtual void endBackup(OperationContext* opCtx) {
        MONGO_UNREACHABLE;
    }

    virtual bool isDurable() const = 0;

    virtual bool isEphemeral() const = 0;

    virtual bool supportsDocLocking() const = 0;

    virtual bool supportsDBLocking() const {
        return true;
    }

    virtual bool supportsCappedCollections() const {
        return true;
    }

    virtual bool supportsDirectoryPerDB() const = 0;

    virtual Status okToRename(OperationContext* opCtx,
                              StringData fromNS,
                              StringData toNS,
                              StringData ident,
                              const RecordStore* originalRecordStore) const {
        return Status::OK();
    }

    virtual bool hasIdent(OperationContext* opCtx, StringData ident) const = 0;

    virtual std::vector<std::string> getAllIdents(OperationContext* opCtx) const = 0;

    virtual void cleanShutdown() = 0;

    virtual SnapshotManager* getSnapshotManager() const {
        return nullptr;
    }

    virtual void setJournalListener(JournalListener* jl) = 0;

    virtual void setStableTimestamp(Timestamp stableTimestamp) {}

    virtual void setInitialDataTimestamp(Timestamp initialDataTimestamp) {}

    virtual void setOldestTimestampFromStable() {}

    virtual void setOldestTimestamp(Timestamp newOldestTimestamp) {}

    virtual bool isCacheUnderPressure(OperationContext* opCtx) const {
        return false;
    }

    virtual void setCachePressureForTest(int pressure) {}

    virtual bool supportsRecoverToStableTimestamp() const {
        return false;
    }

    virtual StatusWith<Timestamp> recoverToStableTimestamp(OperationContext* opCtx) {
        fassertFailed(50664);
    }

    virtual boost::optional<Timestamp> getRecoveryTimestamp() const {
        MONGO_UNREACHABLE;
    }

    virtual boost::optional<Timestamp> getLastStableCheckpointTimestamp() const {
        MONGO_UNREACHABLE;
    }

    virtual Timestamp getAllCommittedTimestamp() const = 0;

    virtual bool supportsReadConcernSnapshot() const {
        return false;
    }

    virtual void replicationBatchIsComplete() const {};

    virtual ~KVEngine() {}
};
}