collection.hpp

Go to the documentation of this file.

//
// Copyright 2009-present MongoDB, Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <mongocxx/v1/collection-fwd.hpp> // IWYU pragma: export
 
//
 
#include <mongocxx/v1/detail/prelude.hpp>
 
#include <mongocxx/v1/client_session-fwd.hpp>
#include <mongocxx/v1/cursor-fwd.hpp>
#include <mongocxx/v1/delete_many_result-fwd.hpp>
#include <mongocxx/v1/delete_one_result-fwd.hpp>
#include <mongocxx/v1/insert_one_result-fwd.hpp>
#include <mongocxx/v1/pipeline-fwd.hpp>
#include <mongocxx/v1/read_concern-fwd.hpp>
#include <mongocxx/v1/read_preference-fwd.hpp>
#include <mongocxx/v1/replace_one_result-fwd.hpp>
#include <mongocxx/v1/search_indexes-fwd.hpp>
#include <mongocxx/v1/update_many_result-fwd.hpp>
#include <mongocxx/v1/update_one_result-fwd.hpp>
 
#include <bsoncxx/v1/detail/type_traits.hpp>
#include <bsoncxx/v1/document/value.hpp>
#include <bsoncxx/v1/document/view.hpp>
#include <bsoncxx/v1/stdx/optional.hpp>
#include <bsoncxx/v1/stdx/string_view.hpp>
#include <bsoncxx/v1/types/value.hpp>
 
#include <mongocxx/v1/aggregate_options.hpp>
#include <mongocxx/v1/bulk_write.hpp>
#include <mongocxx/v1/change_stream.hpp>
#include <mongocxx/v1/config/export.hpp>
#include <mongocxx/v1/count_options.hpp>
#include <mongocxx/v1/delete_many_options.hpp>
#include <mongocxx/v1/delete_one_options.hpp>
#include <mongocxx/v1/distinct_options.hpp>
#include <mongocxx/v1/estimated_document_count_options.hpp>
#include <mongocxx/v1/find_one_and_delete_options.hpp>
#include <mongocxx/v1/find_one_and_replace_options.hpp>
#include <mongocxx/v1/find_one_and_update_options.hpp>
#include <mongocxx/v1/find_options.hpp>
#include <mongocxx/v1/indexes.hpp>
#include <mongocxx/v1/insert_many_options.hpp>
#include <mongocxx/v1/insert_many_result.hpp>
#include <mongocxx/v1/insert_one_options.hpp>
#include <mongocxx/v1/replace_one_options.hpp>
#include <mongocxx/v1/update_many_options.hpp>
#include <mongocxx/v1/update_one_options.hpp>
#include <mongocxx/v1/write_concern.hpp>
 
#include <cstdint>
#include <string>
#include <system_error>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace mongocxx {
namespace v1 {

class collection {
   private:
    class impl;
    void* _impl;
 
    template <typename Container>
    using has_begin_expr = decltype((std::declval<Container const&>().begin()));
 
    template <typename Container>
    struct has_begin : bsoncxx::detail::is_detected<has_begin_expr, Container> {};
 
    template <typename Container>
    using has_end_expr = decltype((std::declval<Container const&>().end()));
 
    template <typename Container>
    struct has_end : bsoncxx::detail::is_detected<has_end_expr, Container> {};
 
    static void is_write_iter_expr_impl(v1::bulk_write::single) {}
 
    template <typename InputIt>
    using is_write_iter_expr = decltype((is_write_iter_expr_impl)(*std::declval<InputIt&>()));
 
    template <typename InputIt>
    struct is_write_iter : bsoncxx::detail::is_detected<is_write_iter_expr, InputIt> {};
 
    template <typename Sentinel, typename InputIt>
    struct is_sentinel_for : bsoncxx::detail::is_equality_comparable<Sentinel, InputIt> {};
 
    template <typename Container>
    struct is_container : bsoncxx::detail::conjunction<has_begin<Container>, has_end<Container>> {};
 
    static void is_document_iter_expr_impl(bsoncxx::v1::document::view) {}
 
    template <typename InputIt>
    using is_document_iter_expr = decltype((is_document_iter_expr_impl)(*std::declval<InputIt&>()));
 
    template <typename InputIt>
    struct is_document_iter : bsoncxx::detail::is_detected<is_document_iter_expr, InputIt> {};
 
   public:
    MONGOCXX_ABI_EXPORT_CDECL() ~collection();

    MONGOCXX_ABI_EXPORT_CDECL() collection(collection&& other) noexcept;

    MONGOCXX_ABI_EXPORT_CDECL(collection&) operator=(collection&& other) noexcept;

    MONGOCXX_ABI_EXPORT_CDECL() collection(collection const& other);

