bulk_write.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/bulk_write-fwd.hpp>
 
//
 
#include <mongocxx/v1/detail/prelude.hpp>
 
#include <bsoncxx/v1/array/view-fwd.hpp>
#include <bsoncxx/v1/document/view-fwd.hpp>
#include <bsoncxx/v1/types/value-fwd.hpp>
 
#include <mongocxx/v1/hint-fwd.hpp>
 
#include <bsoncxx/v1/array/value.hpp>
#include <bsoncxx/v1/document/value.hpp>
#include <bsoncxx/v1/stdx/optional.hpp>
#include <bsoncxx/v1/types/view.hpp>
 
#include <mongocxx/v1/config/export.hpp>
#include <mongocxx/v1/hint.hpp>
#include <mongocxx/v1/pipeline.hpp>
#include <mongocxx/v1/write_concern.hpp>
 
#include <cstdint>
#include <map>
#include <utility>
 
namespace mongocxx {
namespace v1 {

class bulk_write {
   private:
    class impl;
    void* _impl;
 
   public:
    enum class type {
        k_insert_one,

        k_delete_one,

        k_delete_many,

        k_update_one,

        k_update_many,

        k_replace_one,
    };
 
    class insert_one;
    class update_one;
    class update_many;
    class replace_one;
    class delete_one;
    class delete_many;
    class single;
    class options;
    class result;

    MONGOCXX_ABI_EXPORT_CDECL() ~bulk_write();

    MONGOCXX_ABI_EXPORT_CDECL() bulk_write(bulk_write&& other) noexcept;

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

    bulk_write(bulk_write const& other) = delete;

    bulk_write& operator=(bulk_write const& other) = delete;

    MONGOCXX_ABI_EXPORT_CDECL(bool) empty() const;

    MONGOCXX_ABI_EXPORT_CDECL(bulk_write&) append(single const& op);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<result>) execute();
 
    class internal;
 
   private:
    /* explicit(false) */ bulk_write(void* bulk);
};

class bulk_write::insert_one {
   public:
    bsoncxx::v1::document::value value;

    /* explicit(false) */ insert_one(bsoncxx::v1::document::value doc) : value{std::move(doc)} {}

    bsoncxx::v1::document::value const& document() const {
        return value;
    }
};

class bulk_write::update_one {
   private:
    class impl;
    void* _impl;
 
   public:
    MONGOCXX_ABI_EXPORT_CDECL() ~update_one();

    MONGOCXX_ABI_EXPORT_CDECL() update_one(update_one&& other) noexcept;

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

    MONGOCXX_ABI_EXPORT_CDECL() update_one(update_one const& other);

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

    MONGOCXX_ABI_EXPORT_CDECL() update_one(bsoncxx::v1::document::value filter, bsoncxx::v1::document::value update);

    MONGOCXX_ABI_EXPORT_CDECL() update_one(bsoncxx::v1::document::value filter, v1::pipeline update);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::document::view) filter() const;

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::document::view) update() const;

    MONGOCXX_ABI_EXPORT_CDECL(update_one&) collation(bsoncxx::v1::document::value v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::view>) collation() const;

    MONGOCXX_ABI_EXPORT_CDECL(update_one&) hint(v1::hint v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::hint>) hint() const;

    MONGOCXX_ABI_EXPORT_CDECL(update_one&) sort(bsoncxx::v1::document::value v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::view>) sort() const;

    MONGOCXX_ABI_EXPORT_CDECL(update_one&) upsert(bool v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bool>) upsert() const;

    MONGOCXX_ABI_EXPORT_CDECL(update_one&) array_filters(bsoncxx::v1::array::value v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::array::view>) array_filters() const;
 
    class internal;
};

class bulk_write::update_many {
   private:
    class impl;
    void* _impl;
 
   public:
    MONGOCXX_ABI_EXPORT_CDECL() ~update_many();

    MONGOCXX_ABI_EXPORT_CDECL() update_many(update_many&& other) noexcept;

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

    MONGOCXX_ABI_EXPORT_CDECL() update_many(update_many const& other);

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

    MONGOCXX_ABI_EXPORT_CDECL() update_many(bsoncxx::v1::document::value filter, bsoncxx::v1::document::value update);

