wiredtiger_index.h

Go to the documentation of this file.

#pragma once

#include <wiredtiger.h>

#include "mongo/base/status_with.h"
#include "mongo/db/storage/index_entry_comparison.h"
#include "mongo/db/storage/key_string.h"
#include "mongo/db/storage/kv/kv_prefix.h"
#include "mongo/db/storage/sorted_data_interface.h"
#include "mongo/db/storage/wiredtiger/wiredtiger_prepare_conflict.h"
#include "mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h"

namespace mongo {

class IndexCatalogEntry;
class IndexDescriptor;
struct WiredTigerItem;

class WiredTigerIndex : public SortedDataInterface {
public:
    static StatusWith<std::string> parseIndexOptions(const BSONObj& options);

    static std::string generateAppMetadataString(const IndexDescriptor& desc);

    static StatusWith<std::string> generateCreateString(const std::string& engineName,
                                                        const std::string& sysIndexConfig,
                                                        const std::string& collIndexConfig,
                                                        const IndexDescriptor& desc,
                                                        bool isPrefixed);

    static int Create(OperationContext* opCtx, const std::string& uri, const std::string& config);

    WiredTigerIndex(OperationContext* ctx,
                    const std::string& uri,
                    const IndexDescriptor* desc,
                    KVPrefix prefix,
                    bool readOnly);

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

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

    virtual void fullValidate(OperationContext* opCtx,
                              long long* numKeysOut,
                              ValidateResults* fullResults) const;
    virtual bool appendCustomStats(OperationContext* opCtx,
                                   BSONObjBuilder* output,
                                   double scale) const;
    virtual Status dupKeyCheck(OperationContext* opCtx, const BSONObj& key, const RecordId& id);

    virtual bool isEmpty(OperationContext* opCtx);

    virtual Status touch(OperationContext* opCtx) const;

    virtual long long getSpaceUsedBytes(OperationContext* opCtx) const;

    virtual Status initAsEmpty(OperationContext* opCtx);

    virtual Status compact(OperationContext* opCtx);

    const std::string& uri() const {
        return _uri;
    }

    // WiredTigerIndex additions

    virtual bool isDup(OperationContext* opCtx,
                       WT_CURSOR* c,
                       const BSONObj& key,
                       const RecordId& id);

    uint64_t tableId() const {
        return _tableId;
    }
    Ordering ordering() const {
        return _ordering;
    }

    KeyString::Version keyStringVersion() const {
        return _keyStringVersion;
    }

    std::string collectionNamespace() const {
        return _collectionNamespace;
    }

    std::string indexName() const {
        return _indexName;
    }

    bool isIdIndex() const {
        return _isIdIndex;
    }

    virtual bool unique() const = 0;
    virtual bool isTimestampSafeUniqueIdx() const = 0;

    Status dupKeyError(const BSONObj& key);

protected:
    virtual Status _insert(OperationContext* opCtx,
                           WT_CURSOR* c,
                           const BSONObj& key,
                           const RecordId& id,
                           bool dupsAllowed) = 0;

    virtual void _unindex(OperationContext* opCtx,
                          WT_CURSOR* c,
                          const BSONObj& key,
                          const RecordId& id,
                          bool dupsAllowed) = 0;

    void setKey(WT_CURSOR* cursor, const WT_ITEM* item);

    class BulkBuilder;
    class StandardBulkBuilder;
    class UniqueBulkBuilder;

    const Ordering _ordering;
    // The keystring and data format version are effectively const after the WiredTigerIndex
    // instance is constructed.
    KeyString::Version _keyStringVersion;
    int _dataFormatVersion;
    std::string _uri;
    uint64_t _tableId;
    std::string _collectionNamespace;
    std::string _indexName;
    KVPrefix _prefix;
    bool _isIdIndex;
};

class WiredTigerIndexUnique : public WiredTigerIndex {
public:
    WiredTigerIndexUnique(OperationContext* ctx,
                          const std::string& uri,
                          const IndexDescriptor* desc,
                          KVPrefix prefix,
                          bool readOnly = false);

    std::unique_ptr<SortedDataInterface::Cursor> newCursor(OperationContext* opCtx,
                                                           bool forward) const override;

    SortedDataBuilderInterface* getBulkBuilder(OperationContext* opCtx, bool dupsAllowed) override;

    bool unique() const override {
        return true;
    }

    bool isTimestampSafeUniqueIdx() const override;

    bool isDup(OperationContext* opCtx,
               WT_CURSOR* c,
               const BSONObj& key,
               const RecordId& id) override;

    Status _insert(OperationContext* opCtx,
                   WT_CURSOR* c,
                   const BSONObj& key,
                   const RecordId& id,
                   bool dupsAllowed) override;

    Status _insertTimestampUnsafe(OperationContext* opCtx,
                                  WT_CURSOR* c,
                                  const BSONObj& key,
                                  const RecordId& id,
                                  bool dupsAllowed);

    Status _insertTimestampSafe(OperationContext* opCtx,
                                WT_CURSOR* c,
                                const BSONObj& key,
                                const RecordId& id,
                                bool dupsAllowed);

    void _unindex(OperationContext* opCtx,
                  WT_CURSOR* c,
                  const BSONObj& key,
                  const RecordId& id,
                  bool dupsAllowed) override;

    void _unindexTimestampUnsafe(OperationContext* opCtx,
                                 WT_CURSOR* c,
                                 const BSONObj& key,
                                 const RecordId& id,
                                 bool dupsAllowed);

    void _unindexTimestampSafe(OperationContext* opCtx,
                               WT_CURSOR* c,
                               const BSONObj& key,
                               const RecordId& id,
                               bool dupsAllowed);

private:
    bool _partial;
};

class WiredTigerIndexStandard : public WiredTigerIndex {
public:
    WiredTigerIndexStandard(OperationContext* ctx,
                            const std::string& uri,
                            const IndexDescriptor* desc,
                            KVPrefix prefix,
                            bool readOnly = false);

    std::unique_ptr<SortedDataInterface::Cursor> newCursor(OperationContext* opCtx,
                                                           bool forward) const override;

    SortedDataBuilderInterface* getBulkBuilder(OperationContext* opCtx, bool dupsAllowed) override;

    bool unique() const override {
        return false;
    }

    bool isTimestampSafeUniqueIdx() const override {
        return false;
    }

    Status _insert(OperationContext* opCtx,
                   WT_CURSOR* c,
                   const BSONObj& key,
                   const RecordId& id,
                   bool dupsAllowed) override;

    void _unindex(OperationContext* opCtx,
                  WT_CURSOR* c,
                  const BSONObj& key,
                  const RecordId& id,
                  bool dupsAllowed) override;
};

}  // namespace