    MONGOCXX_ABI_EXPORT_CDECL(collection&) operator=(collection const& other);

    MONGOCXX_ABI_EXPORT_CDECL() collection();

    explicit MONGOCXX_ABI_EXPORT_CDECL() operator bool() const;

    MONGOCXX_ABI_EXPORT_CDECL(v1::cursor) aggregate(
        v1::pipeline const& pipeline,
        v1::aggregate_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(v1::cursor)
    aggregate(v1::client_session const& session, v1::pipeline const& pipeline, v1::aggregate_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(v1::bulk_write) create_bulk_write(v1::bulk_write::options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(v1::bulk_write) create_bulk_write(
        v1::client_session const& session,
        v1::bulk_write::options const& opts = {});

    bsoncxx::v1::stdx::optional<v1::bulk_write::result> write(
        v1::bulk_write::single const& write,
        v1::bulk_write::options const& opts = {}) {
        return this->create_bulk_write(opts).append(write).execute();
    }
 
    bsoncxx::v1::stdx::optional<v1::bulk_write::result> write(
        v1::client_session const& session,
        v1::bulk_write::single const& write,
        v1::bulk_write::options const& opts = {}) {
        return this->create_bulk_write(session, opts).append(write).execute();
    }


    template <typename Container, bsoncxx::detail::enable_if_t<is_container<Container>::value>* = nullptr>
    bsoncxx::v1::stdx::optional<v1::bulk_write::result> bulk_write(
        Container const& writes,
        v1::bulk_write::options const& opts = {}) {
        return this->bulk_write(writes.begin(), writes.end(), opts);
    }

    template <typename Container, bsoncxx::detail::enable_if_t<is_container<Container>::value>* = nullptr>
    bsoncxx::v1::stdx::optional<v1::bulk_write::result>
    bulk_write(v1::client_session const& session, Container const& writes, v1::bulk_write::options const& opts = {}) {
        return this->bulk_write(session, writes.begin(), writes.end(), opts);
    }

    template <
        typename InputIt,
        typename Sentinel,
        bsoncxx::detail::enable_if_t<is_write_iter<InputIt>::value && is_sentinel_for<Sentinel, InputIt>::value>* =
            nullptr>
    bsoncxx::v1::stdx::optional<v1::bulk_write::result>
    bulk_write(InputIt begin, Sentinel end, v1::bulk_write::options const& opts = {}) {
        v1::bulk_write bulk{this->create_bulk_write(opts)};
        for (auto iter = begin; iter != end; ++iter) {
            bulk.append(*iter);
        }
        return bulk.execute();
    }
 
    template <
        typename InputIt,
        typename Sentinel,
        bsoncxx::detail::enable_if_t<is_write_iter<InputIt>::value && is_sentinel_for<Sentinel, InputIt>::value>* =
            nullptr>
    bsoncxx::v1::stdx::optional<v1::bulk_write::result> bulk_write(
        v1::client_session const& session,
        InputIt begin,
        Sentinel end,
        v1::bulk_write::options const& opts = {}) {
        v1::bulk_write bulk{this->create_bulk_write(session, opts)};
        for (auto iter = begin; iter != end; ++iter) {
            bulk.append(*iter);
        }
        return bulk.execute();
    }


    MONGOCXX_ABI_EXPORT_CDECL(std::int64_t) count_documents(
        bsoncxx::v1::document::view filter,
        v1::count_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(std::int64_t)
    count_documents(
        v1::client_session const& session,
        bsoncxx::v1::document::view filter,
        v1::count_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(std::int64_t) estimated_document_count(
        v1::estimated_document_count_options const& opts = {});

    bsoncxx::v1::stdx::optional<std::string> create_index(
        bsoncxx::v1::document::value keys,
        bsoncxx::v1::document::value index_opts = {},
        v1::indexes::create_one_options const& create_opts = {}) {
        return this->indexes().create_one(std::move(keys), std::move(index_opts), create_opts);
    }

    bsoncxx::v1::stdx::optional<std::string> create_index(
        v1::client_session const& session,
        bsoncxx::v1::document::value keys,
        bsoncxx::v1::document::value index_opts = {},
        v1::indexes::create_one_options const& create_opts = {}) {
        return this->indexes().create_one(session, std::move(keys), std::move(index_opts), create_opts);
    }

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::delete_many_result>) delete_many(
        bsoncxx::v1::document::view q,
        v1::delete_many_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::delete_many_result>) delete_many(
        v1::client_session const& session,
        bsoncxx::v1::document::view q,
        v1::delete_many_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::delete_one_result>) delete_one(
        bsoncxx::v1::document::view q,
        v1::delete_one_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::delete_one_result>)
    delete_one(
        v1::client_session const& session,
        bsoncxx::v1::document::view q,
        v1::delete_one_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(v1::cursor)
    distinct(
        bsoncxx::v1::stdx::string_view key,
        bsoncxx::v1::document::view query,
        v1::distinct_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(v1::cursor) distinct(
        v1::client_session const& session,
        bsoncxx::v1::stdx::string_view key,
        bsoncxx::v1::document::view query,
        v1::distinct_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(void) drop(
        bsoncxx::v1::stdx::optional<v1::write_concern> const& wc = {},
        bsoncxx::v1::document::view opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(void) drop(
        v1::client_session const& session,
        bsoncxx::v1::stdx::optional<v1::write_concern> const& wc = {},
        bsoncxx::v1::document::view opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(v1::cursor) find(bsoncxx::v1::document::view filter, v1::find_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(v1::cursor)
    find(v1::client_session const& session, bsoncxx::v1::document::view filter, v1::find_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>) find_one(
        bsoncxx::v1::document::view filter,
        v1::find_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>)
    find_one(v1::client_session const& session, bsoncxx::v1::document::view filter, v1::find_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>) find_one_and_delete(
        bsoncxx::v1::document::view query,
        v1::find_one_and_delete_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>) find_one_and_delete(
        v1::client_session const& session,
        bsoncxx::v1::document::view query,
        v1::find_one_and_delete_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>) find_one_and_replace(
        bsoncxx::v1::document::view query,
        bsoncxx::v1::document::view replacement,
        v1::find_one_and_replace_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>) find_one_and_replace(
        v1::client_session const& session,
        bsoncxx::v1::document::view query,
        bsoncxx::v1::document::view replacement,
        v1::find_one_and_replace_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>) find_one_and_update(
        bsoncxx::v1::document::view query,
        bsoncxx::v1::document::view update,
        v1::find_one_and_update_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>) find_one_and_update(
        bsoncxx::v1::document::view query,
        v1::pipeline const& update,
        v1::find_one_and_update_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>) find_one_and_update(
        v1::client_session const& session,
        bsoncxx::v1::document::view query,
        bsoncxx::v1::document::view update,
        v1::find_one_and_update_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::value>) find_one_and_update(
        v1::client_session const& session,
        bsoncxx::v1::document::view query,
        v1::pipeline const& update,
        v1::find_one_and_update_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::insert_one_result>) insert_one(
        bsoncxx::v1::document::view document,
        v1::insert_one_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::insert_one_result>) insert_one(
        v1::client_session const& session,
        bsoncxx::v1::document::view document,
        v1::insert_one_options const& opts = {});

    template <typename Container, bsoncxx::detail::enable_if_t<is_container<Container>::value>* = nullptr>
    bsoncxx::v1::stdx::optional<v1::insert_many_result> insert_many(
        Container const& docs,
        v1::insert_many_options const& opts = {}) {
        return this->insert_many(docs.begin(), docs.end(), opts);
    }

    template <typename Container, bsoncxx::detail::enable_if_t<is_container<Container>::value>* = nullptr>
    bsoncxx::v1::stdx::optional<v1::insert_many_result>
    insert_many(v1::client_session const& session, Container const& docs, v1::insert_many_options const& opts = {}) {
        return this->insert_many(session, docs.begin(), docs.end(), opts);
    }

    template <
        typename InputIt,
        typename Sentinel,
        bsoncxx::detail::enable_if_t<is_document_iter<InputIt>::value && is_sentinel_for<Sentinel, InputIt>::value>* =
            nullptr>
    bsoncxx::v1::stdx::optional<v1::insert_many_result>
    insert_many(InputIt begin, Sentinel end, v1::insert_many_options const& opts = {}) {
        v1::bulk_write bulk{this->_create_insert_many(nullptr, opts)};
        std::vector<bsoncxx::v1::types::value> inserted_ids;
        for (auto iter = begin; iter != end; ++iter) {
            this->_append_insert_many(bulk, inserted_ids, *iter);
        }
        return this->_execute_insert_many(bulk, inserted_ids);
    }
 
    template <
        typename InputIt,
        typename Sentinel,
        bsoncxx::detail::enable_if_t<is_document_iter<InputIt>::value && is_sentinel_for<Sentinel, InputIt>::value>* =
            nullptr>
    bsoncxx::v1::stdx::optional<v1::insert_many_result> insert_many(
        v1::client_session const& session,
        InputIt begin,
        Sentinel end,
        v1::insert_many_options const& opts = {}) {
        v1::bulk_write bulk{this->_create_insert_many(&session, opts)};
        std::vector<bsoncxx::v1::types::value> inserted_ids;
        for (auto iter = begin; iter != end; ++iter) {
            this->_append_insert_many(bulk, inserted_ids, *iter);
        }
        return this->_execute_insert_many(bulk, inserted_ids);
    }


    v1::cursor list_indexes() {
        return this->indexes().list();
    }

    v1::cursor list_indexes(v1::client_session const& session) {
        return this->indexes().list(session);
    }

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::string_view) name() const;

    MONGOCXX_ABI_EXPORT_CDECL(void) rename(
        bsoncxx::v1::stdx::string_view new_name,
        bool drop_target = false,
        bsoncxx::v1::stdx::optional<v1::write_concern> const& write_concern = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(void) rename(
        v1::client_session const& session,
        bsoncxx::v1::stdx::string_view new_name,
        bool drop_target = false,
        bsoncxx::v1::stdx::optional<v1::write_concern> const& write_concern = {});

    MONGOCXX_ABI_EXPORT_CDECL(void) read_concern(v1::read_concern const& rc);

    MONGOCXX_ABI_EXPORT_CDECL(v1::read_concern) read_concern() const;

    MONGOCXX_ABI_EXPORT_CDECL(void) read_preference(v1::read_preference const& rp);

    MONGOCXX_ABI_EXPORT_CDECL(v1::read_preference) read_preference() const;

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::replace_one_result>) replace_one(
        bsoncxx::v1::document::view filter,
        bsoncxx::v1::document::value replacement,
        v1::replace_one_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::replace_one_result>) replace_one(
        v1::client_session const& session,
        bsoncxx::v1::document::view filter,
        bsoncxx::v1::document::value replacement,
        v1::replace_one_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::update_many_result>) update_many(
        bsoncxx::v1::document::view filter,
        bsoncxx::v1::document::view update,
        v1::update_many_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::update_many_result>)
    update_many(bsoncxx::v1::document::view filter, v1::pipeline const& update, update_many_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::update_many_result>) update_many(
        v1::client_session const& session,
        bsoncxx::v1::document::view filter,
        bsoncxx::v1::document::view update,
        v1::update_many_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::update_many_result>) update_many(
        v1::client_session const& session,
        bsoncxx::v1::document::view filter,
        v1::pipeline const& update,
        v1::update_many_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::update_one_result>) update_one(
        bsoncxx::v1::document::view filter,
        bsoncxx::v1::document::view update,
        v1::update_one_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::update_one_result>)
    update_one(bsoncxx::v1::document::view filter, v1::pipeline const& update, update_one_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::update_one_result>) update_one(
        v1::client_session const& session,
        bsoncxx::v1::document::view filter,
        bsoncxx::v1::document::view update,
        v1::update_one_options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::update_one_result>) update_one(
        v1::client_session const& session,
        bsoncxx::v1::document::view filter,
        v1::pipeline const& update,
        v1::update_one_options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(void) write_concern(v1::write_concern const& wc);

    MONGOCXX_ABI_EXPORT_CDECL(v1::write_concern) write_concern() const;

    MONGOCXX_ABI_EXPORT_CDECL(v1::indexes) indexes();

    MONGOCXX_ABI_EXPORT_CDECL(v1::change_stream) watch(v1::change_stream::options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(v1::change_stream) watch(
        v1::client_session const& session,
        v1::change_stream::options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(v1::change_stream) watch(
        v1::pipeline const& pipeline,
        v1::change_stream::options const& opts = {});
 
    MONGOCXX_ABI_EXPORT_CDECL(v1::change_stream)
    watch(v1::client_session const& session, v1::pipeline const& pipeline, v1::change_stream::options const& opts = {});

    MONGOCXX_ABI_EXPORT_CDECL(v1::search_indexes) search_indexes();

    enum class errc {
        zero,         
        max_time_u32, 
    };

    static MONGOCXX_ABI_EXPORT_CDECL(std::error_category const&) error_category();

    friend std::error_code make_error_code(errc v) {
        return {static_cast<int>(v), error_category()};
    }
 
    class internal;
 
   private:
    /* explicit(false) */ collection(void* impl);
 
    MONGOCXX_ABI_EXPORT_CDECL(v1::bulk_write) _create_insert_many(
        v1::client_session const* session,
        v1::insert_many_options const& opts);
 
    static MONGOCXX_ABI_EXPORT_CDECL(void) _append_insert_many(
        v1::bulk_write& bulk,
        std::vector<bsoncxx::v1::types::value>& inserted_ids,
        bsoncxx::v1::document::view doc);
 
    static MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::insert_many_result>) _execute_insert_many(
        v1::bulk_write& bulk,
        std::vector<bsoncxx::v1::types::value>& inserted_ids);
};
 
} // namespace v1
} // namespace mongocxx
 
namespace std {
 
template <>
struct is_error_code_enum<mongocxx::v1::collection::errc> : true_type {};
 
} // namespace std
 
#include <mongocxx/v1/detail/postlude.hpp>