couchbase 3.0.0.alpha.5 → 3.0.0.beta.1

data/ext/couchbase/operations/document_decrement.hxx

@@ -39,7 +39,7 @@ struct decrement_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 };
@@ -54,10 +54,10 @@ struct decrement_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);
@@ -69,6 +69,9 @@ decrement_response
 make_response(std::error_code ec, decrement_request& request, decrement_request::encoded_response_type encoded)
 {
     decrement_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_get.hxx

@@ -53,6 +53,9 @@ get_response
 make_response(std::error_code ec, get_request& request, get_request::encoded_response_type encoded)
 {
     get_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();

data/ext/couchbase/operations/document_get_and_lock.hxx

@@ -55,6 +55,9 @@ get_and_lock_response
 make_response(std::error_code ec, get_and_lock_request& request, get_and_lock_request::encoded_response_type encoded)
 {
     get_and_lock_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();

data/ext/couchbase/operations/document_get_and_touch.hxx

@@ -39,7 +39,7 @@ struct get_and_touch_request {
     document_id id;
     uint16_t partition{};
     uint32_t opaque{};
-    uint32_t expiration{};
+    uint32_t expiry{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
@@ -47,7 +47,7 @@ struct get_and_touch_request {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
-        encoded.body().expiration(expiration);
+        encoded.body().expiry(expiry);
     }
 };
 
@@ -55,6 +55,9 @@ get_and_touch_response
 make_response(std::error_code ec, get_and_touch_request& request, get_and_touch_request::encoded_response_type encoded)
 {
     get_and_touch_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();

data/ext/couchbase/operations/document_get_projected.hxx

@@ -30,7 +30,7 @@ struct get_projected_response {
     std::string value{};
     std::uint64_t cas{};
     std::uint32_t flags{};
-    std::optional<std::uint32_t> expiration{};
+    std::optional<std::uint32_t> expiry{};
 };
 
 struct get_projected_request {
@@ -41,7 +41,7 @@ struct get_projected_request {
     std::uint16_t partition{};
     std::uint32_t opaque{};
     std::vector<std::string> projections{};
-    bool with_expiration{ false };
+    bool with_expiry{ false };
     std::vector<std::string> effective_projections{};
     bool preserve_array_indexes{ false };
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
@@ -54,7 +54,7 @@ struct get_projected_request {
 
         effective_projections = projections;
         std::size_t num_projections = effective_projections.size();
-        if (with_expiration) {
+        if (with_expiry) {
             num_projections++;
         }
         if (num_projections > 16) {
@@ -63,7 +63,7 @@ struct get_projected_request {
         }
 
         protocol::lookup_in_request_body::lookup_in_specs specs{};
-        if (with_expiration) {
+        if (with_expiry) {
             specs.add_spec(protocol::subdoc_opcode::get, true, "$document.exptime");
         }
         if (effective_projections.empty()) {
@@ -198,18 +198,21 @@ get_projected_response
 make_response(std::error_code ec, get_projected_request& request, get_projected_request::encoded_response_type encoded)
 {
     get_projected_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.cas = encoded.cas();
-        if (request.with_expiration) {
-            response.expiration = gsl::narrow_cast<std::uint32_t>(std::stoul(encoded.body().fields()[0].value));
+        if (request.with_expiry) {
+            response.expiry = gsl::narrow_cast<std::uint32_t>(std::stoul(encoded.body().fields()[0].value));
         }
         if (request.effective_projections.empty()) {
             // from full document
-            if (request.projections.empty() && request.with_expiration) {
+            if (request.projections.empty() && request.with_expiry) {
                 // special case when user only wanted full+expiration
                 response.value = encoded.body().fields()[1].value;
             } else {
-                tao::json::value full_doc = tao::json::from_string(encoded.body().fields()[request.with_expiration ? 1 : 0].value);
+                tao::json::value full_doc = tao::json::from_string(encoded.body().fields()[request.with_expiry ? 1 : 0].value);
                 tao::json::value new_doc;
                 for (const auto& projection : request.projections) {
                     auto value_to_apply = priv::subdoc_lookup(full_doc, projection);
@@ -224,7 +227,7 @@ make_response(std::error_code ec, get_projected_request& request, get_projected_
             }
         } else {
             tao::json::value new_doc = tao::json::empty_object;
-            std::size_t offset = request.with_expiration ? 1 : 0;
+            std::size_t offset = request.with_expiry ? 1 : 0;
             for (const auto& projection : request.projections) {
                 auto& field = encoded.body().fields()[offset++];
                 if (field.status == protocol::status::success && !field.value.empty()) {

data/ext/couchbase/operations/document_increment.hxx

@@ -41,7 +41,7 @@ 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 };
@@ -56,10 +56,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);
@@ -71,6 +71,9 @@ increment_response
 make_response(std::error_code ec, increment_request& request, increment_request::encoded_response_type encoded)
 {
     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

@@ -41,7 +41,7 @@ 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 };
@@ -51,7 +51,7 @@ struct insert_request {
         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) {
@@ -64,6 +64,9 @@ insert_response
 make_response(std::error_code ec, insert_request& request, insert_request::encoded_response_type encoded)
 {
     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

@@ -77,6 +77,9 @@ 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, 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());

data/ext/couchbase/operations/document_mutate_in.hxx

@@ -59,7 +59,7 @@ struct mutate_in_request {
     uint32_t opaque{};
     uint64_t cas{ 0 };
     bool access_deleted{ false };
-    std::optional<std::uint32_t> expiration{};
+    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
     };
@@ -86,8 +86,8 @@ struct mutate_in_request {
         encoded.partition(partition);
         encoded.body().id(id);
         encoded.cas(cas);
-        if (expiration) {
-            encoded.body().expiration(*expiration);
+        if (expiry) {
+            encoded.body().expiry(*expiry);
         }
         encoded.body().access_deleted(access_deleted);
         encoded.body().store_semantics(store_semantics);
@@ -102,6 +102,9 @@ 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, 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_remove.hxx

@@ -57,6 +57,9 @@ remove_response
 make_response(std::error_code ec, remove_request& request, remove_request::encoded_response_type encoded)
 {
     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

@@ -41,7 +41,7 @@ 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{};
@@ -53,7 +53,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) {
@@ -66,6 +66,9 @@ replace_response
 make_response(std::error_code ec, replace_request& request, replace_request::encoded_response_type encoded)
 {
     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();

data/ext/couchbase/operations/document_search.hxx

@@ -59,20 +59,20 @@ struct search_response {
 
     struct search_facet {
         struct term_facet {
-            std::string term;
-            std::uint64_t count;
+            std::string term{};
+            std::uint64_t count{};
         };
 
         struct date_range_facet {
-            std::string name;
-            std::uint64_t count;
+            std::string name{};
+            std::uint64_t count{};
             std::optional<std::string> start{};
             std::optional<std::string> end{};
         };
 
         struct numeric_range_facet {
-            std::string name;
-            std::uint64_t count;
+            std::string name{};
+            std::uint64_t count{};
             std::variant<std::monostate, std::uint64_t, double> min{};
             std::variant<std::monostate, std::uint64_t, double> max{};
         };
@@ -189,7 +189,6 @@ struct search_request {
 
         encoded.type = type;
         encoded.headers["content-type"] = "application/json";
-        encoded.headers["client-context-id"] = client_context_id;
         encoded.method = "POST";
         encoded.path = fmt::format("/api/index/{}/query", index_name);
         encoded.body = tao::json::to_string(body);

data/ext/couchbase/operations/document_touch.hxx

@@ -37,7 +37,7 @@ struct touch_request {
     document_id id;
     std::uint16_t partition{};
     std::uint32_t opaque{};
-    std::uint32_t expiration{};
+    std::uint32_t expiry{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
@@ -45,7 +45,7 @@ struct touch_request {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
-        encoded.body().expiration(expiration);
+        encoded.body().expiry(expiry);
     }
 };
 
@@ -53,6 +53,9 @@ touch_response
 make_response(std::error_code ec, touch_request& request, touch_request::encoded_response_type encoded)
 {
     touch_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.cas = encoded.cas();
     }

data/ext/couchbase/operations/document_unlock.hxx

@@ -53,6 +53,9 @@ unlock_response
 make_response(std::error_code ec, unlock_request& request, unlock_request::encoded_response_type encoded)
 {
     unlock_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
     if (!ec) {
         response.cas = encoded.cas();
     }

data/ext/couchbase/operations/document_upsert.hxx

@@ -41,7 +41,7 @@ struct upsert_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 };
@@ -51,7 +51,7 @@ struct upsert_request {
         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) {
@@ -64,6 +64,9 @@ upsert_response
 make_response(std::error_code ec, upsert_request& request, upsert_request::encoded_response_type encoded)
 {
     upsert_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/query_index_build_deferred.hxx

@@ -28,7 +28,7 @@ struct query_index_build_deferred_response {
         std::uint64_t code;
         std::string message;
     };
-    uuid::uuid_t client_context_id;
+    std::string client_context_id;
     std::error_code ec;
     std::string status{};
     std::vector<query_problem> errors{};
@@ -41,7 +41,7 @@ struct query_index_build_deferred_request {
 
     static const inline service_type type = service_type::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::string bucket_name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
@@ -53,7 +53,7 @@ struct query_index_build_deferred_request {
               fmt::format(R"(BUILD INDEX ON `{}` ((SELECT RAW name FROM system:indexes WHERE keyspace_id = "{}" AND state = "deferred")))",
                           bucket_name,
                           bucket_name) },
-            { "client_context_id", uuid::to_string(client_context_id) }
+            { "client_context_id", client_context_id }
         };
         encoded.method = "POST";
         encoded.path = "/query/service";

data/ext/couchbase/operations/query_index_create.hxx

@@ -28,7 +28,7 @@ struct query_index_create_response {
         std::uint64_t code;
         std::string message;
     };
-    uuid::uuid_t client_context_id;
+    std::string client_context_id;
     std::error_code ec;
     std::string status{};
     std::vector<query_problem> errors{};
@@ -41,7 +41,7 @@ struct query_index_create_request {
 
     static const inline service_type type = service_type::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::string bucket_name;
     std::string index_name{};
     std::vector<std::string> fields;
@@ -81,7 +81,7 @@ struct query_index_create_request {
                                                           fmt::join(fields, ", "),
                                                           where_clause,
                                                           with_clause) },
-                               { "client_context_id", uuid::to_string(client_context_id) } };
+                               { "client_context_id", client_context_id } };
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);

data/ext/couchbase/operations/query_index_drop.hxx

@@ -28,7 +28,7 @@ struct query_index_drop_response {
         std::uint64_t code;
         std::string message;
     };
-    uuid::uuid_t client_context_id;
+    std::string client_context_id;
     std::error_code ec;
     std::string status{};
     std::vector<query_problem> errors{};
@@ -41,7 +41,7 @@ struct query_index_drop_request {
 
     static const inline service_type type = service_type::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::string bucket_name;
     std::string index_name;
     bool is_primary{ false };
@@ -54,7 +54,7 @@ struct query_index_drop_request {
         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) },
-                               { "client_context_id", uuid::to_string(client_context_id) } };
+                               { "client_context_id", client_context_id } };
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);