couchbase 3.0.1 → 3.0.2

data/ext/couchbase/operations/collection_drop.hxx

@@ -45,15 +45,16 @@ struct collection_drop_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "DELETE";
         encoded.path = fmt::format("/pools/default/buckets/{}/collections/{}/{}", bucket_name, scope_name, collection_name);
+        return {};
     }
 };
 
 collection_drop_response
-make_response(std::error_code ec, collection_drop_request& request, collection_drop_request::encoded_response_type encoded)
+make_response(std::error_code ec, collection_drop_request& request, collection_drop_request::encoded_response_type&& encoded)
 {
     collection_drop_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/collections_manifest_get.hxx

@@ -47,16 +47,17 @@ struct collections_manifest_get_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
+        return {};
     }
 };
 
 collections_manifest_get_response
 make_response(std::error_code ec,
               collections_manifest_get_request& request,
-              collections_manifest_get_request::encoded_response_type encoded)
+              collections_manifest_get_request::encoded_response_type&& encoded)
 {
     collections_manifest_get_response response{ request.id, encoded.opaque(), ec };
     if (ec && response.opaque == 0) {

data/ext/couchbase/operations/document_analytics.hxx

@@ -166,7 +166,7 @@ struct analytics_request {
     std::vector<tao::json::value> positional_parameters{};
     std::map<std::string, tao::json::value> named_parameters{};
 
-    void encode_to(encoded_request_type& encoded, http_context& context)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context)
     {
         tao::json::value body{ { "statement", statement },
                                { "client_context_id", client_context_id },
@@ -212,11 +212,12 @@ struct analytics_request {
         } else {
             spdlog::debug("ANALYTICS: {}", tao::json::to_string(body["statement"]));
         }
+        return {};
     }
 };
 
 analytics_response
-make_response(std::error_code ec, analytics_request& request, analytics_request::encoded_response_type encoded)
+make_response(std::error_code ec, analytics_request& request, analytics_request::encoded_response_type&& encoded)
 {
     analytics_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/document_append.hxx

@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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.
+ */
+
+#pragma once
+
+#include <protocol/cmd_append.hxx>
+#include <protocol/durability_level.hxx>
+#include <io/retry_context.hxx>
+
+namespace couchbase::operations
+{
+
+struct append_response {
+    document_id id;
+    std::uint32_t opaque;
+    std::error_code ec{};
+    std::uint64_t cas{};
+    mutation_token token{};
+};
+
+struct append_request {
+    using encoded_request_type = protocol::client_request<protocol::append_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::append_response_body>;
+
+    document_id id;
+    std::string value;
+    uint16_t partition{};
+    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 };
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        encoded.body().content(value);
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
+        return {};
+    }
+};
+
+append_response
+make_response(std::error_code ec, append_request& request, append_request::encoded_response_type&& encoded)
+{
+    append_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();
+        response.token.partition_id = request.partition;
+        response.token.bucket_name = response.id.bucket;
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/document_decrement.hxx

@@ -48,7 +48,7 @@ struct decrement_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -64,11 +64,12 @@ struct decrement_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        return {};
     }
 };
 
 decrement_response
-make_response(std::error_code ec, decrement_request& request, decrement_request::encoded_response_type encoded)
+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) {

data/ext/couchbase/operations/document_exists.hxx

@@ -45,15 +45,16 @@ struct exists_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.body().id(partition, id);
+        return {};
     }
 };
 
 exists_response
-make_response(std::error_code ec, exists_request& request, exists_request::encoded_response_type encoded)
+make_response(std::error_code ec, exists_request& request, exists_request::encoded_response_type&& encoded)
 {
     exists_response response{ request.id, encoded.opaque(), ec, request.partition };
     if (!ec) {

data/ext/couchbase/operations/document_get.hxx

@@ -43,16 +43,17 @@ struct get_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
+        return {};
     }
 };
 
 get_response
-make_response(std::error_code ec, get_request& request, get_request::encoded_response_type encoded)
+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) {

data/ext/couchbase/operations/document_get_and_lock.hxx

@@ -44,17 +44,18 @@ struct get_and_lock_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
         encoded.body().lock_time(lock_time);
+        return {};
     }
 };
 
 get_and_lock_response
-make_response(std::error_code ec, get_and_lock_request& request, get_and_lock_request::encoded_response_type encoded)
+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) {

data/ext/couchbase/operations/document_get_and_touch.hxx

@@ -44,17 +44,18 @@ struct get_and_touch_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
         encoded.body().expiry(expiry);
+        return {};
     }
 };
 
 get_and_touch_response
-make_response(std::error_code ec, get_and_touch_request& request, get_and_touch_request::encoded_response_type encoded)
+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) {

data/ext/couchbase/operations/document_get_projected.hxx

@@ -48,7 +48,7 @@ struct get_projected_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -76,6 +76,7 @@ struct get_projected_request {
             }
         }
         encoded.body().specs(specs);
