couchbase 4.2.3 → 4.2.4

package/deps/couchbase-cxx-client/test/test_unit_search.cxx

@@ -0,0 +1,427 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, 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 "test_helper.hxx"
+
+#include "core/impl/encoded_search_query.hxx"
+
+#include <couchbase/boolean_field_query.hxx>
+#include <couchbase/boolean_query.hxx>
+#include <couchbase/conjunction_query.hxx>
+#include <couchbase/date_range_query.hxx>
+#include <couchbase/disjunction_query.hxx>
+#include <couchbase/geo_bounding_box_query.hxx>
+#include <couchbase/geo_distance_query.hxx>
+#include <couchbase/geo_polygon_query.hxx>
+#include <couchbase/match_phrase_query.hxx>
+#include <couchbase/match_query.hxx>
+#include <couchbase/numeric_range_query.hxx>
+#include <couchbase/phrase_query.hxx>
+#include <couchbase/prefix_query.hxx>
+#include <couchbase/query_string_query.hxx>
+#include <couchbase/regexp_query.hxx>
+#include <couchbase/term_query.hxx>
+#include <couchbase/term_range_query.hxx>
+#include <couchbase/wildcard_query.hxx>
+
+#include <tao/json.hpp>
+
+using namespace tao::json::literals;
+
+TEST_CASE("unit: query string search query", "[unit]")
+{
+    {
+        // clang-format off
+//! [search-query-string-boosting]
+couchbase::query_string_query query(R"(description:pool name:pool^5)");
+//! [search-query-string-boosting]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == "{\"query\":\"description:pool name:pool^5\"}"_json);
+    }
+    {
+        // clang-format off
+//! [search-query-string-date-range]
+couchbase::query_string_query query(R"(created:>"2016-09-21")");
+//! [search-query-string-date-range]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == "{\"query\":\"created:>\\\"2016-09-21\\\"\"}"_json);
+    }
+
+    {
+        // clang-format off
+//! [search-query-string-numeric-range]
+couchbase::query_string_query query(R"(reviews.ratings.Cleanliness:>4)");
+//! [search-query-string-numeric-range]
+        // clang-format on
+        query.boost(1.42);
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == "{\"boost\":1.42,\"query\":\"reviews.ratings.Cleanliness:>4\"}"_json);
+    }
+}
+
+TEST_CASE("unit: match search query", "[unit]")
+{
+    {
+        // clang-format off
+//! [search-match]
+auto query = couchbase::match_query("location hostel")
+              .field("reviews.content")
+              .analyzer("standard")
+              .fuzziness(2)
+              .prefix_length(4)
+              .match_operator(couchbase::match_operator::logical_and);
+//! [search-match]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"(
+{"analyzer":"standard","field":"reviews.content","fuzziness":2,"match":"location hostel","operator":"and","prefix_length":4}
+)"_json);
+    }
+}
+
+TEST_CASE("unit: conjunction search query", "[unit]")
+{
+    // clang-format off
+//! [search-conjunction]
+auto query = couchbase::conjunction_query{
+  couchbase::match_query("location hostel").field("reviews.content"),
+  couchbase::boolean_field_query(true).field("free_breakfast")
+};
+//! [search-conjunction]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"conjuncts":[
+    {"field":"reviews.content","match":"location hostel"},
+    {"bool":true,"field":"free_breakfast"}
+]}
+)"_json);
+}
+
+TEST_CASE("unit: disjunction search query", "[unit]")
+{
+    // clang-format off
+//! [search-disjunction]
+auto query = couchbase::disjunction_query{
+  couchbase::match_query("location hostel").field("reviews.content"),
+  couchbase::boolean_field_query(true).field("free_breakfast")
+};
+//! [search-disjunction]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"disjuncts":[
+    {"field":"reviews.content","match":"location hostel"},
+    {"bool":true,"field":"free_breakfast"}
+]}
+)"_json);
+}
+
+TEST_CASE("unit: boolean search query", "[unit]")
+{
+    // clang-format off
+//! [search-boolean]
+couchbase::boolean_query query;
+query.must(
+  couchbase::match_query("hostel room").field("reviews.content"),
+  couchbase::boolean_field_query(true).field("free_breakfast"));
+query.should(
+  couchbase::numeric_range_query().field("reviews.ratings.Overall").min(4),
+  couchbase::numeric_range_query().field("reviews.ratings.Service").min(5));
+query.must_not(
+  couchbase::match_query("Padfield Gilingham").field("city"));
+//! [search-boolean]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"must":     {"conjuncts":[{"field":"reviews.content","match":"hostel room"},{"bool":true,"field":"free_breakfast"}]},
+ "must_not": {"disjuncts":[{"field":"city","match":"Padfield Gilingham"}]},
+ "should":   {"disjuncts":[{"field":"reviews.ratings.Overall","min":4},{"field":"reviews.ratings.Service","min":5}]}}
+)"_json);
+}
+
+TEST_CASE("unit: term search query", "[unit]")
+{
+    // clang-format off
+//! [search-term]
+auto query = couchbase::term_query("locate").field("reviews.content");
+//! [search-term]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"term": "locate", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: match phrase search query", "[unit]")
+{
+    // clang-format off
+//! [search-match-phrase]
+auto query = couchbase::match_phrase_query("nice view").field("reviews.content");
+//! [search-match-phrase]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"match_phrase": "nice view", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: phrase search query", "[unit]")
+{
+    // clang-format off
+//! [search-phrase]
+auto query = couchbase::phrase_query({"nice", "view"}).field("reviews.content");
+//! [search-phrase]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"terms": ["nice", "view"], "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: prefix search query", "[unit]")
+{
+    // clang-format off
+//! [search-prefix]
+auto query = couchbase::prefix_query("inter").field("reviews.content");
+//! [search-prefix]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"prefix": "inter", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: regexp search query", "[unit]")
+{
+    // clang-format off
+//! [search-regexp]
+auto query = couchbase::regexp_query("inter.+").field("reviews.content");
+//! [search-regexp]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"regexp": "inter.+", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: wildcard search query", "[unit]")
+{
+    // clang-format off
+//! [search-wildcard]
+auto query = couchbase::wildcard_query("inter*").field("reviews.content");
+//! [search-wildcard]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"wildcard": "inter*", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: numeric range search query", "[unit]")
+{
+    // clang-format off
+//! [search-numeric-range]
+auto query = couchbase::numeric_range_query()
+               .field("id")
+               .min(100,  /* inclusive= */ false)
+               .max(1000, /* inclusive= */ false);
+//! [search-numeric-range]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"min": 100, "inclusive_min": false, "max": 1000, "inclusive_max": false, "field": "id"}
+)"_json);
+}
+
+TEST_CASE("unit: date range search query", "[unit]")
+{
+    {
+        // clang-format off
+//! [search-date-range]
+auto query = couchbase::date_range_query()
+               .field("review_date")
+               .start("2001-10-09T10:20:30-08:00", /* inclusive= */ false)
+               .end("2016-10-31",                  /* inclusive= */ false);
+//! [search-date-range]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"(
+{"start": "2001-10-09T10:20:30-08:00", "inclusive_start": false, "end": "2016-10-31", "inclusive_end": false, "field": "review_date"}
+)"_json);
+    }
+
+    {
+        // clang-format off
+//! [search-date-range-tm]
+std::tm start_tm{};
+start_tm.tm_year = 2001 - 1900;
+start_tm.tm_mon = 9;
+start_tm.tm_mday = 9;
+start_tm.tm_hour = 10;
+start_tm.tm_min = 20;
+start_tm.tm_sec = 30;
+
+std::tm end_tm{};
+end_tm.tm_year = 2001 - 1900;
+end_tm.tm_mon = 9;
+end_tm.tm_mday = 31;
+
+auto query = couchbase::date_range_query()
+               .field("review_date")
+               .start(start_tm)
+               .end(end_tm);
+// equivalent of {"field":"review_date","start":"2001-10-09T10:20:30+0000","end":"2001-10-31T00:00:00+0000"}
+//! [search-date-range-tm]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"(
+{"end":"2001-10-31T00:00:00+0000","field":"review_date","start":"2001-10-09T10:20:30+0000"}
+)"_json);
+    }
+}
+
+TEST_CASE("unit: term range search query", "[unit]")
+{
+    // clang-format off
+//! [search-term-range]
+auto query = couchbase::term_range_query()
+                .field("desc")
+                .min("foo",  /* inclusive= */ false)
+                .max("foof", /* inclusive= */ false);
+//! [search-term-range]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"min": "foo", "inclusive_min": false, "max": "foof", "inclusive_max": false, "field": "desc"}
+)"_json);
+}
+
+TEST_CASE("unit: special search query", "[unit]")
+{
+    {
+        auto query = couchbase::match_none_query();
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"({"match_none": {}})"_json);
+    }
+    {
+        auto query = couchbase::match_all_query();
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"({"match_all": {}})"_json);
+    }
+}
+
+TEST_CASE("unit: geo distance search query", "[unit]")
+{
+    // clang-format off
+//! [search-geo-distance]
+auto query = couchbase::geo_distance_query(53.482358, -2.235143, "100mi")
+               .field("geo");
+//! [search-geo-distance]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{
+  "location": {
+    "lon": -2.235143,
+    "lat": 53.482358
+   },
+    "distance": "100mi",
+    "field": "geo"
+}
+)"_json);
+}
+
+TEST_CASE("unit: geo bounding box search query", "[unit]")
+{
+    // clang-format off
+//! [search-geo-bounding-box]
+auto query = couchbase::geo_bounding_box_query(
+                  couchbase::geo_point{53.482358, -2.235143},
+                  couchbase::geo_point{40.991862, 28.955043}
+                ).field("geo");
+//! [search-geo-bounding-box]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{
+  "top_left": {
+    "lon": -2.235143,
+    "lat": 53.482358
+   },
+  "bottom_right": {
+    "lon": 28.955043,
+    "lat": 40.991862
+   },
+    "field": "geo"
+}
+)"_json);
+}
+
+TEST_CASE("unit: geo polygon search query", "[unit]")
+{
+    // clang-format off
+//! [search-geo-polygon]
+auto query = couchbase::geo_polygon_query({
+                couchbase::geo_point{ 37.79393211306212, -122.44234633404847 },
+                couchbase::geo_point{ 37.77995881733997, -122.43977141339417 },
+                couchbase::geo_point{ 37.788031092020155, -122.42925715405579 },
+                couchbase::geo_point{ 37.79026946582319, -122.41149020154114 },
+                couchbase::geo_point{ 37.79571192027403, -122.40735054016113 },
+                couchbase::geo_point{ 37.79393211306212, -122.44234633404847 },
+             }).field("geo");
+//! [search-geo-polygon]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{
+    "field": "geo",
+    "polygon_points": [
+      {"lat": 37.79393211306212, "lon": -122.44234633404847},
+      {"lat": 37.77995881733997, "lon": -122.43977141339417},
+      {"lat": 37.788031092020155, "lon": -122.42925715405579},
+      {"lat": 37.79026946582319, "lon": -122.41149020154114},
+      {"lat": 37.79571192027403, "lon": -122.40735054016113},
+      {"lat": 37.79393211306212, "lon": -122.44234633404847}
+    ]
+}
+)"_json);
+}

