CXX-1359 Replace use of index options in API with BSON document

This commit also adds a cast operator to mongocxx::options::index so existing code will still work.

Author: patrickfreed

src/mongocxx/collection.cpp

@@ -65,6 +65,7 @@
 #include <mongocxx/config/private/prelude.hh>
 
 using bsoncxx::builder::basic::kvp;
+using bsoncxx::builder::basic::make_array;
 using bsoncxx::builder::basic::make_document;
 using bsoncxx::builder::basic::sub_array;
 using bsoncxx::builder::basic::sub_document;
@@ -752,136 +753,43 @@ std::int64_t collection::count(view_or_value filter, const options::count& optio
     return result;
 }
 
-bsoncxx::document::value collection::create_index(view_or_value keys,
-                                                  const options::index& options) {
-    scoped_bson_t bson_keys{keys};
-    bson_error_t error;
-    ::mongoc_index_opt_geo_t geo_opt{};
-    ::mongoc_index_opt_t opt{};
-    ::mongoc_index_opt_wt_t wt_opt{};
-    libmongoc::index_opt_init(&opt);
-
-    // keep our safe copies alive
-    bsoncxx::string::view_or_value name_copy{};
-    bsoncxx::string::view_or_value wt_config_copy{};
-    bsoncxx::string::view_or_value default_language_copy{};
-    bsoncxx::string::view_or_value language_override_copy{};
-
-    if (options.background()) {
-        opt.background = *options.background();
-    }
-
-    if (options.unique()) {
-        opt.unique = *options.unique();
-    }
-
-    if (options.name()) {
-        name_copy = options.name()->terminated();
-        opt.name = name_copy.data();
-    }
-
-    if (options.sparse()) {
-        opt.sparse = *options.sparse();
-    }
-
-    if (options.storage_options()) {
-        const options::index::wiredtiger_storage_options* wt_options;
-        libmongoc::index_opt_wt_init(&wt_opt);
+bsoncxx::document::value collection::create_index(bsoncxx::document::view_or_value keys,
+                                                  bsoncxx::document::view_or_value opts) {
+    using namespace bsoncxx;
 
-        if (options.storage_options()->type() ==
-            ::mongoc_index_storage_opt_type_t::MONGOC_INDEX_STORAGE_OPT_WIREDTIGER) {
-            wt_options = static_cast<const options::index::wiredtiger_storage_options*>(
-                options.storage_options().get());
+    builder::basic::document index;
+    document::view opts_view = opts.view();
 
-            if (wt_options->config_string()) {
-                wt_config_copy = wt_options->config_string()->terminated();
-                wt_opt.config_str = wt_config_copy.data();
-            }
-            opt.storage_options = reinterpret_cast<mongoc_index_opt_storage_t*>(&wt_opt);
-        }
-    }
+    if (!opts_view["name"]) {
+        scoped_bson_t keys_bson{keys};
 
-    if (options.expire_after()) {
-        const auto count = options.expire_after()->count();
-        if ((count < 0) || (count > std::numeric_limits<int32_t>::max())) {
-            throw logic_error{error_code::k_invalid_parameter};
-        }
-        opt.expire_after_seconds = static_cast<std::int32_t>(count);
-    }
+        const auto name_from_keys = libmongoc::collection_keys_to_index_string(keys_bson.bson());
+        const auto cleanup_name_from_keys = make_guard([&] { bson_free(name_from_keys); });
 
-    if (options.version()) {
-        opt.v = *options.version();
+        index.append(kvp("name", name_from_keys));
     }
 
-    if (options.weights()) {
-        scoped_bson_t weights{*options.weights()};
-        opt.weights = weights.bson();
-    }
+    index.append(builder::basic::concatenate(make_document(kvp("key", keys))),
+                 builder::basic::concatenate(opts));
 
-    if (options.default_language()) {
-        default_language_copy = options.default_language()->terminated();
-        opt.default_language = default_language_copy.data();
-    }
+    array::view_or_value index_array = make_array(index.view());
+    document::view_or_value command =
+        make_document(kvp("createIndexes", name()), kvp("indexes", index_array.view()));
 
-    if (options.language_override()) {
-        language_override_copy = options.language_override()->terminated();
-        opt.language_override = language_override_copy.data();
-    }
-
-    if (options.collation()) {
-        scoped_bson_t collation{*options.collation()};
-        opt.collation = collation.bson();
-    }
-
-    if (options.partial_filter_expression()) {
-        scoped_bson_t partial_filter_expression{*options.partial_filter_expression()};
-        opt.partial_filter_expression = partial_filter_expression.bson();
-    }
-
-    if (options.twod_sphere_version() || options.twod_bits_precision() ||
-        options.twod_location_min() || options.twod_location_max() ||
-        options.haystack_bucket_size()) {
-        libmongoc::index_opt_geo_init(&geo_opt);
-
-        if (options.twod_sphere_version()) {
-            geo_opt.twod_sphere_version = *options.twod_sphere_version();
-        }
-
-        if (options.twod_bits_precision()) {
-            geo_opt.twod_bits_precision = *options.twod_bits_precision();
-        }
-
-        if (options.twod_location_min()) {
-            geo_opt.twod_location_min = *options.twod_location_min();
-        }
-
-        if (options.twod_location_max()) {
-            geo_opt.twod_location_max = *options.twod_location_max();
-        }
-
-        if (options.haystack_bucket_size()) {
-            geo_opt.haystack_bucket_size = *options.haystack_bucket_size();
-        }
+    scoped_bson_t reply;
+    bson_error_t error;
 
-        opt.geo_options = &geo_opt;
-    }
+    scoped_bson_t command_bson{command};
+    scoped_bson_t opts_bson{make_document()};
 
-    auto result = libmongoc::collection_create_index(
-        _get_impl().collection_t, bson_keys.bson(), &opt, &error);
+    auto result = libmongoc::collection_command_simple(
+        _get_impl().collection_t, command_bson.bson(), NULL, reply.bson_for_init(), &error);
 
     if (!result) {
         throw_exception<operation_exception>(error);
     }
 
-    if (options.name()) {
-        return make_document(kvp("name", *options.name()));
-    } else {
-        const auto keys = libmongoc::collection_keys_to_index_string(bson_keys.bson());
-
-        const auto clean_keys = make_guard([&] { bson_free(keys); });
-
-        return make_document(kvp("name", keys));
-    }
+    return make_document(kvp("name", index.view()["name"].get_utf8().value));
 }
 
 cursor collection::distinct(bsoncxx::string::view_or_value field_name,

src/mongocxx/collection.hpp

@@ -247,9 +247,8 @@ class MONGOCXX_API collection {
     /// @param keys
     ///   The keys for the index: @c {a: 1, b: -1}
     /// @param options
-    ///   Optional arguments, see mongocxx::options::index.
+    ///   A document containing optional arguments.
     ///
-    /// @throws mongocxx::logic_error if the options are invalid.
     /// @throws mongocxx::operation_exception if index creation fails.
     ///
     /// @see https://docs.mongodb.com/master/reference/command/createIndexes/
@@ -260,7 +259,7 @@ class MONGOCXX_API collection {
     ///   3.4+)
     ///
     bsoncxx::document::value create_index(bsoncxx::document::view_or_value keys,
-                                          const options::index& options = options::index());
+                                          bsoncxx::document::view_or_value opts = {});
 
     ///
     /// Deletes all matching documents from the collection.

src/mongocxx/options/index.cpp

@@ -17,7 +17,10 @@
 #include <bsoncxx/stdx/make_unique.hpp>
 #include <mongocxx/private/libmongoc.hh>
 
+#include <bsoncxx/builder/basic/document.hpp>
 #include <mongocxx/config/private/prelude.hh>
+#include <mongocxx/exception/error_code.hpp>
+#include <mongocxx/exception/logic_error.hpp>
 
 namespace mongocxx {
 MONGOCXX_INLINE_NAMESPACE_BEGIN
@@ -184,6 +187,100 @@ const stdx::optional<double>& index::haystack_bucket_size() const {
     return _haystack_bucket_size;
 }
 
+index::operator bsoncxx::document::view_or_value() {
+    using namespace bsoncxx;
+    using builder::basic::kvp;
+    using builder::basic::make_document;
+
+    builder::basic::document root;
+
+    if (_name) {
+        root.append(kvp("name", *_name));
+    }
+
+    if (_background) {
+        root.append(kvp("background", *_background));
+    }
+
+    if (_unique) {
+        root.append(kvp("unique", *_unique));
+    }
+
+    if (_partial_filter_expression) {
+        root.append(kvp("partialFilterExpression", *_partial_filter_expression));
+    }
+
+    if (_sparse) {
+        root.append(kvp("sparse", *_sparse));
+    }
+
+    if (_expire_after) {
+        const auto count = _expire_after->count();
+        if ((count < 0) || (count > std::numeric_limits<std::int32_t>::max())) {
+            throw logic_error{error_code::k_invalid_parameter};
+        }
+
+        root.append(kvp("expireAfterSeconds", types::b_int32{static_cast<std::int32_t>(count)}));
+    }
+
+    if (_weights) {
+        root.append(kvp("weights", *_weights));
+    }
+
+    if (_default_language) {
+        root.append(kvp("default_language", types::b_utf8{*_default_language}));
+    }
+
+    if (_language_override) {
+        root.append(kvp("language_override", types::b_utf8{*_language_override}));
+    }
+
+    if (_twod_sphere_version) {
+        root.append(kvp("2dsphereIndexVersion", types::b_int32{*_twod_sphere_version}));
+    }
+
+    if (_twod_bits_precision) {
+        root.append(kvp("bits", types::b_int32{*_twod_bits_precision}));
+    }
+
+    if (_twod_location_min) {
+        root.append(kvp("min", types::b_double{*_twod_location_min}));
+    }
+
+    if (_twod_location_max) {
+        root.append(kvp("max", types::b_double{*_twod_location_max}));
+    }
+
+    if (_haystack_bucket_size) {
+        root.append(kvp("bucketSize", types::b_double{*_haystack_bucket_size}));
+    }
+
+    if (_collation) {
+        root.append(kvp("collation", *_collation));
+    }
+
+    if (_storage_options) {
+        if (_storage_options->type() == MONGOC_INDEX_STORAGE_OPT_WIREDTIGER) {
+            const options::index::wiredtiger_storage_options* wt_options =
+                static_cast<const options::index::wiredtiger_storage_options*>(
+                    _storage_options.get());
+
+            bsoncxx::document::view_or_value storage_doc;
+            if (wt_options->config_string()) {
+                storage_doc = make_document(
+                    kvp("wiredTiger",
+                        make_document(kvp("configString", *wt_options->config_string()))));
+            } else {
+                storage_doc = make_document(
+                    kvp("wiredTiger", make_document(kvp("configString", types::b_null{}))));
+            }
+
+            root.append(kvp("storageEngine", storage_doc));
+        }
+    }
+    return root.extract();
+}
+
 index::base_storage_options::~base_storage_options() = default;
 
 index::wiredtiger_storage_options::~wiredtiger_storage_options() = default;

src/mongocxx/options/index.hpp

@@ -22,6 +22,8 @@
 #include <bsoncxx/string/view_or_value.hpp>
 #include <mongocxx/stdx.hpp>
 
+#include <bsoncxx/document/value.hpp>
+#include <bsoncxx/document/view_or_value.hpp>
 #include <mongocxx/config/prelude.hpp>
 
 namespace mongocxx {
@@ -46,7 +48,7 @@ class MONGOCXX_API index {
         virtual ~base_storage_options();
 
        private:
-        friend collection;
+        friend class options::index;
         MONGOCXX_PRIVATE virtual int type() const = 0;
     };
 
@@ -432,6 +434,15 @@ class MONGOCXX_API index {
     ///
     const stdx::optional<double>& haystack_bucket_size() const;
 
+    ///
+    /// Conversion operator that provides a view of the options in document form.
+    ///
+    /// @exception mongocxx::logic_error if an invalid expireAfterSeconds field is provided.
+    ///
+    /// @return A view of the current builder contents.
+    ///
+    operator bsoncxx::document::view_or_value();
+
    private:
     friend collection;
 

src/mongocxx/private/libmongoc_symbols.hh

@@ -66,6 +66,7 @@ MONGOCXX_LIBMONGOC_SYMBOL(collection_rename)
 MONGOCXX_LIBMONGOC_SYMBOL(collection_set_read_concern)
 MONGOCXX_LIBMONGOC_SYMBOL(collection_set_read_prefs)
 MONGOCXX_LIBMONGOC_SYMBOL(collection_set_write_concern)
+MONGOCXX_LIBMONGOC_SYMBOL(collection_command_simple)
 MONGOCXX_LIBMONGOC_SYMBOL(cursor_destroy)
 MONGOCXX_LIBMONGOC_SYMBOL(cursor_error)
 MONGOCXX_LIBMONGOC_SYMBOL(cursor_new_from_command_reply)