record_store.h

Go to the documentation of this file.

// record_store.h

#pragma once

#include <boost/optional.hpp>

#include "mongo/base/owned_pointer_vector.h"
#include "mongo/bson/mutable/damage_vector.h"
#include "mongo/db/exec/collection_scan_common.h"
#include "mongo/db/record_id.h"
#include "mongo/db/storage/record_data.h"
#include "mongo/db/storage/record_fetcher.h"

namespace mongo {

class CappedCallback;
class Collection;
struct CompactOptions;
struct CompactStats;
class MAdvise;
class NamespaceDetails;
class OperationContext;
class RecordFetcher;

class RecordStoreCompactAdaptor;
class RecordStore;

struct ValidateResults;
class ValidateAdaptor;

class DocWriter {
public:
    virtual void writeDocument(char* buf) const = 0;
    virtual size_t documentSize() const = 0;
    virtual bool addPadding() const {
        return true;
    }

protected:
    // Can't delete through base pointer.
    ~DocWriter() = default;
};

class UpdateNotifier {
public:
    virtual ~UpdateNotifier() {}
    virtual Status recordStoreGoingToUpdateInPlace(OperationContext* opCtx,
                                                   const RecordId& loc) = 0;
};

struct Record {
    RecordId id;
    RecordData data;
};

enum ValidateCmdLevel : int {
    kValidateIndex = 0x01,
    kValidateRecordStore = 0x02,
    kValidateFull = 0x03
};


class RecordCursor {
public:
    virtual ~RecordCursor() = default;

    virtual boost::optional<Record> next() = 0;

    //
    // Saving and restoring state
    //

    virtual void save() = 0;

    virtual bool restore() = 0;

    virtual void detachFromOperationContext() = 0;

    virtual void reattachToOperationContext(OperationContext* opCtx) = 0;

    virtual void invalidate(OperationContext* opCtx, const RecordId& id) {}

    //
    // RecordFetchers
    //
    // Storage engines which do not support document-level locking hold locks at collection or
    // database granularity. As an optimization, these locks can be yielded when a record needs
    // to be fetched from secondary storage. If this method returns non-NULL, then it indicates
    // that the query system layer should yield its locks, following the protocol defined by the
    // RecordFetcher class, so that a potential page fault is triggered out of the lock.
    //
    // Storage engines which support document-level locking need not implement this.
    //
    // TODO see if these can be replaced by WriteConflictException.
    //

    virtual std::unique_ptr<RecordFetcher> fetcherForNext() const {
        return {};
    }
};

class SeekableRecordCursor : public RecordCursor {
public:
    virtual boost::optional<Record> seekExact(const RecordId& id) = 0;

    virtual void saveUnpositioned() {
        save();
    }

    virtual std::unique_ptr<RecordFetcher> fetcherForId(const RecordId& id) const {
        return {};
    }
};

class RecordStore {
    MONGO_DISALLOW_COPYING(RecordStore);

public:
    RecordStore(StringData ns) : _ns(ns.toString()) {}

    virtual ~RecordStore() {}

    // META

    // name of the RecordStore implementation
    virtual const char* name() const = 0;

    virtual const std::string& ns() const {
        return _ns;
    }

    virtual long long dataSize(OperationContext* opCtx) const = 0;

    virtual long long numRecords(OperationContext* opCtx) const = 0;

    virtual bool isCapped() const = 0;

    virtual void setCappedCallback(CappedCallback*) {
        MONGO_UNREACHABLE;
    }

    virtual int64_t storageSize(OperationContext* opCtx,
                                BSONObjBuilder* extraInfo = NULL,
                                int infoLevel = 0) const = 0;

    // CRUD related

    virtual RecordData dataFor(OperationContext* opCtx, const RecordId& loc) const {
        RecordData data;
        invariant(findRecord(opCtx, loc, &data));
        return data;
    }

    virtual bool findRecord(OperationContext* opCtx, const RecordId& loc, RecordData* out) const {
        auto cursor = getCursor(opCtx);
        auto record = cursor->seekExact(loc);
        if (!record)
            return false;

        record->data.makeOwned();  // Unowned data expires when cursor goes out of scope.
        *out = std::move(record->data);
        return true;
    }

    virtual void deleteRecord(OperationContext* opCtx, const RecordId& dl) = 0;

    virtual StatusWith<RecordId> insertRecord(OperationContext* opCtx,
                                              const char* data,
                                              int len,
                                              Timestamp timestamp,
                                              bool enforceQuota) = 0;

    virtual Status insertRecords(OperationContext* opCtx,
                                 std::vector<Record>* records,
                                 std::vector<Timestamp>* timestamps,
                                 bool enforceQuota) {
        int index = 0;
        for (auto& record : *records) {
            StatusWith<RecordId> res = insertRecord(opCtx,
                                                    record.data.data(),
                                                    record.data.size(),
                                                    (*timestamps)[index++],
                                                    enforceQuota);
            if (!res.isOK())
                return res.getStatus();

            record.id = res.getValue();
        }
        return Status::OK();
    }

