collection_info_cache.h

Go to the documentation of this file.

#pragma once

#include "mongo/base/shim.h"
#include "mongo/db/collection_index_usage_tracker.h"
#include "mongo/db/query/plan_cache.h"
#include "mongo/db/query/query_settings.h"
#include "mongo/db/update_index_data.h"
#include "mongo/stdx/functional.h"

namespace mongo {
class Collection;
class IndexDescriptor;
class OperationContext;

class CollectionInfoCache {
public:
    class Impl {
    public:
        virtual ~Impl() = 0;

        virtual PlanCache* getPlanCache() const = 0;

        virtual QuerySettings* getQuerySettings() const = 0;

        virtual const UpdateIndexData& getIndexKeys(OperationContext* opCtx) const = 0;

        virtual CollectionIndexUsageMap getIndexUsageStats() const = 0;

        virtual void init(OperationContext* opCtx) = 0;

        virtual void addedIndex(OperationContext* opCtx, const IndexDescriptor* desc) = 0;

        virtual void droppedIndex(OperationContext* opCtx, StringData indexName) = 0;

        virtual void clearQueryCache() = 0;

        virtual void notifyOfQuery(OperationContext* opCtx,
                                   const std::set<std::string>& indexesUsed) = 0;
    };


public:
    static MONGO_DECLARE_SHIM((Collection * collection,
                               const NamespaceString& ns,
                               PrivateTo<CollectionInfoCache>)
                                  ->std::unique_ptr<Impl>) makeImpl;

    explicit inline CollectionInfoCache(Collection* const collection, const NamespaceString& ns)
        : _pimpl(makeImpl(collection, ns, PrivateCall<CollectionInfoCache>{})) {}

    inline ~CollectionInfoCache() = default;

    inline void init(OperationContext* const opCtx) {
        return this->_impl().init(opCtx);
    }

    inline PlanCache* getPlanCache() const {
        return this->_impl().getPlanCache();
    }

    inline QuerySettings* getQuerySettings() const {
        return this->_impl().getQuerySettings();
    }

    /* get set of index keys for this namespace.  handy to quickly check if a given
       field is indexed (Note it might be a secondary component of a compound index.)
    */
    inline const UpdateIndexData& getIndexKeys(OperationContext* const opCtx) const {
        return this->_impl().getIndexKeys(opCtx);
    }

    inline CollectionIndexUsageMap getIndexUsageStats() const {
        return this->_impl().getIndexUsageStats();
    }

    inline void addedIndex(OperationContext* const opCtx, const IndexDescriptor* const desc) {
        return this->_impl().addedIndex(opCtx, desc);
    }

    inline void droppedIndex(OperationContext* const opCtx, const StringData indexName) {
        return this->_impl().droppedIndex(opCtx, indexName);
    }

    inline void clearQueryCache() {
        return this->_impl().clearQueryCache();
    }

    inline void notifyOfQuery(OperationContext* const opCtx,
                              const std::set<std::string>& indexesUsed) {
        return this->_impl().notifyOfQuery(opCtx, indexesUsed);
    }

    std::unique_ptr<Impl> _pimpl;

    // This structure exists to give us a customization point to decide how to force users of this
    // class to depend upon the corresponding `collection_info_cache.cpp` Translation Unit (TU).
    // All public forwarding functions call `_impl(), and `_impl` creates an instance of this
    // structure.
    struct TUHook {
        static void hook() noexcept;

        explicit inline TUHook() noexcept {
            if (kDebugBuild)
                this->hook();
        }
    };

    inline const Impl& _impl() const {
        TUHook{};
        return *this->_pimpl;
    }

    inline Impl& _impl() {
        TUHook{};
        return *this->_pimpl;
    }
};
}  // namespace mongo