couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/ext/couchbase/operations/document_increment.hxx

@@ -0,0 +1,87 @@
+/* -*- 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_increment.hxx>
+#include <protocol/durability_level.hxx>
+#include <operations.hxx>
+#include <protocol/client_response.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{};
+    mutation_token token{};
+};
+
+struct increment_request {
+    using encoded_request_type = protocol::client_request<protocol::increment_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::increment_response_body>;
+
+    document_id id;
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
+    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 };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        encoded.body().delta(delta);
+        if (initial_value) {
+            encoded.body().initial_value(initial_value.value());
+            encoded.body().expiry(expiry);
+        } else {
+            encoded.body().initial_value(0);
+            encoded.body().expiry(0xffff'ffff);
+        }
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
+    }
+};
+
+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();
+        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_insert.hxx

@@ -0,0 +1,79 @@
+/* -*- 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 <document_id.hxx>
+#include <protocol/cmd_insert.hxx>
+#include <protocol/durability_level.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{};
+};
+
+struct insert_request {
+    using encoded_request_type = protocol::client_request<protocol::insert_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::insert_response_body>;
+
+    document_id id;
+    std::string value;
+    uint16_t partition{};
+    uint32_t opaque{};
+    uint32_t flags{ 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 };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        encoded.body().expiry(expiry);
+        encoded.body().flags(flags);
+        encoded.body().content(value);
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
+    }
+};
+
+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();
+        response.token.partition_id = request.partition;
+        response.token.bucket_name = response.id.bucket;
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/{lookup_in.hxx → document_lookup_in.hxx}

@@ -18,7 +18,7 @@
 #pragma once
 
 #include <gsl/gsl_assert>
-#include <operations/document_id.hxx>
+#include <document_id.hxx>
 #include <protocol/cmd_lookup_in.hxx>
 
 namespace couchbase::operations
@@ -31,8 +31,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 +49,22 @@ 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 };
 
     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 +76,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,8 +97,13 @@ 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;
 }
 
-} // namespace couchbase::operations
+} // namespace couchbase::operations

data/ext/couchbase/operations/{mutate_in.hxx → document_mutate_in.hxx}

@@ -18,8 +18,17 @@
 #pragma once
 
 #include <gsl/gsl_assert>
-#include <operations/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 <mutation_token.hxx>
+#include <document_id.hxx>
+#include <timeout_defaults.hxx>
+#include <errors.hxx>
 
 namespace couchbase::operations
 {
@@ -30,10 +39,13 @@ 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{};
     std::vector<field> fields{};
     std::optional<std::size_t> first_error_index{};
 };
@@ -45,28 +57,63 @@ 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 };
 
     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);
+        }
     }
 };
 
 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();
+        response.token.partition_id = request.partition;
+        response.token.bucket_name = response.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];
+            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;
@@ -80,8 +127,16 @@ 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;
 }
 
-} // namespace couchbase::operations
+} // namespace couchbase::operations

data/ext/couchbase/operations/{query.hxx → 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 {
@@ -53,7 +64,6 @@ struct query_response_payload {
 
     query_meta_data meta_data{};
     std::vector<std::string> rows{};
-    std::string body;
 };
 } // namespace couchbase::operations
 
@@ -125,21 +135,26 @@ struct traits<couchbase::operations::query_response_payload> {
     }
 };
 } // namespace tao::json
+
 namespace couchbase::operations
 {
-
 struct query_response {
-    uuid::uuid_t client_context_id;
+    std::string client_context_id;
     std::error_code ec;
     query_response_payload payload{};
 };
 
 struct query_request {
+    using response_type = query_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
 
+    enum class scan_consistency_type { not_bounded, request_plus };
+
+    static const inline service_type type = service_type::query;
+
     std::string statement;
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
 
     bool adhoc{ true };
     bool metrics{ false };
@@ -147,8 +162,12 @@ struct query_request {
 
     std::optional<std::uint64_t> max_parallelism{};
     std::optional<std::uint64_t> scan_cap{};
+    std::optional<std::uint64_t> scan_wait{};
     std::optional<std::uint64_t> pipeline_batch{};
     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 };
 
     enum class profile_mode {
         off,
@@ -163,9 +182,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", uuid::to_string(client_context_id) } };
+                               { "client_context_id", client_context_id },
+                               { "timeout", fmt::format("{}ms", timeout.count()) } };
         if (positional_parameters.empty()) {
             for (auto& param : named_parameters) {
                 Expects(param.first.empty() == false);
@@ -189,16 +208,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;
@@ -206,9 +225,41 @@ struct query_request {
         if (readonly) {
             body["readonly"] = true;
         }
+        bool check_scan_wait = false;
+        if (scan_consistency) {
+            switch (scan_consistency.value()) {
+                case scan_consistency_type::not_bounded:
+                    body["scan_consistency"] = "not_bounded";
+                    break;
+                case scan_consistency_type::request_plus:
+                    check_scan_wait = true;
+                    body["scan_consistency"] = "request_plus";
+                    break;
+            }
+        } else if (!mutation_state.empty()) {
+            check_scan_wait = true;
+            body["scan_consistency"] = "at_plus";
+            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 == nullptr) {
+                    scan_vectors[token.bucket_name] = tao::json::empty_object;
+                    bucket = scan_vectors.find(token.bucket_name);
+                }
+                auto& bucket_obj = bucket->get_object();
+                bucket_obj[std::to_string(token.partition_id)] =
+                  std::vector<tao::json::value>{ token.sequence_number, std::to_string(token.partition_uuid) };
+            }
+            body["scan_vectors"] = scan_vectors;
+        }
+        if (check_scan_wait && scan_wait) {
+            body["scan_wait"] = fmt::format("{}ms", scan_wait.value());
+        }
         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);
@@ -220,9 +271,63 @@ 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 == uuid::to_string(request.client_context_id));
+        Expects(response.payload.meta_data.client_context_id == request.client_context_id);
+        if (response.payload.meta_data.status != "success") {
+            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;
+
+            if (response.payload.meta_data.errors) {
+                for (const auto& error : *response.payload.meta_data.errors) {
+                    switch (error.code) {
+                        case 1080: /* IKey: "timeout" */
+                            server_timeout = true;
+                            break;
+                        case 3000: /* IKey: "parse.syntax_error" */
+                            syntax_error = true;
+                            break;
+                        case 4040: /* IKey: "plan.build_prepared.no_such_name" */
+                        case 4050: /* IKey: "plan.build_prepared.unrecognized_prepared" */
+                        case 4060: /* IKey: "plan.build_prepared.no_such_name" */
+                        case 4070: /* IKey: "plan.build_prepared.decoding" */
+                        case 4080: /* IKey: "plan.build_prepared.name_encoded_plan_mismatch" */
+                        case 4090: /* IKey: "plan.build_prepared.name_not_in_encoded_plan" */
+                            prepared_statement_failure = true;
+                            break;
+                        case 12004: /* IKey: "datastore.couchbase.primary_idx_not_found" */
+                        case 12016: /* IKey: "datastore.couchbase.index_not_found" */
+                            index_not_found = true;
+                            break;
+                        default:
+                            if ((error.code >= 12000 && error.code < 13000) || (error.code >= 14000 && error.code < 15000)) {
+                                index_failure = true;
+                            } else if (error.code >= 4000 && error.code < 5000) {
+                                planning_failure = true;
+                            }
+                            break;
+                    }
+                }
+            }
+            if (syntax_error) {
+                response.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } else if (server_timeout) {
+                response.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);
+            } else if (index_failure) {
+                response.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);
+            } else if (index_not_found) {
+                response.ec = std::make_error_code(error::common_errc::index_not_found);
+            } else {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
     }
     return response;
 }