    MONGOCXX_ABI_EXPORT_CDECL() update_many(bsoncxx::v1::document::value filter, pipeline const& update);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::document::view) filter() const;

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::document::view) update() const;

    MONGOCXX_ABI_EXPORT_CDECL(update_many&) collation(bsoncxx::v1::document::value v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::view>) collation() const;

    MONGOCXX_ABI_EXPORT_CDECL(update_many&) hint(v1::hint v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::hint>) hint() const;

    MONGOCXX_ABI_EXPORT_CDECL(update_many&) upsert(bool v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bool>) upsert() const;

    MONGOCXX_ABI_EXPORT_CDECL(update_many&) array_filters(bsoncxx::v1::array::value v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::array::view>) array_filters() const;
 
    class internal;
 
   private:
    /* explicit(false) */ update_many(void* impl);
};

class bulk_write::replace_one {
   private:
    class impl;
    void* _impl;
 
   public:
    MONGOCXX_ABI_EXPORT_CDECL() ~replace_one();

    MONGOCXX_ABI_EXPORT_CDECL() replace_one(replace_one&& other) noexcept;

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

    MONGOCXX_ABI_EXPORT_CDECL() replace_one(replace_one const& other);

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

    MONGOCXX_ABI_EXPORT_CDECL() replace_one(
        bsoncxx::v1::document::value filter,
        bsoncxx::v1::document::value replacement);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::document::view) filter() const;

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::document::view) replacement() const;

    MONGOCXX_ABI_EXPORT_CDECL(replace_one&) collation(bsoncxx::v1::document::value v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::view>) collation() const;

    MONGOCXX_ABI_EXPORT_CDECL(replace_one&) hint(v1::hint v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::hint>) hint() const;

    MONGOCXX_ABI_EXPORT_CDECL(replace_one&) sort(bsoncxx::v1::document::value v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::view>) sort() const;

    MONGOCXX_ABI_EXPORT_CDECL(replace_one&) upsert(bool v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bool>) upsert() const;
 
    class internal;
 
   private:
    /* explicit(false) */ replace_one(void* impl);
};

class bulk_write::delete_one {
   private:
    class impl;
    void* _impl;
 
   public:
    MONGOCXX_ABI_EXPORT_CDECL() ~delete_one();

    MONGOCXX_ABI_EXPORT_CDECL() delete_one(delete_one&& other) noexcept;

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

    MONGOCXX_ABI_EXPORT_CDECL() delete_one(delete_one const& other);

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

    explicit MONGOCXX_ABI_EXPORT_CDECL() delete_one(bsoncxx::v1::document::value filter);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::document::view) filter() const;

    MONGOCXX_ABI_EXPORT_CDECL(delete_one&) collation(bsoncxx::v1::document::value v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::view>) collation() const;

    MONGOCXX_ABI_EXPORT_CDECL(delete_one&) hint(v1::hint v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::hint>) hint() const;
 
    class internal;
 
   private:
    /* explicit(false) */ delete_one(void* impl);
};

class bulk_write::delete_many {
   private:
    class impl;
    void* _impl;
 
   public:
    MONGOCXX_ABI_EXPORT_CDECL() ~delete_many();

    MONGOCXX_ABI_EXPORT_CDECL() delete_many(delete_many&& other) noexcept;

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

    MONGOCXX_ABI_EXPORT_CDECL() delete_many(delete_many const& other);

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

    explicit MONGOCXX_ABI_EXPORT_CDECL() delete_many(bsoncxx::v1::document::value filter);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::document::view) filter() const;

    MONGOCXX_ABI_EXPORT_CDECL(delete_many&) collation(bsoncxx::v1::document::value v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::view>) collation() const;

    MONGOCXX_ABI_EXPORT_CDECL(delete_many&) hint(v1::hint v);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::hint>) hint() const;
 
    class internal;
 
   private:
    /* explicit(false) */ delete_many(void* impl);
};

class bulk_write::single {
   private:
    class impl;
    void* _impl;
 
   public:
    MONGOCXX_ABI_EXPORT_CDECL() ~single();

    MONGOCXX_ABI_EXPORT_CDECL() single(single&& other) noexcept;

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

    MONGOCXX_ABI_EXPORT_CDECL() single(single const& other);

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

