index_catalog_impl.h

Go to the documentation of this file.

#pragma once

#include <vector>

#include "mongo/db/catalog/index_catalog.h"

#include "mongo/db/catalog/index_catalog_entry.h"
#include "mongo/db/index/multikey_paths.h"
#include "mongo/db/jsobj.h"
#include "mongo/db/operation_context.h"
#include "mongo/db/record_id.h"
#include "mongo/db/server_options.h"
#include "mongo/db/storage/record_store.h"

namespace mongo {

class Client;
class Collection;

class IndexDescriptor;
class IndexAccessMethod;
struct InsertDeleteOptions;

class IndexCatalogImpl : public IndexCatalog::Impl {
public:
    explicit IndexCatalogImpl(IndexCatalog* this_,
                              Collection* collection,
                              int maxNumIndexesAllowed);
    ~IndexCatalogImpl() override;

    // must be called before used
    Status init(OperationContext* opCtx) override;

    bool ok() const override;

    // ---- accessors -----

    bool haveAnyIndexes() const override;
    int numIndexesTotal(OperationContext* opCtx) const override;
    int numIndexesReady(OperationContext* opCtx) const override;
    int numIndexesInProgress(OperationContext* opCtx) const {
        return numIndexesTotal(opCtx) - numIndexesReady(opCtx);
    }

    bool haveIdIndex(OperationContext* opCtx) const override;

    BSONObj getDefaultIdIndexSpec() const override;

    IndexDescriptor* findIdIndex(OperationContext* opCtx) const override;

    IndexDescriptor* findIndexByName(OperationContext* opCtx,
                                     StringData name,
                                     bool includeUnfinishedIndexes = false) const override;

    IndexDescriptor* findIndexByKeyPatternAndCollationSpec(
        OperationContext* opCtx,
        const BSONObj& key,
        const BSONObj& collationSpec,
        bool includeUnfinishedIndexes = false) const override;

    void findIndexesByKeyPattern(OperationContext* opCtx,
                                 const BSONObj& key,
                                 bool includeUnfinishedIndexes,
                                 std::vector<IndexDescriptor*>* matches) const override;

    IndexDescriptor* findShardKeyPrefixedIndex(OperationContext* opCtx,
                                               const BSONObj& shardKey,
                                               bool requireSingleKey) const override;

    void findIndexByType(OperationContext* opCtx,
                         const std::string& type,
                         std::vector<IndexDescriptor*>& matches,
                         bool includeUnfinishedIndexes = false) const override;


    const IndexDescriptor* refreshEntry(OperationContext* opCtx,
                                        const IndexDescriptor* oldDesc) override;

    // never returns NULL
    const IndexCatalogEntry* getEntry(const IndexDescriptor* desc) const override;

    IndexAccessMethod* getIndex(const IndexDescriptor* desc) override;
    const IndexAccessMethod* getIndex(const IndexDescriptor* desc) const override;

    Status checkUnfinished() const override;

    class IndexIteratorImpl : public IndexCatalog::IndexIterator::Impl {
    public:
        IndexIteratorImpl(OperationContext* opCtx,
                          const IndexCatalog* cat,
                          bool includeUnfinishedIndexes);

        bool more() override;
        IndexDescriptor* next() override;

        // returns the access method for the last return IndexDescriptor
        IndexAccessMethod* accessMethod(const IndexDescriptor* desc) override;

        // returns the IndexCatalogEntry for the last return IndexDescriptor
        IndexCatalogEntry* catalogEntry(const IndexDescriptor* desc) override;

    private:
        IndexIteratorImpl* clone_impl() const override;

        void _advance();

        bool _includeUnfinishedIndexes;

        OperationContext* const _opCtx;
        const IndexCatalog* _catalog;
        IndexCatalogEntryContainer::const_iterator _iterator;

        bool _start;  // only true before we've called next() or more()

        IndexCatalogEntry* _prev;
        IndexCatalogEntry* _next;

        friend class IndexCatalog;
    };

    using IndexIterator = IndexCatalog::IndexIterator;

    // ---- index set modifiers ------

    StatusWith<BSONObj> createIndexOnEmptyCollection(OperationContext* opCtx,
                                                     BSONObj spec) override;

    StatusWith<BSONObj> prepareSpecForCreate(OperationContext* opCtx,
                                             const BSONObj& original) const override;

    void dropAllIndexes(OperationContext* opCtx,
                        bool includingIdIndex,
                        stdx::function<void(const IndexDescriptor*)> onDropFn = nullptr) override;

    Status dropIndex(OperationContext* opCtx, IndexDescriptor* desc) override;

    std::vector<BSONObj> getAndClearUnfinishedIndexes(OperationContext* opCtx) override;


    struct IndexKillCriteria {
        std::string ns;
        std::string name;
        BSONObj key;
    };

    // ---- modify single index

    bool isMultikey(OperationContext* opCtx, const IndexDescriptor* idx) override;

    MultikeyPaths getMultikeyPaths(OperationContext* opCtx, const IndexDescriptor* idx) override;

    // --- these probably become private?


    class IndexBuildBlock {
        MONGO_DISALLOW_COPYING(IndexBuildBlock);

    public:
        IndexBuildBlock(OperationContext* opCtx, Collection* collection, const BSONObj& spec);

