CXX-791 Options for bulk ops should be on the options::bulk_op type

Author: acmorrow

src/mongocxx/bulk_write.cpp

@@ -33,8 +33,16 @@ bulk_write& bulk_write::operator=(bulk_write&&) noexcept = default;
 
 bulk_write::~bulk_write() = default;
 
-bulk_write::bulk_write(bool ordered)
-    : _impl(stdx::make_unique<impl>(libmongoc::bulk_operation_new(ordered))) {
+bulk_write::bulk_write(options::bulk_write options)
+    : _impl(stdx::make_unique<impl>(libmongoc::bulk_operation_new(options.ordered()))) {
+    auto options_wc = options.write_concern();
+    if (options_wc)
+        libmongoc::bulk_operation_set_write_concern(_impl->operation_t,
+                                                    options_wc->_impl->write_concern_t);
+
+    auto options_bdv = options.bypass_document_validation();
+    if (options_bdv)
+        libmongoc::bulk_operation_set_bypass_document_validation(_impl->operation_t, *options_bdv);
 }
 
 void bulk_write::append(const model::write& operation) {
@@ -87,20 +95,5 @@ void bulk_write::append(const model::write& operation) {
     }
 }
 
-void bulk_write::bypass_document_validation(bool bypass_document_validation) {
-    libmongoc::bulk_operation_set_bypass_document_validation(_impl->operation_t,
-                                                             bypass_document_validation);
-}
-
-void bulk_write::write_concern(class write_concern wc) {
-    libmongoc::bulk_operation_set_write_concern(_impl->operation_t, wc._impl->write_concern_t);
-}
-
-class write_concern bulk_write::write_concern() const {
-    class write_concern wc(stdx::make_unique<write_concern::impl>(libmongoc::write_concern_copy(
-        libmongoc::bulk_operation_get_write_concern(_impl->operation_t))));
-    return wc;
-}
-
 MONGOCXX_INLINE_NAMESPACE_END
 }  // namespace mongocxx

src/mongocxx/bulk_write.hpp

@@ -16,9 +16,8 @@
 
 #include <mongocxx/config/prelude.hpp>
 
-#include <mongocxx/write_concern.hpp>
+#include <mongocxx/options/bulk_write.hpp>
 #include <mongocxx/model/write.hpp>