+        return {};
     }
 };
 
@@ -197,7 +198,7 @@ subdoc_apply_projection(tao::json::value& root, const std::string& path, tao::js
 } // namespace priv
 
 get_projected_response
-make_response(std::error_code ec, get_projected_request& request, get_projected_request::encoded_response_type encoded)
+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) {

data/ext/couchbase/operations/document_increment.hxx

@@ -50,7 +50,7 @@ struct increment_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -66,11 +66,12 @@ struct increment_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        return {};
     }
 };
 
 increment_response
-make_response(std::error_code ec, increment_request& request, increment_request::encoded_response_type encoded)
+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) {

data/ext/couchbase/operations/document_insert.hxx

@@ -48,7 +48,7 @@ struct insert_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -59,11 +59,12 @@ struct insert_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        return {};
     }
 };
 
 insert_response
-make_response(std::error_code ec, insert_request& request, insert_request::encoded_response_type encoded)
+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) {

data/ext/couchbase/operations/document_lookup_in.hxx

@@ -39,6 +39,7 @@ struct lookup_in_response {
     std::error_code ec{};
     std::uint64_t cas{};
     std::vector<field> fields{};
+    bool deleted{ false };
 };
 
 struct lookup_in_request {
@@ -53,7 +54,7 @@ struct lookup_in_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
         for (std::size_t i = 0; i < specs.entries.size(); ++i) {
             auto& entry = specs.entries[i];
@@ -72,16 +73,21 @@ struct lookup_in_request {
         encoded.body().id(id);
         encoded.body().access_deleted(access_deleted);
         encoded.body().specs(specs);
+        return {};
     }
 };
 
 lookup_in_response
-make_response(std::error_code ec, lookup_in_request& request, lookup_in_request::encoded_response_type encoded)
+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 (encoded.status() == protocol::status::subdoc_success_deleted ||
+        encoded.status() == protocol::status::subdoc_multi_path_failure_deleted) {
+        response.deleted = true;
+    }
     if (!ec) {
         response.cas = encoded.cas();
         response.fields.resize(request.specs.entries.size());

data/ext/couchbase/operations/document_mutate_in.hxx

@@ -50,6 +50,7 @@ struct mutate_in_response {
     mutation_token token{};
     std::vector<field> fields{};
     std::optional<std::size_t> first_error_index{};
+    bool deleted{ false };
 };
 
 struct mutate_in_request {
@@ -61,6 +62,7 @@ struct mutate_in_request {
     uint32_t opaque{};
     uint64_t cas{ 0 };
     bool access_deleted{ false };
+    bool create_as_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
@@ -71,8 +73,11 @@ struct mutate_in_request {
     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)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& ctx)
     {
+        if (create_as_deleted && !ctx.supports_feature(protocol::hello_feature::subdoc_create_as_deleted)) {
+            return std::make_error_code(error::common_errc::unsupported_operation);
+        }
         for (std::size_t i = 0; i < specs.entries.size(); ++i) {
             auto& entry = specs.entries[i];
             entry.original_index = i;
@@ -93,21 +98,27 @@ struct mutate_in_request {
             encoded.body().expiry(*expiry);
         }
         encoded.body().access_deleted(access_deleted);
+        encoded.body().create_as_deleted(create_as_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);
         }
+        return {};
     }
 };
 
 mutate_in_response
-make_response(std::error_code ec, mutate_in_request& request, mutate_in_request::encoded_response_type encoded)
+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 (encoded.status() == protocol::status::subdoc_success_deleted ||
+        encoded.status() == protocol::status::subdoc_multi_path_failure_deleted) {
+        response.deleted = true;
+    }
     if (!ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_prepend.hxx

@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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.
+ */
+
+#pragma once
+
+#include <protocol/cmd_prepend.hxx>
+#include <protocol/durability_level.hxx>
+#include <io/retry_context.hxx>
+
+namespace couchbase::operations
+{
+
+struct prepend_response {
+    document_id id;
+    std::uint32_t opaque;
+    std::error_code ec{};
+    std::uint64_t cas{};
+    mutation_token token{};
+};
+
+struct prepend_request {
+    using encoded_request_type = protocol::client_request<protocol::prepend_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::prepend_response_body>;
+
+    document_id id;
+    std::string value;
+    uint16_t partition{};
+    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 };
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        encoded.body().content(value);
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
+        return {};
+    }
+};
+
+prepend_response
+make_response(std::error_code ec, prepend_request& request, prepend_request::encoded_response_type&& encoded)
+{
+    prepend_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();
+        response.token.partition_id = request.partition;
+        response.token.bucket_name = response.id.bucket;
+    }
+    return response;
+}
+
+} // namespace couchbase::operations