        ~IndexBuildBlock();

        Status init();

        void success();

        void fail();

        IndexCatalogEntry* getEntry() {
            return _entry;
        }

        const std::string& getIndexName() const {
            return _indexName;
        }

        const BSONObj& getSpec() const {
            return _spec;
        }

    private:
        Collection* const _collection;
        IndexCatalog* const _catalog;
        const std::string _ns;

        BSONObj _spec;

        std::string _indexName;
        std::string _indexNamespace;

        IndexCatalogEntry* _entry;
        bool _inProgress;

        OperationContext* _opCtx;
    };

    // ----- data modifiers ------

    Status indexRecords(OperationContext* opCtx,
                        const std::vector<BsonRecord>& bsonRecords,
                        int64_t* keysInsertedOut) override;

    void unindexRecord(OperationContext* opCtx,
                       const BSONObj& obj,
                       const RecordId& loc,
                       bool noWarn,
                       int64_t* keysDeletedOut) override;

    // ------- temp internal -------

    inline std::string getAccessMethodName(OperationContext* opCtx,
                                           const BSONObj& keyPattern) override {
        return _getAccessMethodName(opCtx, keyPattern);
    }

    Status _upgradeDatabaseMinorVersionIfNeeded(OperationContext* opCtx,
                                                const std::string& newPluginName) override;

    // public static helpers

    static BSONObj fixIndexKey(const BSONObj& key);

    static void prepareInsertDeleteOptions(OperationContext* opCtx,
                                           const IndexDescriptor* desc,
                                           InsertDeleteOptions* options);

private:
    static const BSONObj _idObj;  // { _id : 1 }

    bool _shouldOverridePlugin(OperationContext* opCtx, const BSONObj& keyPattern) const;

    std::string _getAccessMethodName(OperationContext* opCtx, const BSONObj& keyPattern) const;

    void _checkMagic() const;

    Status _indexFilteredRecords(OperationContext* opCtx,
                                 IndexCatalogEntry* index,
                                 const std::vector<BsonRecord>& bsonRecords,
                                 int64_t* keysInsertedOut);

    Status _indexRecords(OperationContext* opCtx,
                         IndexCatalogEntry* index,
                         const std::vector<BsonRecord>& bsonRecords,
                         int64_t* keysInsertedOut);

    Status _unindexRecord(OperationContext* opCtx,
                          IndexCatalogEntry* index,
                          const BSONObj& obj,
                          const RecordId& loc,
                          bool logIfError,
                          int64_t* keysDeletedOut);

    inline const IndexCatalogEntryContainer& _getEntries() const override {
        return this->_entries;
    }

    inline IndexCatalogEntryContainer& _getEntries() override {
        return this->_entries;
    }

    Status _dropIndex(OperationContext* opCtx, IndexCatalogEntry* entry) override;

    // just does disk hanges
    // doesn't change memory state, etc...
    void _deleteIndexFromDisk(OperationContext* opCtx,
                              const std::string& indexName,
                              const std::string& indexNamespace);

    // descriptor ownership passes to _setupInMemoryStructures
    // initFromDisk: Avoids registering a change to undo this operation when set to true.
    //               You must set this flag if calling this function outside of a UnitOfWork.
    IndexCatalogEntry* _setupInMemoryStructures(OperationContext* opCtx,
                                                std::unique_ptr<IndexDescriptor> descriptor,
                                                bool initFromDisk);

    // Apply a set of transformations to the user-provided index object 'spec' to make it
    // conform to the standard for insertion.  This function adds the 'v' field if it didn't
    // exist, removes the '_id' field if it exists, applies plugin-level transformations if
    // appropriate, etc.
    static StatusWith<BSONObj> _fixIndexSpec(OperationContext* opCtx,
                                             Collection* collection,
                                             const BSONObj& spec);

    Status _isSpecOk(OperationContext* opCtx, const BSONObj& spec) const;

    Status _doesSpecConflictWithExisting(OperationContext* opCtx, const BSONObj& spec) const;

    inline const Collection* _getCollection() const override {
        return this->_collection;
    }

    inline Collection* _getCollection() override {
        return this->_collection;
    }


    int _magic;
    Collection* const _collection;
    const int _maxNumIndexesAllowed;

    IndexCatalogEntryContainer _entries;

    // These are the index specs of indexes that were "leftover".
    // "Leftover" means they were unfinished when a mongod shut down.
    // Certain operations are prohibited until someone fixes.
    // Retrieve by calling getAndClearUnfinishedIndexes().
    std::vector<BSONObj> _unfinishedIndexes;

    IndexCatalog* const _this;


    inline static IndexCatalogEntry* _setupInMemoryStructures(
        IndexCatalog* const this_,
        OperationContext* const opCtx,
        std::unique_ptr<IndexDescriptor> descriptor,
        const bool initFromDisk) {
        return this_->_setupInMemoryStructures(opCtx, std::move(descriptor), initFromDisk);
    }

    inline static Status _dropIndex(IndexCatalog* const this_,
                                    OperationContext* const opCtx,
                                    IndexCatalogEntry* const desc) {
        return this_->_dropIndex(opCtx, desc);
    }
};
}  // namespace mongo