package/deps/couchbase-cxx-client/test/utils/integration_test_guard.cxx

@@ -63,7 +63,7 @@ build_origin(const test_context& ctx,
         ctx.dns_nameserver.value_or(couchbase::core::io::dns::dns_config::default_nameserver),
         ctx.dns_port.value_or(couchbase::core::io::dns::dns_config::default_port),
     };
-    if (ctx.deployment == deployment_type::capella) {
+    if (ctx.deployment == deployment_type::capella || ctx.deployment == test::utils::deployment_type::elixir) {
         origin.options().apply_profile("wan_development");
     }
     return origin;
@@ -213,6 +213,7 @@ integration_test_guard::cluster_version()
     auto parsed_version = server_version::parse(runtime_version, ctx.deployment);
     parsed_version.profile = runtime_pools_info.config_profile;
     parsed_version.developer_preview = runtime_pools_info.is_developer_preview;
+    parsed_version.use_gocaves = ctx.version.use_gocaves;
     if (parsed_version.major == 0) {
         /* the build does not specify version properly */
         return ctx.version;

package/deps/couchbase-cxx-client/test/utils/logger.cxx

@@ -32,7 +32,9 @@ init_logger()
         if (auto env_val = spdlog::details::os::getenv("TEST_LOG_LEVEL"); !env_val.empty()) {
             couchbase::core::logger::set_log_levels(couchbase::core::logger::level_from_str(env_val));
         }
-        spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v at %@ %!");
+        if (auto env_val = spdlog::details::os::getenv("TEST_LOG_INCLUDE_LOCATION"); !env_val.empty()) {
+            spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v at %@ %!");
+        }
         initialized = true;
     }
 }