    virtual Status insertRecordsWithDocWriter(OperationContext* opCtx,
                                              const DocWriter* const* docs,
                                              const Timestamp* timestamps,
                                              size_t nDocs,
                                              RecordId* idsOut = nullptr) = 0;

    StatusWith<RecordId> insertRecordWithDocWriter(OperationContext* opCtx,
                                                   const DocWriter* doc,
                                                   Timestamp timestamp) {
        RecordId out;
        Status status = insertRecordsWithDocWriter(opCtx, &doc, &timestamp, 1, &out);
        if (!status.isOK())
            return status;
        return out;
    }

    virtual Status updateRecord(OperationContext* opCtx,
                                const RecordId& oldLocation,
                                const char* data,
                                int len,
                                bool enforceQuota,
                                UpdateNotifier* notifier) = 0;

    virtual bool updateWithDamagesSupported() const = 0;

    virtual StatusWith<RecordData> updateWithDamages(OperationContext* opCtx,
                                                     const RecordId& loc,
                                                     const RecordData& oldRec,
                                                     const char* damageSource,
                                                     const mutablebson::DamageVector& damages) = 0;

    virtual std::unique_ptr<SeekableRecordCursor> getCursor(OperationContext* opCtx,
                                                            bool forward = true) const = 0;

    virtual std::unique_ptr<RecordCursor> getCursorForRepair(OperationContext* opCtx) const {
        return {};
    }

    virtual std::unique_ptr<RecordCursor> getRandomCursor(OperationContext* opCtx) const {
        return {};
    }

    virtual std::vector<std::unique_ptr<RecordCursor>> getManyCursors(
        OperationContext* opCtx) const {
        std::vector<std::unique_ptr<RecordCursor>> out(1);
        out[0] = getCursor(opCtx);
        return out;
    }

    // higher level


    virtual Status truncate(OperationContext* opCtx) = 0;

    virtual void cappedTruncateAfter(OperationContext* opCtx, RecordId end, bool inclusive) = 0;

    virtual bool compactSupported() const {
        return false;
    }

    virtual bool compactsInPlace() const {
        MONGO_UNREACHABLE;
    }

    virtual Status compact(OperationContext* opCtx,
                           RecordStoreCompactAdaptor* adaptor,
                           const CompactOptions* options,
                           CompactStats* stats) {
        MONGO_UNREACHABLE;
    }

    virtual bool isInRecordIdOrder() const {
        return false;
    }

    virtual Status validate(OperationContext* opCtx,
                            ValidateCmdLevel level,
                            ValidateAdaptor* adaptor,
                            ValidateResults* results,
                            BSONObjBuilder* output) = 0;

    virtual void appendCustomStats(OperationContext* opCtx,
                                   BSONObjBuilder* result,
                                   double scale) const = 0;

    virtual Status touch(OperationContext* opCtx, BSONObjBuilder* output) const {
        return Status(ErrorCodes::CommandNotSupported,
                      "this storage engine does not support touch");
    }

    virtual boost::optional<RecordId> oplogStartHack(OperationContext* opCtx,
                                                     const RecordId& startingPosition) const {
        return boost::none;
    }

    virtual Status oplogDiskLocRegister(OperationContext* opCtx,
                                        const Timestamp& opTime,
                                        bool orderedCommit) {
        return Status::OK();
    }

    virtual void waitForAllEarlierOplogWritesToBeVisible(OperationContext* opCtx) const = 0;

    virtual void updateStatsAfterRepair(OperationContext* opCtx,
                                        long long numRecords,
                                        long long dataSize) = 0;

    virtual Status updateCappedSize(OperationContext* opCtx, long long cappedSize) {
        return Status(ErrorCodes::CommandNotSupported,
                      "this storage engine does not support updateCappedSize");
    }

protected:
    std::string _ns;
};

class RecordStoreCompactAdaptor {
public:
    virtual ~RecordStoreCompactAdaptor() {}
    virtual bool isDataValid(const RecordData& recData) = 0;
    virtual size_t dataSize(const RecordData& recData) = 0;
    virtual void inserted(const RecordData& recData, const RecordId& newLocation) = 0;
};

struct ValidateResults {
    ValidateResults() {
        valid = true;
    }
    bool valid;
    std::vector<std::string> errors;
    std::vector<std::string> warnings;
};

class ValidateAdaptor {
public:
    virtual ~ValidateAdaptor() {}

    virtual Status validate(const RecordId& recordId,
                            const RecordData& recordData,
                            size_t* dataSize) = 0;
};
}