couchbase 3.0.0.alpha.5 → 3.0.3

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>
@@ -41,13 +43,12 @@ struct mutate_in_response {
         std::string value;
         std::size_t original_index;
     };
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
     mutation_token token{};
     std::vector<field> fields{};
     std::optional<std::size_t> first_error_index{};
+    bool deleted{ false };
 };
 
 struct mutate_in_request {
@@ -59,7 +60,8 @@ struct mutate_in_request {
     uint32_t opaque{};
     uint64_t cas{ 0 };
     bool access_deleted{ false };
-    std::optional<std::uint32_t> expiration{};
+    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
     };
@@ -67,9 +69,13 @@ 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)
+    [[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;
@@ -86,27 +92,33 @@ 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().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(error_context::key_value&& ctx, mutate_in_request& request, mutate_in_request::encoded_response_type&& encoded)
 {
-    mutate_in_response response{ request.id, encoded.opaque(), ec };
-    if (!ec) {
+    mutate_in_response response{ ctx };
+    if (encoded.status() == protocol::status::subdoc_success_deleted ||
+        encoded.status() == protocol::status::subdoc_multi_path_failure_deleted) {
+        response.deleted = true;
+    }
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
         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];
@@ -130,8 +142,8 @@ make_response(std::error_code ec, mutate_in_request& request, mutate_in_request:
                       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);
+               response.ctx.ec == std::make_error_code(error::common_errc::cas_mismatch)) {
+        response.ctx.ec = std::make_error_code(error::key_value_errc::document_exists);
     }
     return response;
 }

data/ext/couchbase/operations/document_prepend.hxx

@@ -0,0 +1,72 @@
+/* -*- 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 {
+    error_context::key_value ctx;
+    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(error_context::key_value&& ctx, prepend_request& request, prepend_request::encoded_response_type&& encoded)
+{
+    prepend_response response{ ctx };
+    if (!response.ctx.ec) {
+        response.cas = encoded.cas();
+        response.token = encoded.body().token();
+        response.token.partition_id = request.partition;
+        response.token.bucket_name = response.ctx.id.bucket;
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/document_query.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     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.
@@ -26,11 +26,13 @@
 #include <version.hxx>
 
 #include <errors.hxx>
+#include <io/http_context.hxx>
+#include <io/http_message.hxx>
 #include <mutation_token.hxx>
-#include <service_type.hxx>
 #include <platform/uuid.h>
+#include <service_type.hxx>
 #include <timeout_defaults.hxx>
-#include <io/http_message.hxx>
+#include <error_context/query.hxx>
 
 namespace couchbase::operations
 {
@@ -47,8 +49,8 @@ struct query_response_payload {
     };
 
     struct query_problem {
-        std::uint64_t code;
-        std::string message;
+        std::uint64_t code{};
+        std::string message{};
     };
 
     struct query_meta_data {
@@ -63,6 +65,7 @@ struct query_response_payload {
     };
 
     query_meta_data meta_data{};
+    std::optional<std::string> prepared{};
     std::vector<std::string> rows{};
 };
 } // namespace couchbase::operations
@@ -76,13 +79,21 @@ struct traits<couchbase::operations::query_response_payload> {
     {
         couchbase::operations::query_response_payload result;
         result.meta_data.request_id = v.at("requestID").get_string();
-        result.meta_data.client_context_id = v.at("clientContextID").get_string();
+        const auto i = v.find("clientContextID");
+        if (i != nullptr) {
+            result.meta_data.client_context_id = i->get_string();
+        }
         result.meta_data.status = v.at("status").get_string();
         const auto s = v.find("signature");
         if (s != nullptr) {
             result.meta_data.signature = tao::json::to_string(*s);
         }
-
+        {
+            const auto c = v.find("prepared");
+            if (c != nullptr) {
+                result.prepared = c->get_string();
+            }
+        }
         const auto p = v.find("profile");
         if (p != nullptr) {
             result.meta_data.profile = tao::json::to_string(*p);
@@ -139,8 +150,7 @@ struct traits<couchbase::operations::query_response_payload> {
 namespace couchbase::operations
 {
 struct query_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::query ctx;
     query_response_payload payload{};
 };
 
@@ -148,6 +158,7 @@ struct query_request {
     using response_type = query_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::query;
 
     enum class scan_consistency_type { not_bounded, request_plus };
 
@@ -159,6 +170,7 @@ struct query_request {
     bool adhoc{ true };
     bool metrics{ false };
     bool readonly{ false };
+    bool flex_index{ false };
 
     std::optional<std::uint64_t> max_parallelism{};
     std::optional<std::uint64_t> scan_cap{};
@@ -168,6 +180,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,
@@ -179,12 +194,36 @@ struct query_request {
     std::map<std::string, tao::json::value> raw{};
     std::vector<tao::json::value> positional_parameters{};
     std::map<std::string, tao::json::value> named_parameters{};
+    std::optional<http_context> ctx_{};
+    bool extract_encoded_plan_{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    std::string body_str{};
+
+    [[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 },
-                               { "timeout", fmt::format("{}ms", timeout.count()) } };
+        ctx_.emplace(context);
+        tao::json::value body{};
+        if (adhoc) {
+            body["statement"] = statement;
+        } else {
+            auto entry = ctx_->cache.get(statement);
+            if (entry) {
+                body["prepared"] = entry->name;
+                if (entry->plan) {
+                    body["encoded_plan"] = entry->plan.value();
+                }
+            } else {
+                body["statement"] = "PREPARE " + statement;
+                if (context.config.supports_enhanced_prepared_statements()) {
+                    body["auto_execute"] = true;
+                } else {
+                    extract_encoded_plan_ = true;
+                }
+            }
+        }
+        body["client_context_id"] = client_context_id;
+        body["timeout"] = fmt::format(
+          "{}ms", ((timeout > std::chrono::milliseconds(5'000)) ? (timeout - std::chrono::milliseconds(500)) : timeout).count());
         if (positional_parameters.empty()) {
             for (auto& param : named_parameters) {
                 Expects(param.first.empty() == false);
@@ -225,6 +264,9 @@ struct query_request {
         if (readonly) {
             body["readonly"] = true;
         }
+        if (flex_index) {
+            body["use_fts"] = true;
+        }
         bool check_scan_wait = false;
         if (scan_consistency) {
             switch (scan_consistency.value()) {
@@ -255,35 +297,96 @@ 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("default:`{}`.`{}`", *bucket_name, *scope_name);
+            }
+        }
         for (auto& param : raw) {
             body[param.first] = param.second;
         }
         encoded.type = type;
+        encoded.headers["connection"] = "keep-alive";
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
         encoded.path = "/query/service";
-        encoded.body = tao::json::to_string(body);
+        body_str = tao::json::to_string(body);
+        encoded.body = body_str;
+
+        tao::json::value stmt = body["statement"];
+        tao::json::value prep = body["prepared"];
+        if (!stmt.is_string()) {
+            stmt = statement;
+        }
+        if (!prep.is_string()) {
+            prep = false;
+        }
+        if (ctx_->options.show_queries) {
+            spdlog::info("QUERY: prep={}, {}", tao::json::to_string(prep), tao::json::to_string(stmt));
+        } else {
+            spdlog::debug("QUERY: prep={}, {}", tao::json::to_string(prep), tao::json::to_string(stmt));
+        }
+        return {};
     }
 };
 
 query_response
-make_response(std::error_code ec, query_request& request, query_request::encoded_response_type encoded)
+make_response(error_context::query&& ctx, query_request& request, query_request::encoded_response_type&& encoded)
 {
-    query_response response{ request.client_context_id, ec };
-    if (!ec) {
-        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") {
+    query_response response{ ctx };
+    response.ctx.statement = request.statement;
+    response.ctx.parameters = request.body_str;
+    if (!response.ctx.ec) {
+        try {
+            response.payload = tao::json::from_string(encoded.body).as<query_response_payload>();
+        } catch (tao::json::pegtl::parse_error& e) {
+            response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            return response;
+        }
+        Expects(response.payload.meta_data.client_context_id.empty() ||
+                response.payload.meta_data.client_context_id == request.client_context_id);
+        if (response.payload.meta_data.status == "success") {
+            if (response.payload.prepared) {
+                request.ctx_->cache.put(request.statement, response.payload.prepared.value());
+            } else if (request.extract_encoded_plan_) {
+                request.extract_encoded_plan_ = false;
+                if (response.payload.rows.size() == 1) {
+                    tao::json::value row{};
+                    try {
+                        row = tao::json::from_string(response.payload.rows[0]);
+                    } catch (tao::json::pegtl::parse_error& e) {
+                        response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                        return response;
+                    }
+                    auto* plan = row.find("encoded_plan");
+                    auto* name = row.find("name");
+                    if (plan != nullptr && name != nullptr) {
+                        request.ctx_->cache.put(request.statement, name->get_string(), plan->get_string());
+                        throw couchbase::priv::retry_http_request{};
+                    }
+                    response.ctx.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+
+                } else {
+                    response.ctx.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+                }
+            }
+        } else {
             bool prepared_statement_failure = false;
             bool index_not_found = false;
             bool index_failure = false;
             bool planning_failure = false;
             bool syntax_error = false;
             bool server_timeout = false;
+            bool invalid_argument = false;
 
             if (response.payload.meta_data.errors) {
                 for (const auto& error : *response.payload.meta_data.errors) {
                     switch (error.code) {
+                        case 1065: /* IKey: "service.io.request.unrecognized_parameter" */
+                            invalid_argument = true;
+                            break;
                         case 1080: /* IKey: "timeout" */
                             server_timeout = true;
                             break;
@@ -313,19 +416,21 @@ make_response(std::error_code ec, query_request& request, query_request::encoded
                 }
             }
             if (syntax_error) {
-                response.ec = std::make_error_code(error::common_errc::parsing_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } else if (invalid_argument) {
+                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
             } else if (server_timeout) {
-                response.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
+                response.ctx.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
             } else if (prepared_statement_failure) {
-                response.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+                response.ctx.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
             } else if (index_failure) {
-                response.ec = std::make_error_code(error::query_errc::index_failure);
+                response.ctx.ec = std::make_error_code(error::query_errc::index_failure);
             } else if (planning_failure) {
-                response.ec = std::make_error_code(error::query_errc::planning_failure);
+                response.ctx.ec = std::make_error_code(error::query_errc::planning_failure);
             } else if (index_not_found) {
-                response.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
             } else {
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
             }
         }
     }