CXX-687: add option class for index creation

Author: Machyne

examples/mongocxx/index.cpp

@@ -1,7 +1,9 @@
 #include <bsoncxx/builder/stream/document.hpp>
 
+#include <bsoncxx/stdx/make_unique.hpp>
 #include <mongocxx/client.hpp>
 #include <mongocxx/instance.hpp>
+#include <mongocxx/stdx.hpp>
 #include <mongocxx/uri.hpp>
 
 using bsoncxx::builder::stream::document;
@@ -15,6 +17,11 @@ int main(int, char**) {
     mongocxx::client conn{mongocxx::uri{}};
 
     auto db = conn["test"];
+    try {
+        db["restaurants"].drop();
+    } catch (const std::exception&) {
+        // Collection did not exist.
+    }
 
     // Create a single field index.
     {
@@ -27,10 +34,38 @@ int main(int, char**) {
 
     // Create a compound index.
     {
+        db["restaurants"].drop();
         // @begin: cpp-create-compound-index
         document index_spec;
         index_spec << "cuisine" << 1 << "address.zipcode" << -1;
         db["restaurants"].create_index(index_spec, {});
         // @end: cpp-create-compound-index
     }
+
+    // Create a unique index.
+    {
+        db["restaurants"].drop();
+        // @begin: cpp-create-unique-index
+        document index_spec;
+        mongocxx::options::index index_options{};
+        index_spec << "website" << 1;
+        index_options.unique(true);
+        db["restaurants"].create_index(index_spec, index_options);
+        // @end: cpp-create-unique-index
+    }
+
+    // Create an index with storage engine options
+    {
+        db["restaurants"].drop();
+        // @begin: cpp-create-wt-options-index
+        document index_spec;
+        mongocxx::options::index index_options{};
+        std::unique_ptr<mongocxx::options::index::wiredtiger_storage_options> wt_options =
+            mongocxx::stdx::make_unique<mongocxx::options::index::wiredtiger_storage_options>();
+        index_spec << "cuisine" << 1;
+        wt_options->config_string("block_allocation=first");
+        index_options.storage_options(std::move(wt_options));
+        db["restaurants"].create_index(index_spec, index_options);
+        // @begin: cpp-create-wt-options-index
+    }
 }

src/mongocxx/CMakeLists.txt

@@ -47,6 +47,7 @@ set(mongocxx_sources
     options/find_one_and_delete.cpp
     options/find_one_and_replace.cpp
     options/find_one_and_update.cpp
+    options/index.cpp
     options/insert.cpp
     options/ssl.cpp
     options/update.cpp

src/mongocxx/collection.cpp

@@ -466,12 +466,102 @@ std::int64_t collection::count(bsoncxx::document::view filter, const options::co
 }
 
 bsoncxx::document::value collection::create_index(bsoncxx::document::view keys,
-                                                  bsoncxx::document::view options) {
+                                                  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);
+
+    if (options.background()) {
+        opt.background = *options.background();
+    }
+
+    if (options.unique()) {
+        opt.unique = *options.unique();
+    }
+
+    if (options.name()) {
+        opt.name = options.name()->c_str();
+    }
+
+    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);
+
+        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());
+
+            if (wt_options->config_string()) {
+                wt_opt.config_str = wt_options->config_string()->c_str();
+            }
+            opt.storage_options = reinterpret_cast<mongoc_index_opt_storage_t*>(&wt_opt);
+        }
+    }
+
+    if (options.expire_after_seconds()) {
+        opt.expire_after_seconds = *options.expire_after_seconds();
+    }
+
+    if (options.version()) {
+        opt.v = *options.version();
+    }
+
+    if (options.weights()) {
+        scoped_bson_t weights{options.weights()};
+        opt.weights = weights.bson();
+    }
+
+    if (options.default_language()) {
+        opt.default_language = options.default_language()->c_str();
+    }
+
+    if (options.language_override()) {
+        opt.language_override = options.language_override()->c_str();
+    }
+
+    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();
+        }
+
+        opt.geo_options = &geo_opt;
+    }
 
     auto result =
