couchbase 3.0.0.alpha.2 → 3.0.0

data/ext/couchbase/operations/document_increment.hxx

@@ -17,14 +17,18 @@
 
 #pragma once
 
-#include <document_id.hxx>
 #include <protocol/cmd_increment.hxx>
+#include <protocol/durability_level.hxx>
+#include <operations.hxx>
+#include <protocol/client_response.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
 
 struct increment_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t content{};
     std::uint64_t cas{};
@@ -38,11 +42,13 @@ struct increment_request {
     document_id id;
     std::uint16_t partition{};
     std::uint32_t opaque{};
-    std::uint32_t expiration{ 0 };
+    std::uint32_t expiry{ 0 };
     std::uint64_t delta{ 1 };
     std::optional<std::uint64_t> initial_value{};
     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)
     {
@@ -52,10 +58,10 @@ struct increment_request {
         encoded.body().delta(delta);
         if (initial_value) {
             encoded.body().initial_value(initial_value.value());
-            encoded.body().expiration(expiration);
+            encoded.body().expiry(expiry);
         } else {
             encoded.body().initial_value(0);
-            encoded.body().expiration(0xffff'ffff);
+            encoded.body().expiry(0xffff'ffff);
         }
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
@@ -66,7 +72,10 @@ struct increment_request {
 increment_response
 make_response(std::error_code ec, increment_request& request, increment_request::encoded_response_type encoded)
 {
-    increment_response response{ request.id, ec };
+    increment_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.cas = encoded.cas();
         response.content = encoded.body().content();

data/ext/couchbase/operations/document_insert.hxx

@@ -20,12 +20,14 @@
 #include <document_id.hxx>
 #include <protocol/cmd_insert.hxx>
 #include <protocol/durability_level.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
 
 struct insert_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -40,16 +42,18 @@ struct insert_request {
     uint16_t partition{};
     uint32_t opaque{};
     uint32_t flags{ 0 };
-    uint32_t expiration{ 0 };
+    uint32_t expiry{ 0 };
     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)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
-        encoded.body().expiration(expiration);
+        encoded.body().expiry(expiry);
         encoded.body().flags(flags);
         encoded.body().content(value);
         if (durability_level != protocol::durability_level::none) {
@@ -61,7 +65,10 @@ struct insert_request {
 insert_response
 make_response(std::error_code ec, insert_request& request, insert_request::encoded_response_type encoded)
 {
-    insert_response response{ request.id, ec };
+    insert_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

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
 {
@@ -31,8 +32,10 @@ struct lookup_in_response {
         protocol::status status;
         std::string path;
         std::string value;
+        std::size_t original_index;
     };
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     std::vector<field> fields{};
@@ -47,9 +50,23 @@ struct lookup_in_request {
     uint32_t opaque{};
     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)
     {
+        for (std::size_t i = 0; i < specs.entries.size(); ++i) {
+            auto& entry = specs.entries[i];
+            entry.original_index = i;
+        }
+        std::stable_sort(specs.entries.begin(),
+                         specs.entries.end(),
+                         [](const protocol::lookup_in_request_body::lookup_in_specs::entry& lhs,
+                            const protocol::lookup_in_request_body::lookup_in_specs::entry& rhs) -> bool {
+                             return (lhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr) >
+                                    (rhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr);
+                         });
+
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
@@ -61,12 +78,16 @@ struct lookup_in_request {
 lookup_in_response
 make_response(std::error_code ec, lookup_in_request& request, lookup_in_request::encoded_response_type encoded)
 {
-    lookup_in_response response{ request.id, ec };
+    lookup_in_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.cas = encoded.cas();
         response.fields.resize(request.specs.entries.size());
         for (size_t i = 0; i < request.specs.entries.size(); ++i) {
             auto& req_entry = request.specs.entries[i];
+            response.fields[i].original_index = req_entry.original_index;
             response.fields[i].opcode = static_cast<protocol::subdoc_opcode>(req_entry.opcode);
             response.fields[i].path = req_entry.path;
             response.fields[i].status = protocol::status::success;
@@ -78,6 +99,11 @@ make_response(std::error_code ec, lookup_in_request& request, lookup_in_request:
               res_entry.status == protocol::status::success || res_entry.status == protocol::status::subdoc_success_deleted;
             response.fields[i].value = res_entry.value;
         }
+        std::sort(response.fields.begin(),
+                  response.fields.end(),
+                  [](const lookup_in_response::field& lhs, const lookup_in_response::field& rhs) -> bool {
+                      return lhs.original_index < rhs.original_index;
+                  });
     }
     return response;
 }

data/ext/couchbase/operations/document_mutate_in.hxx

@@ -18,8 +18,19 @@
 #pragma once
 
 #include <gsl/gsl_assert>
-#include <document_id.hxx>
+#include <algorithm>
+
 #include <protocol/cmd_mutate_in.hxx>
+#include <protocol/status.hxx>
+#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>
+#include <errors.hxx>
 
 namespace couchbase::operations
 {
@@ -30,8 +41,10 @@ struct mutate_in_response {
         protocol::status status;
         std::string path;
         std::string value;
+        std::size_t original_index;
     };
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -46,17 +59,41 @@ struct mutate_in_request {
     document_id id;
     uint16_t partition{};
     uint32_t opaque{};
+    uint64_t cas{ 0 };
     bool access_deleted{ false };
+    std::optional<std::uint32_t> expiry{};
+    protocol::mutate_in_request_body::store_semantics_type store_semantics{
+        protocol::mutate_in_request_body::store_semantics_type::replace
+    };
     protocol::mutate_in_request_body::mutate_in_specs specs{};
     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)
     {
+        for (std::size_t i = 0; i < specs.entries.size(); ++i) {
+            auto& entry = specs.entries[i];
+            entry.original_index = i;
+        }
+        std::stable_sort(specs.entries.begin(),
+                         specs.entries.end(),
+                         [](const protocol::mutate_in_request_body::mutate_in_specs::entry& lhs,
+                            const protocol::mutate_in_request_body::mutate_in_specs::entry& rhs) -> bool {
+                             return (lhs.flags & protocol::mutate_in_request_body::mutate_in_specs::path_flag_xattr) >
+                                    (rhs.flags & protocol::mutate_in_request_body::mutate_in_specs::path_flag_xattr);
+                         });
+
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
+        encoded.cas(cas);
+        if (expiry) {
+            encoded.body().expiry(*expiry);
+        }
         encoded.body().access_deleted(access_deleted);
+        encoded.body().store_semantics(store_semantics);
         encoded.body().specs(specs);
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
@@ -67,7 +104,10 @@ struct mutate_in_request {
 mutate_in_response
 make_response(std::error_code ec, mutate_in_request& request, mutate_in_request::encoded_response_type encoded)
 {
-    mutate_in_response response{ request.id, ec };
+    mutate_in_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
@@ -76,6 +116,7 @@ make_response(std::error_code ec, mutate_in_request& request, mutate_in_request:
         response.fields.resize(request.specs.entries.size());
         for (size_t i = 0; i < request.specs.entries.size(); ++i) {
             auto& req_entry = request.specs.entries[i];
+            response.fields[i].original_index = req_entry.original_index;
             response.fields[i].opcode = static_cast<protocol::subdoc_opcode>(req_entry.opcode);
             response.fields[i].path = req_entry.path;
             response.fields[i].status = protocol::status::success;
@@ -89,6 +130,14 @@ make_response(std::error_code ec, mutate_in_request& request, mutate_in_request:
                 break;
             }
         }
+        std::sort(response.fields.begin(),
+                  response.fields.end(),
+                  [](const mutate_in_response::field& lhs, const mutate_in_response::field& rhs) -> bool {
+                      return lhs.original_index < rhs.original_index;
+                  });
+    } else if (request.store_semantics == protocol::mutate_in_request_body::store_semantics_type::insert &&
+               ec == std::make_error_code(error::common_errc::cas_mismatch)) {
+        response.ec = std::make_error_code(error::key_value_errc::document_exists);
     }
     return response;
 }

data/ext/couchbase/operations/document_query.hxx

@@ -17,10 +17,21 @@
 
 #pragma once
 
+#include <gsl/gsl>
+
+#include <spdlog/spdlog.h>
+
 #include <tao/json.hpp>
 
 #include <version.hxx>
 
+#include <errors.hxx>
+#include <mutation_token.hxx>
+#include <service_type.hxx>
+#include <platform/uuid.h>
+#include <timeout_defaults.hxx>
+#include <io/http_message.hxx>
+
 namespace couchbase::operations
 {
 struct query_response_payload {
@@ -142,7 +153,6 @@ struct query_request {
 
     static const inline service_type type = service_type::query;
 
-    std::uint64_t timeout{ 75'000 }; // milliseconds
     std::string statement;
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
@@ -157,6 +167,10 @@ struct query_request {
     std::optional<std::uint64_t> pipeline_cap{};
     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,
@@ -171,10 +185,9 @@ struct query_request {
 
     void encode_to(encoded_request_type& encoded)
     {
-        encoded.headers["content-type"] = "application/json";
         tao::json::value body{ { "statement", statement },
                                { "client_context_id", client_context_id },
-                               { "timeout", fmt::format("{}ms", timeout) } };
+                               { "timeout", fmt::format("{}ms", timeout.count()) } };
         if (positional_parameters.empty()) {
             for (auto& param : named_parameters) {
                 Expects(param.first.empty() == false);
@@ -198,16 +211,16 @@ struct query_request {
                 break;
         }
         if (max_parallelism) {
-            body["max_parallelism"] = max_parallelism.value();
+            body["max_parallelism"] = std::to_string(max_parallelism.value());
         }
         if (pipeline_cap) {
-            body["pipeline_cap"] = pipeline_cap.value();
+            body["pipeline_cap"] = std::to_string(pipeline_cap.value());
         }
         if (pipeline_batch) {
-            body["pipeline_batch"] = pipeline_batch.value();
+            body["pipeline_batch"] = std::to_string(pipeline_batch.value());
         }
         if (scan_cap) {
-            body["scan_cap"] = scan_cap.value();
+            body["scan_cap"] = std::to_string(scan_cap.value());
         }
         if (!metrics) {
             body["metrics"] = false;
@@ -232,7 +245,7 @@ struct query_request {
             tao::json::value scan_vectors = tao::json::empty_object;
             for (const auto& token : mutation_state) {
                 auto* bucket = scan_vectors.find(token.bucket_name);
-                if (!bucket) {
+                if (bucket == nullptr) {
                     scan_vectors[token.bucket_name] = tao::json::empty_object;
                     bucket = scan_vectors.find(token.bucket_name);
                 }
@@ -243,15 +256,23 @@ struct query_request {
             body["scan_vectors"] = scan_vectors;
         }
         if (check_scan_wait && scan_wait) {
-            body["scan_wait"] = scan_wait.value();
+            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;
         }
+        encoded.type = type;
+        encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
-        spdlog::trace("query request: {}", encoded.body);
     }
 };
 
@@ -260,7 +281,6 @@ make_response(std::error_code ec, query_request& request, query_request::encoded
 {
     query_response response{ request.client_context_id, ec };
     if (!ec) {
-        spdlog::trace("query response: {}", encoded.body);
         response.payload = tao::json::from_string(encoded.body).as<query_response_payload>();
         Expects(response.payload.meta_data.client_context_id == request.client_context_id);
         if (response.payload.meta_data.status != "success") {

data/ext/couchbase/operations/document_remove.hxx

@@ -19,12 +19,14 @@
 
 #include <document_id.hxx>
 #include <protocol/cmd_remove.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
 
 struct remove_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -39,6 +41,8 @@ struct remove_request {
     uint32_t opaque{};
     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)
     {
@@ -54,7 +58,10 @@ struct remove_request {
 remove_response
 make_response(std::error_code ec, remove_request& request, remove_request::encoded_response_type encoded)
 {
-    remove_response response{ request.id, ec };
+    remove_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_replace.hxx

@@ -20,12 +20,14 @@
 #include <document_id.hxx>
 #include <protocol/cmd_replace.hxx>
 #include <protocol/durability_level.hxx>
+#include <io/retry_context.hxx>
 
 namespace couchbase::operations
 {
 
 struct replace_response {
     document_id id;
+    std::uint32_t opaque;
     std::error_code ec{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -40,10 +42,12 @@ struct replace_request {
     uint16_t partition{};
     uint32_t opaque{};
     uint32_t flags{ 0 };
-    uint32_t expiration{ 0 };
+    uint32_t expiry{ 0 };
     uint64_t cas{ 0 };
     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)
     {
@@ -51,7 +55,7 @@ struct replace_request {
         encoded.partition(partition);
         encoded.cas(cas);
         encoded.body().id(id);
-        encoded.body().expiration(expiration);
+        encoded.body().expiry(expiry);
         encoded.body().flags(flags);
         encoded.body().content(value);
         if (durability_level != protocol::durability_level::none) {
@@ -63,7 +67,10 @@ struct replace_request {
 replace_response
 make_response(std::error_code ec, replace_request& request, replace_request::encoded_response_type encoded)
 {
-    replace_response response{ request.id, ec };
+    replace_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();