index_create_impl.h

Go to the documentation of this file.

#pragma once

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

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

#include "mongo/base/disallow_copying.h"
#include "mongo/base/status.h"
#include "mongo/db/catalog/index_catalog.h"
#include "mongo/db/catalog/index_catalog_impl.h"
#include "mongo/db/index/index_access_method.h"
#include "mongo/db/record_id.h"

namespace mongo {

class BackgroundOperation;
class BSONObj;
class Collection;
class OperationContext;

class MultiIndexBlockImpl : public MultiIndexBlock::Impl {
    MONGO_DISALLOW_COPYING(MultiIndexBlockImpl);

public:
    MultiIndexBlockImpl(OperationContext* opCtx, Collection* collection);
    ~MultiIndexBlockImpl() override;

    void allowBackgroundBuilding() override {
        _buildInBackground = true;
    }

    void allowInterruption() override {
        _allowInterruption = true;
    }

    void ignoreUniqueConstraint() override {
        _ignoreUnique = true;
    }

    void removeExistingIndexes(std::vector<BSONObj>* specs) const override;

    StatusWith<std::vector<BSONObj>> init(const std::vector<BSONObj>& specs) override;
    StatusWith<std::vector<BSONObj>> init(const BSONObj& spec) override;

    Status insertAllDocumentsInCollection(std::set<RecordId>* dupsOut = nullptr) override;

    Status insert(const BSONObj& wholeDocument, const RecordId& loc) override;

    Status doneInserting(std::set<RecordId>* dupsOut = nullptr) override;

    void commit(stdx::function<void(const BSONObj& spec)> onCreateFn) override;

    void abortWithoutCleanup() override;

    bool getBuildInBackground() const override {
        return _buildInBackground;
    }

private:
    class SetNeedToCleanupOnRollback;
    class CleanupIndexesVectorOnRollback;

    struct IndexToBuild {
        std::unique_ptr<IndexCatalogImpl::IndexBuildBlock> block;

        IndexAccessMethod* real = NULL;           // owned elsewhere
        const MatchExpression* filterExpression;  // might be NULL, owned elsewhere
        std::unique_ptr<IndexAccessMethod::BulkBuilder> bulk;

        InsertDeleteOptions options;
    };

    virtual bool initBackgroundIndexFromSpec(const BSONObj& spec) const = 0;

    std::vector<IndexToBuild> _indexes;

    std::unique_ptr<BackgroundOperation> _backgroundOperation;

    // Pointers not owned here and must outlive 'this'
    Collection* _collection;
    OperationContext* _opCtx;

    bool _buildInBackground;
    bool _allowInterruption;
    bool _ignoreUnique;

    bool _needToCleanup;
};

}  // namespace mongo