database.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <string>

#include "mongo/base/shim.h"
#include "mongo/base/status.h"
#include "mongo/base/string_data.h"
#include "mongo/bson/bsonobj.h"
#include "mongo/db/catalog/collection.h"
#include "mongo/db/catalog/collection_options.h"
#include "mongo/db/namespace_string.h"
#include "mongo/db/repl/optime.h"
#include "mongo/db/storage/storage_options.h"
#include "mongo/db/views/view.h"
#include "mongo/db/views/view_catalog.h"
#include "mongo/stdx/functional.h"
#include "mongo/util/mongoutils/str.h"
#include "mongo/util/string_map.h"

namespace mongo {

class Database : public Decorable<Database> {
public:
    typedef StringMap<Collection*> CollectionMap;

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

        virtual void init(OperationContext* opCtx) = 0;

        virtual void close(OperationContext* opCtx, const std::string& reason) = 0;

        virtual const std::string& name() const = 0;

        virtual void clearTmpCollections(OperationContext* opCtx) = 0;

        virtual Status setProfilingLevel(OperationContext* opCtx, int newLevel) = 0;

        virtual int getProfilingLevel() const = 0;

        virtual const char* getProfilingNS() const = 0;

        virtual void setDropPending(OperationContext* opCtx, bool dropPending) = 0;

        virtual bool isDropPending(OperationContext* opCtx) const = 0;

        virtual void getStats(OperationContext* opCtx, BSONObjBuilder* output, double scale) = 0;

        virtual const DatabaseCatalogEntry* getDatabaseCatalogEntry() const = 0;

        virtual Status dropCollection(OperationContext* opCtx,
                                      StringData fullns,
                                      repl::OpTime dropOpTime) = 0;
        virtual Status dropCollectionEvenIfSystem(OperationContext* opCtx,
                                                  const NamespaceString& fullns,
                                                  repl::OpTime dropOpTime) = 0;

        virtual Status dropView(OperationContext* opCtx, StringData fullns) = 0;

        virtual Collection* createCollection(OperationContext* opCtx,
                                             StringData ns,
                                             const CollectionOptions& options,
                                             bool createDefaultIndexes,
                                             const BSONObj& idIndex) = 0;

        virtual Status createView(OperationContext* opCtx,
                                  StringData viewName,
                                  const CollectionOptions& options) = 0;

        virtual Collection* getCollection(OperationContext* opCtx, StringData ns) const = 0;

        virtual ViewCatalog* getViewCatalog() = 0;

        virtual Collection* getOrCreateCollection(OperationContext* opCtx,
                                                  const NamespaceString& nss) = 0;

        virtual Status renameCollection(OperationContext* opCtx,
                                        StringData fromNS,
                                        StringData toNS,
                                        bool stayTemp) = 0;

        virtual const NamespaceString& getSystemIndexesName() const = 0;

        virtual const std::string& getSystemViewsName() const = 0;

        virtual StatusWith<NamespaceString> makeUniqueCollectionNamespace(
            OperationContext* opCtx, StringData collectionNameModel) = 0;

        virtual CollectionMap& collections() = 0;
        virtual const CollectionMap& collections() const = 0;
    };

public:
    static MONGO_DECLARE_SHIM((OperationContext * opCtx)->void) dropAllDatabasesExceptLocal;

    static MONGO_DECLARE_SHIM(
        (OperationContext * opCtx,
         Database* db,
         StringData ns,
         BSONObj options,
         CollectionOptions::ParseKind parseKind = CollectionOptions::parseForCommand,
         bool createDefaultIndexes = true,
         const BSONObj& idIndex = BSONObj())
            ->Status) userCreateNS;

    static MONGO_DECLARE_SHIM((Database * this_,
                               OperationContext* opCtx,
                               StringData name,
                               DatabaseCatalogEntry*,
                               PrivateTo<Database>)
                                  ->std::unique_ptr<Impl>) makeImpl;

    class iterator {
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = Collection*;
        using pointer = const value_type*;
        using reference = const value_type&;
        using difference_type = ptrdiff_t;

        explicit inline iterator() = default;
        inline iterator(CollectionMap::const_iterator it) : _it(std::move(it)) {}

        inline reference operator*() const {
            return _it->second;
        }

        inline pointer operator->() const {
            return &_it->second;
        }

        inline friend bool operator==(const iterator& lhs, const iterator& rhs) {
            return lhs._it == rhs._it;
        }

        inline friend bool operator!=(const iterator& lhs, const iterator& rhs) {
            return !(lhs == rhs);
        }

        inline iterator& operator++() {
            ++_it;
            return *this;
        }

