sorted_data_interface.h

Go to the documentation of this file.

#include <boost/optional/optional.hpp>
#include <boost/optional/optional_io.hpp>
#include <memory>

#include "mongo/db/jsobj.h"
#include "mongo/db/operation_context.h"
#include "mongo/db/record_id.h"
#include "mongo/db/storage/index_entry_comparison.h"

#pragma once

namespace mongo {

class BSONObjBuilder;
class BucketDeletionNotification;
class SortedDataBuilderInterface;
struct ValidateResults;

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

    //
    // Data changes
    //

    virtual SortedDataBuilderInterface* getBulkBuilder(OperationContext* opCtx,
                                                       bool dupsAllowed) = 0;

    virtual Status insert(OperationContext* opCtx,
                          const BSONObj& key,
                          const RecordId& loc,
                          bool dupsAllowed) = 0;

    virtual void unindex(OperationContext* opCtx,
                         const BSONObj& key,
                         const RecordId& loc,
                         bool dupsAllowed) = 0;

    virtual Status dupKeyCheck(OperationContext* opCtx,
                               const BSONObj& key,
                               const RecordId& loc) = 0;

    virtual Status compact(OperationContext* opCtx) {
        return Status::OK();
    }

    //
    // Information about the tree
    //

    virtual void fullValidate(OperationContext* opCtx,
                              long long* numKeysOut,
                              ValidateResults* fullResults) const = 0;

    virtual bool appendCustomStats(OperationContext* opCtx,
                                   BSONObjBuilder* output,
                                   double scale) const = 0;


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

    virtual bool isEmpty(OperationContext* opCtx) = 0;

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

    virtual long long numEntries(OperationContext* opCtx) const {
        long long x = -1;
        fullValidate(opCtx, &x, NULL);
        return x;
    }

    class Cursor {
    public:
        enum RequestedInfo {
            // Only usable part of the return is whether it is engaged or not.
            kJustExistance = 0,
            // Key must be filled in.
            kWantKey = 1,
            // Loc must be fulled in.
            kWantLoc = 2,
            // Both must be returned.
            kKeyAndLoc = kWantKey | kWantLoc,
        };

        virtual ~Cursor() = default;


        virtual void setEndPosition(const BSONObj& key, bool inclusive) = 0;

        virtual boost::optional<IndexKeyEntry> next(RequestedInfo parts = kKeyAndLoc) = 0;

        //
        // Seeking
        //

        virtual boost::optional<IndexKeyEntry> seek(const BSONObj& key,
                                                    bool inclusive,
                                                    RequestedInfo parts = kKeyAndLoc) = 0;

        virtual boost::optional<IndexKeyEntry> seek(const IndexSeekPoint& seekPoint,
                                                    RequestedInfo parts = kKeyAndLoc) = 0;

        virtual boost::optional<IndexKeyEntry> seekExact(const BSONObj& key,
                                                         RequestedInfo parts = kKeyAndLoc) {
            auto kv = seek(key, true, kKeyAndLoc);
            if (kv && kv->key.woCompare(key, BSONObj(), /*considerFieldNames*/ false) == 0)
                return kv;
            return {};
        }

        //
        // Saving and restoring state
        //

        virtual void save() = 0;

        virtual void saveUnpositioned() {
            save();
        }

        virtual void restore() = 0;

        virtual void detachFromOperationContext() = 0;

        virtual void reattachToOperationContext(OperationContext* opCtx) = 0;
    };

    virtual std::unique_ptr<Cursor> newCursor(OperationContext* opCtx,
                                              bool isForward = true) const = 0;

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

    //
    // Index creation
    //

    virtual Status initAsEmpty(OperationContext* opCtx) = 0;
};

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

    virtual Status addKey(const BSONObj& key, const RecordId& loc) = 0;

    virtual void commit(bool mayInterrupt) {}
};

}  // namespace mongo