-#include <bsoncxx/stdx/optional.hpp>
 
 namespace mongocxx {
 MONGOCXX_INLINE_NAMESPACE_BEGIN
@@ -53,7 +52,7 @@ class MONGOCXX_API bulk_write {
     ///   be reported after attempting all operations. Unordered bulk writes may be more efficient
     ///   than ordered bulk writes.
     ///
-    explicit bulk_write(bool ordered);
+    explicit bulk_write(options::bulk_write options = {});
 
     ///
     /// Move constructs a bulk write operation.
@@ -88,29 +87,6 @@ class MONGOCXX_API bulk_write {
     ///
     void append(const model::write& operation);
 
-    ///
-    /// Whether or not to bypass document validation for this operation.
-    ///
-    /// @param bypass_document_validation
-    ///   Whether or not to bypass document validation.
-    ///
-    void bypass_document_validation(bool bypass_document_validation);
-
-    ///
-    /// Sets the write_concern for this operation.
-    ///
-    /// @param wc
-    ///   The write_concern to set
-    ///
-    void write_concern(class write_concern wc);
-
-    ///
-    /// Gets the write_concern for the bulk write.
-    ///
-    /// @return The current write_concern.
-    ///
-    class write_concern write_concern() const;
-
    private:
     friend class collection;
 

src/mongocxx/collection.cpp

@@ -285,7 +285,25 @@ cursor collection::aggregate(const pipeline& pipeline, const options::aggregate&
 
 stdx::optional<result::insert_one> collection::insert_one(view_or_value document,
                                                           const options::insert& options) {
-    class bulk_write bulk_op(false);
+
+    // TODO: We should consider making it possible to convert from an options::insert into
+    // an options::bulk_write at the type level, removing the need to re-iterate this code
+    // many times here and below.
+    //
+    // See comments in: https://github.com/mongodb/mongo-cxx-driver/pull/409
+
+    options::bulk_write bulk_opts;
+    bulk_opts.ordered(false);
+
+    if (options.write_concern()) {
+        bulk_opts.write_concern(*options.write_concern());
+    }
+
+    if (options.bypass_document_validation()) {
+        bulk_opts.bypass_document_validation(*options.bypass_document_validation());
+    }
+
+    class bulk_write bulk_op(bulk_opts);
     bsoncxx::document::element oid{};
 
     bsoncxx::builder::stream::document new_document;
@@ -299,14 +317,6 @@ stdx::optional<result::insert_one> collection::insert_one(view_or_value document
         oid = document.view()["_id"];
     }
 
-    if (options.write_concern()) {
-        bulk_op.write_concern(*options.write_concern());
-    }
-
-    if (options.bypass_document_validation()) {
-        bulk_op.bypass_document_validation(*options.bypass_document_validation());
-    }
-
     auto result = bulk_write(bulk_op);
     if (!result) {
         return stdx::optional<result::insert_one>();
@@ -319,17 +329,20 @@ stdx::optional<result::insert_one> collection::insert_one(view_or_value document
 stdx::optional<result::replace_one> collection::replace_one(view_or_value filter,
                                                             view_or_value replacement,
                                                             const options::update& options) {
-    class bulk_write bulk_op(false);
-    model::replace_one replace_op(filter, replacement);
+    options::bulk_write bulk_opts;
+    bulk_opts.ordered(false);
+
+    if (options.bypass_document_validation())
+        bulk_opts.bypass_document_validation(*options.bypass_document_validation());
+    if (options.write_concern()) bulk_opts.write_concern(*options.write_concern());
 
+    class bulk_write bulk_op(bulk_opts);
+
+    model::replace_one replace_op(filter, replacement);
     if (options.upsert()) replace_op.upsert(options.upsert().value());
 
     bulk_op.append(replace_op);
 
-    if (options.bypass_document_validation())
-        bulk_op.bypass_document_validation(*options.bypass_document_validation());
-    if (options.write_concern()) bulk_op.write_concern(*options.write_concern());
-
     auto result = bulk_write(bulk_op);
     if (!result) {
         return stdx::optional<result::replace_one>();
@@ -340,17 +353,20 @@ stdx::optional<result::replace_one> collection::replace_one(view_or_value filter
 
 stdx::optional<result::update> collection::update_many(view_or_value filter, view_or_value update,
                                                        const options::update& options) {
-    class bulk_write bulk_op(false);
-    model::update_many update_op(filter, update);
+    options::bulk_write bulk_opts;
+    bulk_opts.ordered(false);
 
+    if (options.bypass_document_validation())
+        bulk_opts.bypass_document_validation(*options.bypass_document_validation());
+    if (options.write_concern()) bulk_opts.write_concern(*options.write_concern());
+
+    class bulk_write bulk_op(bulk_opts);
+
+    model::update_many update_op(filter, update);
     if (options.upsert()) update_op.upsert(options.upsert().value());
 
     bulk_op.append(update_op);
 
-    if (options.bypass_document_validation())
-        bulk_op.bypass_document_validation(*options.bypass_document_validation());
-    if (options.write_concern()) bulk_op.write_concern(*options.write_concern());
-
     auto result = bulk_write(bulk_op);
     if (!result) {
         return stdx::optional<result::update>();
@@ -361,12 +377,17 @@ stdx::optional<result::update> collection::update_many(view_or_value filter, vie
 
 stdx::optional<result::delete_result> collection::delete_many(
     view_or_value filter, const options::delete_options& options) {
-    class bulk_write bulk_op(false);
+
+    options::bulk_write bulk_opts;
+    bulk_opts.ordered(false);
+
+    if (options.write_concern()) bulk_opts.write_concern(*options.write_concern());
+
+    class bulk_write bulk_op(bulk_opts);
+
     model::delete_many delete_op(filter);
     bulk_op.append(delete_op);
 
-    if (options.write_concern()) bulk_op.write_concern(*options.write_concern());
-
     auto result = bulk_write(bulk_op);
     if (!result) {
         return stdx::optional<result::delete_result>();
@@ -377,17 +398,21 @@ stdx::optional<result::delete_result> collection::delete_many(
 
 stdx::optional<result::update> collection::update_one(view_or_value filter, view_or_value update,
                                                       const options::update& options) {
-    class bulk_write bulk_op(false);
-    model::update_one update_op(filter, update);
 
+    options::bulk_write bulk_opts;
+    bulk_opts.ordered(false);
+
+    if (options.bypass_document_validation())
+        bulk_opts.bypass_document_validation(*options.bypass_document_validation());
+    if (options.write_concern()) bulk_opts.write_concern(*options.write_concern());
+
+    class bulk_write bulk_op(bulk_opts);
+
+    model::update_one update_op(filter, update);
     if (options.upsert()) update_op.upsert(options.upsert().value());
 
     bulk_op.append(update_op);
 
-    if (options.bypass_document_validation())
-        bulk_op.bypass_document_validation(*options.bypass_document_validation());
-    if (options.write_concern()) bulk_op.write_concern(*options.write_concern());
-
     auto result = bulk_write(bulk_op);
     if (!result) {
         return stdx::optional<result::update>();
@@ -398,12 +423,17 @@ stdx::optional<result::update> collection::update_one(view_or_value filter, view
 
 stdx::optional<result::delete_result> collection::delete_one(
     view_or_value filter, const options::delete_options& options) {
-    class bulk_write bulk_op(false);
+
+    options::bulk_write bulk_opts;
+    bulk_opts.ordered(false);
+
+    if (options.write_concern()) bulk_opts.write_concern(*options.write_concern());
+
+    class bulk_write bulk_op(bulk_opts);
+
     model::delete_one delete_op(filter);
     bulk_op.append(delete_op);
 
-    if (options.write_concern()) bulk_op.write_concern(*options.write_concern());
-
     auto result = bulk_write(bulk_op);
     if (!result) {
         return stdx::optional<result::delete_result>();

src/mongocxx/collection.hpp

@@ -614,7 +614,7 @@ template <typename write_model_iterator_type>
 MONGOCXX_INLINE stdx::optional<result::bulk_write> collection::bulk_write(
     write_model_iterator_type begin, write_model_iterator_type end,
     const options::bulk_write& options) {
-    class bulk_write writes(options.ordered().value_or(true));
+    class bulk_write writes(options);
 
     std::for_each(begin, end, [&](const model::write& current) { writes.append(current); });
 

src/mongocxx/insert_many_builder.cpp

@@ -22,14 +22,24 @@
 namespace mongocxx {
 MONGOCXX_INLINE_NAMESPACE_BEGIN
 
-insert_many_builder::insert_many_builder(const options::insert& options)
-    : _writes{options.ordered().value_or(true)}, _inserted_ids{}, _index{0} {
-    if (options.write_concern()) {
-        _writes.write_concern(*options.write_concern());
+namespace {
+
+options::bulk_write make_bulk_write_options(const options::insert& insert_options) {
+    options::bulk_write bw;
+    bw.ordered(insert_options.ordered().value_or(true));
+    if (insert_options.write_concern()) {
+        bw.write_concern(*insert_options.write_concern());
     }
-    if (options.bypass_document_validation()) {
-        _writes.bypass_document_validation(*options.bypass_document_validation());
+    if (insert_options.bypass_document_validation()) {
+        bw.bypass_document_validation(*insert_options.bypass_document_validation());
     }
+    return bw;
+}
+
+} // namespace
+
+insert_many_builder::insert_many_builder(const options::insert& options)
+    : _writes{make_bulk_write_options(options)}, _inserted_ids{}, _index{0} {
 };
 
 void insert_many_builder::operator()(const bsoncxx::document::view& doc) {

src/mongocxx/options/bulk_write.cpp

@@ -20,16 +20,31 @@ namespace mongocxx {
 MONGOCXX_INLINE_NAMESPACE_BEGIN
 namespace options {
 
+bulk_write::bulk_write()
+    : _ordered(true) {}
+
 void bulk_write::ordered(bool ordered) {
     _ordered = ordered;
 }
 
+bool bulk_write::ordered() const {
+    return _ordered;
+}
+
 void bulk_write::write_concern(class write_concern wc) {
     _write_concern = std::move(wc);
 }
 
-const stdx::optional<bool>& bulk_write::ordered() const {
-    return _ordered;
+const stdx::optional<class write_concern>& bulk_write::write_concern() const {
+    return _write_concern;
+}
+
+void bulk_write::bypass_document_validation(bool bypass_document_validation) {
+    _bypass_document_validation = bypass_document_validation;
+}
+
+const stdx::optional<bool> bulk_write::bypass_document_validation() const {
+    return _bypass_document_validation;
 }
 
 }  // namespace options

src/mongocxx/options/bulk_write.hpp

@@ -31,6 +31,13 @@ class MONGOCXX_API bulk_write {
 
    public:
 
+    ///
+    /// Constructs a new bulk_write object. By default, bulk writes are considered ordered
+    /// as this is the only safe choice. If you want an unordered update, you must call
+    /// ordered(false) to switch to unordered mode.
+    ///
+    bulk_write();
+
     ///
     /// Sets whether the writes must be executed in order by the server.
     ///
@@ -47,9 +54,9 @@ class MONGOCXX_API bulk_write {
     ///
     /// Gets the current value of the ordered option.
     ///
-    /// @return The optional value of the ordered option.
+    /// @return The value of the ordered option.
     ///
-    const stdx::optional<bool>& ordered() const;
+    bool ordered() const;
 
     ///
     /// Sets the write_concern for this operation.
@@ -71,9 +78,26 @@ class MONGOCXX_API bulk_write {
     ///
     const stdx::optional<class write_concern>& write_concern() const;
 
+    ///
+    /// Set whether or not to bypass document validation for this operation.
+    ///
+    /// @param bypass_document_validation
+    ///   Whether or not to bypass document validation.
+    ///
+    void bypass_document_validation(bool bypass_document_validation);
+
+    ///
+    /// The current setting for bypassing document validation for this operation.
+    ///
+    /// @return
+    ///  The current document validation bypass setting.
+    ///
+    const stdx::optional<bool> bypass_document_validation() const;
+
    private:
-    stdx::optional<bool> _ordered;
+    bool _ordered;
     stdx::optional<class write_concern> _write_concern;
+    stdx::optional<bool> _bypass_document_validation;
 };
 
 }  // namespace options