index_catalog_entry_impl.h

Go to the documentation of this file.

#pragma once

#include <boost/optional.hpp>
#include <string>

#include "mongo/base/owned_pointer_vector.h"
#include "mongo/bson/ordering.h"
#include "mongo/bson/timestamp.h"
#include "mongo/db/catalog/index_catalog_entry.h"
#include "mongo/db/index/multikey_paths.h"
#include "mongo/db/matcher/expression.h"
#include "mongo/db/record_id.h"
#include "mongo/db/storage/kv/kv_prefix.h"
#include "mongo/platform/atomic_word.h"
#include "mongo/stdx/mutex.h"

namespace mongo {

class CollatorInterface;
class CollectionCatalogEntry;
class CollectionInfoCache;
class HeadManager;
class IndexAccessMethod;
class IndexDescriptor;
class MatchExpression;
class OperationContext;

class IndexCatalogEntryImpl : public IndexCatalogEntry::Impl {
    MONGO_DISALLOW_COPYING(IndexCatalogEntryImpl);

public:
    explicit IndexCatalogEntryImpl(
        IndexCatalogEntry* this_,
        OperationContext* opCtx,
        StringData ns,
        CollectionCatalogEntry* collection,           // not owned
        std::unique_ptr<IndexDescriptor> descriptor,  // ownership passes to me
        CollectionInfoCache* infoCache);              // not owned, optional

    ~IndexCatalogEntryImpl() final;

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

    void init(std::unique_ptr<IndexAccessMethod> accessMethod) final;

    IndexDescriptor* descriptor() final {
        return _descriptor.get();
    }
    const IndexDescriptor* descriptor() const final {
        return _descriptor.get();
    }

    IndexAccessMethod* accessMethod() final {
        return _accessMethod.get();
    }
    const IndexAccessMethod* accessMethod() const final {
        return _accessMethod.get();
    }

    const Ordering& ordering() const final {
        return _ordering;
    }

    const MatchExpression* getFilterExpression() const final {
        return _filterExpression.get();
    }

    const CollatorInterface* getCollator() const final {
        return _collator.get();
    }


    const RecordId& head(OperationContext* opCtx) const final;

    void setHead(OperationContext* opCtx, RecordId newHead) final;

    void setIsReady(bool newIsReady) final;

    HeadManager* headManager() const final {
        return _headManager.get();
    }

    // --

    bool isMultikey(OperationContext* opCtx) const final;

    MultikeyPaths getMultikeyPaths(OperationContext* opCtx) const final;

    void setMultikey(OperationContext* opCtx, const MultikeyPaths& multikeyPaths) final;

    // if this ready is ready for queries
    bool isReady(OperationContext* opCtx) const final;

    KVPrefix getPrefix() const final {
        return _prefix;
    }

    boost::optional<Timestamp> getMinimumVisibleSnapshot() final {
        return _minVisibleSnapshot;
    }

    void setMinimumVisibleSnapshot(Timestamp name) final {
        _minVisibleSnapshot = name;
    }

private:
    class SetMultikeyChange;
    class SetHeadChange;

    bool _catalogIsReady(OperationContext* opCtx) const;
    RecordId _catalogHead(OperationContext* opCtx) const;

    bool _catalogIsMultikey(OperationContext* opCtx, MultikeyPaths* multikeyPaths) const;

    KVPrefix _catalogGetPrefix(OperationContext* opCtx) const;

    // -----

    std::string _ns;

    CollectionCatalogEntry* _collection;  // not owned here

    std::unique_ptr<IndexDescriptor> _descriptor;  // owned here

    CollectionInfoCache* _infoCache;  // not owned here

    std::unique_ptr<IndexAccessMethod> _accessMethod;

    // Owned here.
    std::unique_ptr<HeadManager> _headManager;
    std::unique_ptr<CollatorInterface> _collator;
    std::unique_ptr<MatchExpression> _filterExpression;

    // cached stuff

    Ordering _ordering;  // TODO: this might be b-tree specific
    bool _isReady;       // cache of NamespaceDetails info
    RecordId _head;      // cache of IndexDetails

    // Set to true if this index supports path-level multikey tracking.
    // '_indexTracksPathLevelMultikeyInfo' is effectively const after IndexCatalogEntry::init() is
    // called.
    bool _indexTracksPathLevelMultikeyInfo = false;

    // Set to true if this index is multikey. '_isMultikey' serves as a cache of the information
    // stored in the NamespaceDetails or KVCatalog.
    AtomicWord<bool> _isMultikey;

    // Controls concurrent access to '_indexMultikeyPaths'. We acquire this mutex rather than the
    // RESOURCE_METADATA lock as a performance optimization so that it is cheaper to detect whether
    // there is actually any path-level multikey information to update or not.
    mutable stdx::mutex _indexMultikeyPathsMutex;

    // Non-empty only if '_indexTracksPathLevelMultikeyInfo' is true.
    //
    // If non-empty, '_indexMultikeyPaths' is a vector with size equal to the number of elements
    // in the index key pattern. Each element in the vector is an ordered set of positions (starting
    // at 0) into the corresponding indexed field that represent what prefixes of the indexed field
    // causes the index to be multikey.
    MultikeyPaths _indexMultikeyPaths;

    // KVPrefix used to differentiate between index entries in different logical indexes sharing the
    // same underlying sorted data interface.
    const KVPrefix _prefix;

    // The earliest snapshot that is allowed to read this index.
    boost::optional<Timestamp> _minVisibleSnapshot;
};
}  // namespace mongo