    /* explicit(false) */ MONGOCXX_ABI_EXPORT_CDECL() single(insert_one op);
    /* explicit(false) */ MONGOCXX_ABI_EXPORT_CDECL() single(update_one op);
    /* explicit(false) */ MONGOCXX_ABI_EXPORT_CDECL() single(update_many op);
    /* explicit(false) */ MONGOCXX_ABI_EXPORT_CDECL() single(delete_one op);
    /* explicit(false) */ MONGOCXX_ABI_EXPORT_CDECL() single(delete_many op);
    /* explicit(false) */ MONGOCXX_ABI_EXPORT_CDECL() single(replace_one op);

    MONGOCXX_ABI_EXPORT_CDECL(v1::bulk_write::type) type() const;

    MONGOCXX_ABI_EXPORT_CDECL(insert_one const&) get_insert_one() const&;
    MONGOCXX_ABI_EXPORT_CDECL(insert_one&&) get_insert_one() &&;

    MONGOCXX_ABI_EXPORT_CDECL(update_one const&) get_update_one() const&;
    MONGOCXX_ABI_EXPORT_CDECL(update_one&&) get_update_one() &&;

    MONGOCXX_ABI_EXPORT_CDECL(update_many const&) get_update_many() const&;
    MONGOCXX_ABI_EXPORT_CDECL(update_many&&) get_update_many() &&;

    MONGOCXX_ABI_EXPORT_CDECL(delete_one const&) get_delete_one() const&;
    MONGOCXX_ABI_EXPORT_CDECL(delete_one&&) get_delete_one() &&;

    MONGOCXX_ABI_EXPORT_CDECL(delete_many const&) get_delete_many() const&;
    MONGOCXX_ABI_EXPORT_CDECL(delete_many&&) get_delete_many() &&;

    MONGOCXX_ABI_EXPORT_CDECL(replace_one const&) get_replace_one() const&;
    MONGOCXX_ABI_EXPORT_CDECL(replace_one&&) get_replace_one() &&;
 
    class internal;
};

class bulk_write::options {
   private:
    class impl;
    void* _impl;
 
   public:
    MONGOCXX_ABI_EXPORT_CDECL() ~options();

    MONGOCXX_ABI_EXPORT_CDECL() options(options&& other) noexcept;

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

    MONGOCXX_ABI_EXPORT_CDECL() options(options const& other);

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

    MONGOCXX_ABI_EXPORT_CDECL() options();

    MONGOCXX_ABI_EXPORT_CDECL(options&) bypass_document_validation(bool bypass_document_validation);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bool>) bypass_document_validation() const;

    MONGOCXX_ABI_EXPORT_CDECL(options&) comment(bsoncxx::v1::types::value comment);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::types::view>) comment() const;

    MONGOCXX_ABI_EXPORT_CDECL(options&) let(bsoncxx::v1::document::value let);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<bsoncxx::v1::document::view>) let() const;

    MONGOCXX_ABI_EXPORT_CDECL(options&) ordered(bool ordered);

    MONGOCXX_ABI_EXPORT_CDECL(bool) ordered() const;

    MONGOCXX_ABI_EXPORT_CDECL(options&) write_concern(v1::write_concern wc);

    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v1::stdx::optional<v1::write_concern>) write_concern() const;
 
    class internal;
 
   private:
    /* explicit(false) */ options(void* impl);
};

class bulk_write::result {
   private:
    class impl;
    void* _impl;
 
   public:
    MONGOCXX_ABI_EXPORT_CDECL() ~result();

    MONGOCXX_ABI_EXPORT_CDECL() result(result&& other) noexcept;

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

    MONGOCXX_ABI_EXPORT_CDECL() result(result const& other);

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

    MONGOCXX_ABI_EXPORT_CDECL(std::int64_t) inserted_count() const;

    MONGOCXX_ABI_EXPORT_CDECL(std::int64_t) matched_count() const;

    MONGOCXX_ABI_EXPORT_CDECL(std::int64_t) modified_count() const;

    MONGOCXX_ABI_EXPORT_CDECL(std::int64_t) deleted_count() const;

    MONGOCXX_ABI_EXPORT_CDECL(std::int64_t) upserted_count() const;

    using id_map = std::map<std::int64_t, bsoncxx::v1::types::view>;

    MONGOCXX_ABI_EXPORT_CDECL(id_map) upserted_ids() const;

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

 
    class internal;
 
   private:
    /* explicit(false) */ result(void* impl);
};
 
} // namespace v1
} // namespace mongocxx
 
#include <mongocxx/v1/detail/postlude.hpp>