-        libmongoc::collection_create_index(_impl->collection_t, bson_keys.bson(), nullptr, &error);
+        libmongoc::collection_create_index(_impl->collection_t, bson_keys.bson(), &opt, &error);
 
     if (!result) {
         throw exception::operation(std::make_tuple(error.message, error.code));

src/mongocxx/collection.hpp

@@ -37,6 +37,7 @@
 #include <mongocxx/options/find_one_and_delete.hpp>
 #include <mongocxx/options/find_one_and_replace.hpp>
 #include <mongocxx/options/find_one_and_update.hpp>
+#include <mongocxx/options/index.hpp>
 #include <mongocxx/options/insert.hpp>
 #include <mongocxx/options/update.hpp>
 #include <mongocxx/read_preference.hpp>
@@ -203,16 +204,14 @@ class MONGOCXX_API collection {
     /// @param keys
     ///   The keys for the index: @c {a: 1, b: -1}
     /// @param options
-    ///   Optional arguments to index creation command, see ensureindex-options link
+    ///   Optional arguments, see mongocxx::options::index.
     ///
     /// @throws exception::operation if index creation fails.
     ///
     /// @see http://docs.mongodb.org/manual/reference/method/db.collection.createIndex/
-    /// @see
-    /// http://docs.mongodb.org/manual/reference/method/db.collection.ensureIndex/#ensureindex-options
     ///
-    bsoncxx::document::value create_index(
-        bsoncxx::document::view keys, bsoncxx::document::view options = bsoncxx::document::view{});
+    bsoncxx::document::value create_index(bsoncxx::document::view keys,
+                                          const options::index& options = options::index());
 
     ///
     /// Deletes all matching documents from the collection.

src/mongocxx/options/index.cpp

@@ -0,0 +1,179 @@
+// Copyright 2015 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.
+
+#include <mongocxx/options/index.hpp>
+
+#include <bsoncxx/stdx/make_unique.hpp>
+#include <mongocxx/private/libmongoc.hpp>
+
+namespace mongocxx {
+MONGOCXX_INLINE_NAMESPACE_BEGIN
+namespace options {
+
+index::index() = default;
+
+void index::background(bool background) {
+    _background = background;
+}
+
+void index::unique(bool unique) {
+    _unique = unique;
+}
+
+void index::name(std::string name) {
+    _name = std::move(name);
+}
+
+void index::sparse(bool sparse) {
+    _sparse = sparse;
+}
+
+void index::storage_options(std::unique_ptr<index::base_storage_options> storage_options) {
+    _storage_options = std::move(storage_options);
+}
+
+void index::storage_options(std::unique_ptr<index::wiredtiger_storage_options> storage_options) {
+    _storage_options = std::move(std::unique_ptr<index::base_storage_options>(
+        static_cast<index::base_storage_options*>(storage_options.release())));
+}
+
+void index::expire_after_seconds(std::int32_t expire_after_seconds) {
+    _expire_after_seconds = expire_after_seconds;
+}
+
+void index::version(std::int32_t version) {
+    _version = version;
+}
+
+void index::weights(bsoncxx::document::view weights) {
+    _weights = weights;
+}
+
+void index::default_language(std::string default_language) {
+    _default_language = std::move(default_language);
+}
+
+void index::language_override(std::string language_override) {
+    _language_override = std::move(language_override);
+}
+
+void index::partial_filter_expression(bsoncxx::document::view partial_filter_expression) {
+    _partial_filter_expression = partial_filter_expression;
+}
+
+void index::twod_sphere_version(std::uint8_t twod_sphere_version) {
+    _twod_sphere_version = twod_sphere_version;
+}
+
+void index::twod_bits_precision(std::uint8_t twod_bits_precision) {
+    _twod_bits_precision = twod_bits_precision;
+}
+
+void index::twod_location_min(double twod_location_min) {
+    _twod_location_min = twod_location_min;
+}
+
+void index::twod_location_max(double twod_location_max) {
+    _twod_location_max = twod_location_max;
+}
+
+void index::haystack_bucket_size(double haystack_bucket_size) {
+    _haystack_bucket_size = haystack_bucket_size;
+}
+
+const stdx::optional<bool>& index::background() const {
+    return _background;
+}
+
+const stdx::optional<bool>& index::unique() const {
+    return _unique;
+}
+
+const stdx::optional<std::string>& index::name() const {
+    return _name;
+}
+
+const stdx::optional<bool>& index::sparse() const {
+    return _sparse;
+}
+
+const std::unique_ptr<index::base_storage_options>& index::storage_options() const {
+    return _storage_options;
+}
+
+const stdx::optional<std::int32_t>& index::expire_after_seconds() const {
+    return _expire_after_seconds;
+}
+
+const stdx::optional<std::int32_t>& index::version() const {
+    return _version;
+}
+
+const stdx::optional<bsoncxx::document::view>& index::weights() const {
+    return _weights;
+}
+
+const stdx::optional<std::string>& index::default_language() const {
+    return _default_language;
+}
+
+const stdx::optional<std::string>& index::language_override() const {
+    return _language_override;
+}
+
+const stdx::optional<bsoncxx::document::view>& index::partial_filter_expression() const {
+    return _partial_filter_expression;
+}
+
+const stdx::optional<std::uint8_t>& index::twod_sphere_version() const {
+    return _twod_sphere_version;
+}
+
+const stdx::optional<std::uint8_t>& index::twod_bits_precision() const {
+    return _twod_bits_precision;
+}
+
+const stdx::optional<double>& index::twod_location_min() const {
+    return _twod_location_min;
+}
+
+const stdx::optional<double>& index::twod_location_max() const {
+    return _twod_location_max;
+}
+
+const stdx::optional<double>& index::haystack_bucket_size() const {
+    return _haystack_bucket_size;
+}
+
+index::base_storage_options::~base_storage_options() = default;
+
+index::wiredtiger_storage_options::~wiredtiger_storage_options() = default;
+
+void index::wiredtiger_storage_options::config_string(std::string config_string) {
+    _config_string = std::move(config_string);
+}
+
+const stdx::optional<std::string>& index::wiredtiger_storage_options::config_string() const {
+    return _config_string;
+}
+
+const int index::wiredtiger_storage_options::type() const {
+    return mongoc_index_storage_opt_type_t::MONGOC_INDEX_STORAGE_OPT_WIREDTIGER;
+}
+
+}  // namespace options
+MONGOCXX_INLINE_NAMESPACE_END
+}  // namespace mongocxx
+
+#include <mongocxx/config/postlude.hpp>