        inline iterator operator++(int) {
            auto oldPosition = *this;
            ++_it;
            return oldPosition;
        }

    private:
        CollectionMap::const_iterator _it;
    };

    explicit inline Database(OperationContext* const opCtx,
                             const StringData name,
                             DatabaseCatalogEntry* const dbEntry)
        : _pimpl(makeImpl(this, opCtx, name, dbEntry, PrivateCall<Database>{})) {
        this->_impl().init(opCtx);
    }

    // must call close first
    inline ~Database() = default;

    inline Database(Database&&) = delete;
    inline Database& operator=(Database&&) = delete;

    inline iterator begin() const {
        return iterator(this->_impl().collections().begin());
    }

    inline iterator end() const {
        return iterator(this->_impl().collections().end());
    }

    // closes files and other cleanup see below.
    inline void close(OperationContext* const opCtx, const std::string& reason) {
        return this->_impl().close(opCtx, reason);
    }

    inline const std::string& name() const {
        return this->_impl().name();
    }

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

    inline Status setProfilingLevel(OperationContext* const opCtx, const int newLevel) {
        return this->_impl().setProfilingLevel(opCtx, newLevel);
    }

    inline int getProfilingLevel() const {
        return this->_impl().getProfilingLevel();
    }

    inline const char* getProfilingNS() const {
        return this->_impl().getProfilingNS();
    }

    inline void setDropPending(OperationContext* opCtx, bool dropPending) {
        this->_impl().setDropPending(opCtx, dropPending);
    }

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

    inline void getStats(OperationContext* const opCtx,
                         BSONObjBuilder* const output,
                         const double scale = 1) {
        return this->_impl().getStats(opCtx, output, scale);
    }

    inline const DatabaseCatalogEntry* getDatabaseCatalogEntry() const {
        return this->_impl().getDatabaseCatalogEntry();
    }

    inline Status dropCollection(OperationContext* const opCtx,
                                 const StringData fullns,
                                 repl::OpTime dropOpTime = {}) {
        return this->_impl().dropCollection(opCtx, fullns, dropOpTime);
    }
    inline Status dropCollectionEvenIfSystem(OperationContext* const opCtx,
                                             const NamespaceString& fullns,
                                             repl::OpTime dropOpTime = {}) {
        return this->_impl().dropCollectionEvenIfSystem(opCtx, fullns, dropOpTime);
    }

    inline Status dropView(OperationContext* const opCtx, const StringData fullns) {
        return this->_impl().dropView(opCtx, fullns);
    }

    inline Collection* createCollection(OperationContext* const opCtx,
                                        StringData ns,
                                        const CollectionOptions& options = CollectionOptions(),
                                        const bool createDefaultIndexes = true,
                                        const BSONObj& idIndex = BSONObj()) {
        return this->_impl().createCollection(opCtx, ns, options, createDefaultIndexes, idIndex);
    }

    inline Status createView(OperationContext* const opCtx,
                             const StringData viewName,
                             const CollectionOptions& options) {
        return this->_impl().createView(opCtx, viewName, options);
    }

    inline Collection* getCollection(OperationContext* opCtx, const StringData ns) const {
        return this->_impl().getCollection(opCtx, ns);
    }

    inline Collection* getCollection(OperationContext* opCtx, const NamespaceString& ns) const {
        return this->_impl().getCollection(opCtx, ns.ns());
    }

    inline ViewCatalog* getViewCatalog() {
        return this->_impl().getViewCatalog();
    }

    inline Collection* getOrCreateCollection(OperationContext* const opCtx,
                                             const NamespaceString& nss) {
        return this->_impl().getOrCreateCollection(opCtx, nss);
    }

    inline Status renameCollection(OperationContext* const opCtx,
                                   const StringData fromNS,
                                   const StringData toNS,
                                   const bool stayTemp) {
        return this->_impl().renameCollection(opCtx, fromNS, toNS, stayTemp);
    }

    static MONGO_DECLARE_SHIM((OperationContext * opCtx, Database* db)->void) dropDatabase;

    inline const NamespaceString& getSystemIndexesName() const {
        return this->_impl().getSystemIndexesName();
    }

    inline const std::string& getSystemViewsName() const {
        return this->_impl().getSystemViewsName();
    }

    inline StatusWith<NamespaceString> makeUniqueCollectionNamespace(
        OperationContext* opCtx, StringData collectionNameModel) {
        return this->_impl().makeUniqueCollectionNamespace(opCtx, collectionNameModel);
    }

private:
    // This structure exists to give us a customization point to decide how to force users of this
    // class to depend upon the corresponding `database.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;
    }

    std::unique_ptr<Impl> _pimpl;
};
}  // namespace mongo