couchbase 3.0.0.beta.1 → 3.0.0

data/ext/couchbase/operations/document_decrement.hxx

@@ -19,6 +19,7 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_decrement.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -45,6 +46,7 @@ struct decrement_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_exists.hxx

@@ -19,6 +19,7 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_exists.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -42,6 +43,7 @@ struct exists_request {
     std::uint16_t partition{};
     std::uint32_t opaque{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_get.hxx

@@ -19,6 +19,7 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_get.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -40,6 +41,7 @@ struct get_request {
     uint16_t partition{};
     uint32_t opaque{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ true };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_get_and_lock.hxx

@@ -19,6 +19,7 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_get_and_lock.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -41,6 +42,7 @@ struct get_and_lock_request {
     uint32_t opaque{};
     uint32_t lock_time{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_get_and_touch.hxx

@@ -19,6 +19,7 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_get_and_touch.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -41,6 +42,7 @@ struct get_and_touch_request {
     uint32_t opaque{};
     uint32_t expiry{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_get_projected.hxx

@@ -19,6 +19,7 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_lookup_in.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -45,6 +46,7 @@ struct get_projected_request {
     std::vector<std::string> effective_projections{};
     bool preserve_array_indexes{ false };
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ true };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_increment.hxx

@@ -21,6 +21,7 @@
 #include <protocol/durability_level.hxx>
 #include <operations.hxx>
 #include <protocol/client_response.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -47,6 +48,7 @@ struct increment_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_insert.hxx

@@ -20,6 +20,7 @@
 #include <document_id.hxx>
 #include <protocol/cmd_insert.hxx>
 #include <protocol/durability_level.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -45,6 +46,7 @@ struct insert_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_lookup_in.hxx

@@ -20,6 +20,7 @@
 #include <gsl/gsl_assert>
 #include <document_id.hxx>
 #include <protocol/cmd_lookup_in.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -50,6 +51,7 @@ struct lookup_in_request {
     bool access_deleted{ false };
     protocol::lookup_in_request_body::lookup_in_specs specs{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_mutate_in.hxx

@@ -25,6 +25,8 @@
 #include <protocol/durability_level.hxx>
 #include <protocol/client_request.hxx>
 
+#include <io/retry_context.hxx>
+
 #include <mutation_token.hxx>
 #include <document_id.hxx>
 #include <timeout_defaults.hxx>
@@ -67,6 +69,7 @@ struct mutate_in_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_query.hxx

@@ -168,6 +168,9 @@ struct query_request {
     std::optional<scan_consistency_type> scan_consistency{};
     std::vector<mutation_token> mutation_state{};
     std::chrono::milliseconds timeout{ timeout_defaults::query_timeout };
+    std::optional<std::string> bucket_name{};
+    std::optional<std::string> scope_name{};
+    std::optional<std::string> scope_qualifier{};
 
     enum class profile_mode {
         off,
@@ -255,6 +258,13 @@ struct query_request {
         if (check_scan_wait && scan_wait) {
             body["scan_wait"] = fmt::format("{}ms", scan_wait.value());
         }
+        if (scope_qualifier) {
+            body["query_context"] = scope_qualifier;
+        } else if (scope_name) {
+            if (bucket_name) {
+                body["query_context"] = fmt::format("`{}`.{}", *bucket_name, *scope_name);
+            }
+        }
         for (auto& param : raw) {
             body[param.first] = param.second;
         }

data/ext/couchbase/operations/document_remove.hxx

@@ -19,6 +19,7 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_remove.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -41,6 +42,7 @@ struct remove_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_replace.hxx

@@ -20,6 +20,7 @@
 #include <document_id.hxx>
 #include <protocol/cmd_replace.hxx>
 #include <protocol/durability_level.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -46,6 +47,7 @@ struct replace_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_search.hxx

@@ -231,7 +231,7 @@ make_response(std::error_code ec, search_request& request, search_request::encod
                     search_response::search_row row{};
                     row.index = entry.at("index").get_string();
                     row.id = entry.at("id").get_string();
-                    row.score = entry.at("score").get_double();
+                    row.score = entry.at("score").as<double>();
                     const auto* locations = entry.find("locations");
                     if (locations != nullptr && locations->is_object()) {
                         for (const auto& field : locations->get_object()) {
@@ -306,7 +306,7 @@ make_response(std::error_code ec, search_request& request, search_request::encod
                             const auto* min = numeric_range.find("min");
                             if (min != nullptr) {
                                 if (min->is_double()) {
-                                    nrf.min = min->get_double();
+                                    nrf.min = min->as<double>();
                                 } else if (min->is_integer()) {
                                     nrf.min = min->get_unsigned();
                                 }
@@ -314,7 +314,7 @@ make_response(std::error_code ec, search_request& request, search_request::encod
                             const auto* max = numeric_range.find("max");
                             if (max != nullptr) {
                                 if (max->is_double()) {
-                                    nrf.max = max->get_double();
+                                    nrf.max = max->as<double>();
                                 } else if (max->is_integer()) {
                                     nrf.max = max->get_unsigned();
                                 }
@@ -346,6 +346,11 @@ make_response(std::error_code ec, search_request& request, search_request::encod
                 response.ec = std::make_error_code(error::common_errc::index_not_found);
                 return response;
             }
+            if (response.error.find("no planPIndexes for indexName") != std::string::npos ||
+                response.error.find("pindex_consistency mismatched partition") != std::string::npos) {
+                response.ec = std::make_error_code(error::search_errc::index_not_ready);
+                return response;
+            }
         }
         response.ec = std::make_error_code(error::common_errc::internal_server_failure);
     }

data/ext/couchbase/operations/document_touch.hxx

@@ -19,6 +19,7 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_touch.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -39,6 +40,7 @@ struct touch_request {
     std::uint32_t opaque{};
     std::uint32_t expiry{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_unlock.hxx

@@ -19,6 +19,7 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_unlock.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -39,6 +40,7 @@ struct unlock_request {
     uint32_t opaque{};
     uint64_t cas{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_upsert.hxx

@@ -20,6 +20,7 @@
 #include <document_id.hxx>
 #include <protocol/cmd_upsert.hxx>
 #include <protocol/durability_level.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
@@ -45,6 +46,7 @@ struct upsert_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/query_index_create.hxx

@@ -42,7 +42,10 @@ struct query_index_create_request {
     static const inline service_type type = service_type::query;
 
     std::string client_context_id{ uuid::to_string(uuid::random()) };
+    static constexpr auto namespace_id = "default";
     std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
     std::string index_name{};
     std::vector<std::string> fields;
     bool is_primary{ false };
@@ -70,14 +73,21 @@ struct query_index_create_request {
         if (with) {
             with_clause = fmt::format("WITH {}", tao::json::to_string(with));
         }
+        std::string keyspace = fmt::format("{}:`{}`", namespace_id, bucket_name);
+        if (!scope_name.empty()) {
+            keyspace += ".`" + scope_name + "`";
+        }
+        if (!collection_name.empty()) {
+            keyspace += ".`" + collection_name + "`";
+        }
         tao::json::value body{ { "statement",
-                                 is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON `{}` USING GSI {})",
+                                 is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON {} USING GSI {})",
                                                           index_name.empty() ? "" : fmt::format("`{}`", index_name),
-                                                          bucket_name,
+                                                          keyspace,
                                                           with_clause)
-                                            : fmt::format(R"(CREATE INDEX `{}` ON `{}`({}) {} USING GSI {})",
+                                            : fmt::format(R"(CREATE INDEX `{}` ON {}({}) {} USING GSI {})",
                                                           index_name,
-                                                          bucket_name,
+                                                          keyspace,
                                                           fmt::join(fields, ", "),
                                                           where_clause,
                                                           with_clause) },

data/ext/couchbase/operations/query_index_drop.hxx

@@ -42,7 +42,10 @@ struct query_index_drop_request {
     static const inline service_type type = service_type::query;
 
     std::string client_context_id{ uuid::to_string(uuid::random()) };
+    static constexpr auto namespace_id = "default";
     std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
     std::string index_name;
     bool is_primary{ false };
     bool ignore_if_does_not_exist{ false };
@@ -51,9 +54,16 @@ struct query_index_drop_request {
     void encode_to(encoded_request_type& encoded)
     {
         encoded.headers["content-type"] = "application/json";
+        std::string keyspace = fmt::format("`{}`", bucket_name);
+        if (!scope_name.empty()) {
+            keyspace += ".`" + scope_name + "`";
+        }
+        if (!collection_name.empty()) {
+            keyspace += ".`" + collection_name + "`";
+        }
         tao::json::value body{ { "statement",
-                                 is_primary ? fmt::format(R"(DROP PRIMARY INDEX ON `{}` USING GSI)", bucket_name)
-                                            : fmt::format(R"(DROP INDEX `{}`.`{}` USING GSI)", bucket_name, index_name) },
+                                 is_primary ? fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace)
+                                            : fmt::format(R"(DROP INDEX {}.`{}` USING GSI)", keyspace, index_name) },
                                { "client_context_id", client_context_id } };
         encoded.method = "POST";
         encoded.path = "/query/service";

data/ext/couchbase/operations/query_index_get_all.hxx

@@ -32,9 +32,12 @@ struct query_index_get_all_response {
         std::string datastore_id;
         std::string keyspace_id;
         std::string namespace_id;
+        std::string collection_name;
         std::string type;
         std::vector<std::string> index_key{};
         std::optional<std::string> condition{};
+        std::optional<std::string> bucket_id{};
+        std::optional<std::string> scope_id{};
     };
     std::string client_context_id;
     std::error_code ec;
@@ -59,8 +62,8 @@ struct query_index_get_all_request {
         tao::json::value body{
             { "statement",
               fmt::format(
-                R"(SELECT idx.* FROM system:indexes AS idx WHERE keyspace_id = "{}" AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
-                bucket_name) },
+                R"(SELECT idx.* FROM system:indexes AS idx WHERE ((keyspace_id = "{}" AND bucket_id IS MISSING) OR (bucket_id = "{}")) AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
+                bucket_name, bucket_name) },
             { "client_context_id", client_context_id }
         };
         encoded.method = "POST";
@@ -87,6 +90,12 @@ make_response(std::error_code ec, query_index_get_all_request& request, query_in
                     index.type = entry.at("using").get_string();
                     index.name = entry.at("name").get_string();
                     index.state = entry.at("state").get_string();
+                    if (const auto* prop = entry.find("bucket_id")) {
+                        index.bucket_id = prop->get_string();
+                    }
+                    if (const auto* prop = entry.find("scope_id")) {
+                        index.scope_id = prop->get_string();
+                    }
                     if (const auto* prop = entry.find("is_primary")) {
                         index.is_primary = prop->get_boolean();
                     }

data/ext/couchbase/origin.hxx

@@ -23,6 +23,18 @@
 
 namespace couchbase
 {
+struct cluster_credentials {
+    std::string username;
+    std::string password;
+    std::string certificate_path;
+    std::string key_path;
+
+    [[nodiscard]] bool uses_certificate() const
+    {
+        return !certificate_path.empty();
+    }
+};
+
 struct origin {
     using node_entry = std::pair<std::string, std::string>;
     using node_list = std::vector<node_entry>;
@@ -33,26 +45,31 @@ struct origin {
 
     origin(const origin& other)
       : options_(other.options_)
-      , username_(other.username_)
-      , password_(other.password_)
+      , credentials_(std::move(other.credentials_))
       , nodes_(other.nodes_)
       , next_node_(nodes_.begin())
     {
     }
 
-    origin(std::string username, std::string password, const std::string& hostname, std::uint16_t port, const cluster_options& options)
+    origin(cluster_credentials auth, const std::string& hostname, std::uint16_t port, const cluster_options& options)
       : options_(options)
-      , username_(std::move(username))
-      , password_(std::move(password))
+      , credentials_(std::move(auth))
       , nodes_{ { hostname, std::to_string(port) } }
       , next_node_(nodes_.begin())
     {
     }
 
-    origin(std::string username, std::string password, const utils::connection_string& connstr)
+    origin(cluster_credentials auth, const std::string& hostname, const std::string& port, const cluster_options& options)
+      : options_(options)
+      , credentials_(std::move(auth))
+      , nodes_{ { hostname, port } }
+      , next_node_(nodes_.begin())
+    {
+    }
+
+    origin(cluster_credentials auth, const utils::connection_string& connstr)
       : options_(connstr.options)
-      , username_(std::move(username))
-      , password_(std::move(password))
+      , credentials_(std::move(auth))
     {
         nodes_.reserve(connstr.bootstrap_nodes.size());
         for (const auto& node : connstr.bootstrap_nodes) {
@@ -66,8 +83,7 @@ struct origin {
     {
         if (this != &other) {
             options_ = other.options_;
-            username_ = other.username_;
-            password_ = other.password_;
+            credentials_ = other.credentials_;
             nodes_ = other.nodes_;
             next_node_ = nodes_.begin();
             exhausted_ = false;
@@ -75,21 +91,31 @@ struct origin {
         return *this;
     }
 
-    [[nodiscard]] const std::string& get_username() const
+    [[nodiscard]] const std::string& username() const
     {
-        return username_;
+        return credentials_.username;
     }
 
-    [[nodiscard]] const std::string& get_password() const
+    [[nodiscard]] const std::string& password() const
     {
-        return password_;
+        return credentials_.password;
+    }
+
+    [[nodiscard]] const std::string& certificate_path() const
+    {
+        return credentials_.certificate_path;
+    }
+
+    [[nodiscard]] const std::string& key_path() const
+    {
+        return credentials_.key_path;
     }
 
     [[nodiscard]] std::vector<std::string> get_nodes() const
     {
         std::vector<std::string> res;
         res.reserve(nodes_.size());
-        for (const auto &node : nodes_) {
+        for (const auto& node : nodes_) {
             res.emplace_back(fmt::format("\"{}:{}\"", node.first, node.second));
         }
         return res;
@@ -136,10 +162,14 @@ struct origin {
         return options_;
     }
 
+    [[nodiscard]] const couchbase::cluster_credentials& credentials() const
+    {
+        return credentials_;
+    }
+
   private:
     couchbase::cluster_options options_{};
-    std::string username_{};
-    std::string password_{};
+    cluster_credentials credentials_{};
     node_list nodes_{};
     node_list::iterator next_node_{};
     bool exhausted_{ false };