package/deps/couchbase-cxx-client/test/utils/server_version.hxx

@@ -38,8 +38,14 @@ struct server_version {
     server_edition edition{ server_edition::unknown };
     deployment_type deployment{ deployment_type::on_prem };
     server_config_profile profile{ server_config_profile::unknown };
+    bool use_gocaves{ false };
 
-    static server_version parse(const std::string& str, const deployment_type deployment);
+    static server_version parse(const std::string& str, deployment_type deployment);
+
+    [[nodiscard]] bool is_mock() const
+    {
+        return use_gocaves;
+    }
 
     [[nodiscard]] bool is_alice() const
     {
@@ -97,7 +103,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_preserve_expiry() const
     {
-        return is_cheshire_cat() || is_neo();
+        return !use_gocaves && (is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_preserve_expiry_for_query() const
@@ -112,27 +118,37 @@ struct server_version {
 
     [[nodiscard]] bool supports_query_index_management() const
     {
-        return is_mad_hatter() || is_cheshire_cat() || is_neo();
+        return !use_gocaves && (is_mad_hatter() || is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_analytics() const
     {
-        return is_enterprise() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
+        return !use_gocaves && is_enterprise() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
+    }
+
+    [[nodiscard]] bool supports_query() const
+    {
+        return !use_gocaves;
+    }
+
+    [[nodiscard]] bool supports_search() const
+    {
+        return !use_gocaves;
     }
 
     [[nodiscard]] bool supports_analytics_pending_mutations() const
     {
-        return is_mad_hatter() || is_cheshire_cat() || is_neo();
+        return supports_analytics() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_analytics_link_azure_blob() const
     {
-        return is_cheshire_cat() && developer_preview;
+        return supports_analytics() && is_cheshire_cat() && developer_preview;
     }
 
     [[nodiscard]] bool supports_analytics_links() const
     {
-        return (major == 6 && minor >= 6) || major > 6;
+        return supports_analytics() && ((major == 6 && minor >= 6) || major > 6);
     }
 
     [[nodiscard]] bool supports_minimum_durability_level() const
@@ -142,17 +158,17 @@ struct server_version {
 
     [[nodiscard]] bool supports_search_analyze() const
     {
-        return is_mad_hatter() || is_cheshire_cat() || is_neo();
+        return supports_search() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_analytics_links_cert_auth() const
     {
-        return is_neo();
+        return supports_analytics() && is_neo();
     }
 
     [[nodiscard]] bool supports_eventing_functions() const
     {
-        return is_enterprise() && (is_cheshire_cat() || is_neo()) && deployment == deployment_type::on_prem;
+        return !use_gocaves && is_enterprise() && (is_cheshire_cat() || is_neo()) && deployment == deployment_type::on_prem;
     }
 
     [[nodiscard]] bool is_enterprise() const
@@ -167,22 +183,22 @@ struct server_version {
 
     [[nodiscard]] bool supports_bucket_management() const
     {
-        return deployment == deployment_type::on_prem;
+        return !use_gocaves && deployment == deployment_type::on_prem;
     }
 
     [[nodiscard]] bool supports_user_management() const
     {
-        return deployment == deployment_type::on_prem;
+        return !use_gocaves && deployment == deployment_type::on_prem;
     }
 
     [[nodiscard]] bool requires_search_replicas() const
     {
-        return deployment == deployment_type::capella || is_serverless_config_profile();
+        return deployment == deployment_type::elixir || deployment == deployment_type::capella || is_serverless_config_profile();
     }
 
     [[nodiscard]] bool supports_views() const
     {
-        return deployment == deployment_type::on_prem && (major < 7 || (major == 7 && minor < 2));
+        return !use_gocaves && deployment == deployment_type::on_prem && (major < 7 || (major == 7 && minor < 2));
     }
 
     [[nodiscard]] bool supports_memcached_buckets() const
@@ -197,7 +213,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_search_disable_scoring() const
     {
-        return is_mad_hatter() || is_cheshire_cat() || is_neo();
+        return supports_search() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
     }
 };
 

package/deps/couchbase-cxx-client/test/utils/test_context.cxx

@@ -92,6 +92,14 @@ test_context::load_from_environment()
         ctx.number_of_io_threads = std::stoul(var);
     }
 
+    if (auto var = spdlog::details::os::getenv("TEST_USE_GOCAVES"); !var.empty()) {
+        if (var == "true" || var == "yes" || var == "1") {
+            ctx.version.use_gocaves = true;
+        } else if (var == "false" || var == "no" || var == "0") {
+            ctx.version.use_gocaves = false;
+        }
+    }
+
     return ctx;
 }
 } // namespace test::utils

package/deps/couchbase-cxx-client/tools/get.cxx

@@ -47,6 +47,7 @@ Usage:
 
 Options:
   -h --help                 Show this screen.
+  --verbose                 Include more context and information where it is applicable.
   --bucket-name=STRING      Name of the bucket. [default: {bucket_name}]
   --scope-name=STRING       Name of the scope. [default: {scope_name}]
   --collection-name=STRING  Name of the collection. [default: {collection_name}]
@@ -79,6 +80,7 @@ struct command_options {
     bool hexdump{ false };
     bool pretty_json{ false };
     bool json_lines{ false };
+    bool verbose{ false };
 };
 
 static void
@@ -141,16 +143,14 @@ print_result(const std::string& bucket_name,
         } else {
             fmt::print(stderr, "{}, error: {}\n", prefix, ctx.ec().message());
         }
+        if (cmd_options.verbose) {
+            fmt::print(stderr, "{}\n", ctx.to_json());
+        }
     } else {
         auto [value, flags] = resp.content_as<cbc::passthrough_transcoder>();
-        if (resp.expiry_time()) {
-            fmt::print(stderr,
-                       "{}, size: {}, CAS: 0x{}, flags: 0x{:08x}, expiry: {}\n",
-                       prefix,
-                       value.size(),
-                       resp.cas(),
-                       flags,
-                       resp.expiry_time().value());
+        if (const auto& exptime = resp.expiry_time(); exptime.has_value()) {
+            fmt::print(
+              stderr, "{}, size: {}, CAS: 0x{}, flags: 0x{:08x}, expiry: {}\n", prefix, value.size(), resp.cas(), flags, exptime.value());
         } else {
             fmt::print(stderr, "{}, size: {}, CAS: 0x{}, flags: 0x{:08x}\n", prefix, value.size(), resp.cas(), flags);
         }
@@ -247,6 +247,7 @@ cbc::get::execute(const std::vector<std::string>& argv)
     cbc::fill_cluster_options(options, cluster_options, connection_string);
 
     command_options cmd_options{};
+    cmd_options.verbose = options["--verbose"].asBool();
     cmd_options.bucket_name = options["--bucket-name"].asString();
     cmd_options.scope_name = options["--scope-name"].asString();
     cmd_options.collection_name = options["--collection-name"].asString();