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

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
@@ -82,4 +82,4 @@ make_response(std::error_code ec, lookup_in_request& request, lookup_in_request:
     return response;
 }
 
-} // namespace couchbase::operations
+} // namespace couchbase::operations

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

@@ -18,7 +18,7 @@
 #pragma once
 
 #include <gsl/gsl_assert>
-#include <operations/document_id.hxx>
+#include <document_id.hxx>
 #include <protocol/cmd_mutate_in.hxx>
 
 namespace couchbase::operations
@@ -34,6 +34,7 @@ struct mutate_in_response {
     document_id id;
     std::error_code ec{};
     std::uint64_t cas{};
+    mutation_token token{};
     std::vector<field> fields{};
     std::optional<std::size_t> first_error_index{};
 };
@@ -47,6 +48,8 @@ struct mutate_in_request {
     uint32_t opaque{};
     bool access_deleted{ false };
     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{};
 
     void encode_to(encoded_request_type& encoded)
     {
@@ -55,6 +58,9 @@ struct mutate_in_request {
         encoded.body().id(id);
         encoded.body().access_deleted(access_deleted);
         encoded.body().specs(specs);
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
     }
 };
 
@@ -64,6 +70,9 @@ make_response(std::error_code ec, mutate_in_request& request, mutate_in_request:
     mutate_in_response response{ request.id, ec };
     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];
@@ -84,4 +93,4 @@ make_response(std::error_code ec, mutate_in_request& request, mutate_in_request:
     return response;
 }
 
-} // namespace couchbase::operations
+} // namespace couchbase::operations

data/ext/couchbase/operations/{query.hxx → document_query.hxx}

@@ -53,7 +53,6 @@ struct query_response_payload {
 
     query_meta_data meta_data{};
     std::vector<std::string> rows{};
-    std::string body;
 };
 } // namespace couchbase::operations
 
@@ -125,21 +124,27 @@ struct traits {
     }
 };
 } // 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::uint64_t timeout{ 75'000 }; // milliseconds
     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 +152,11 @@ 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{};
 
     enum class profile_mode {
         off,
@@ -165,7 +173,8 @@ struct query_request {
     {
         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) } };
         if (positional_parameters.empty()) {
             for (auto& param : named_parameters) {
                 Expects(param.first.empty() == false);
@@ -206,12 +215,43 @@ 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) {
+                    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"] = scan_wait.value();
+        }
         for (auto& param : raw) {
             body[param.first] = param.second;
         }
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
+        spdlog::trace("query request: {}", encoded.body);
     }
 };
 
@@ -222,7 +262,62 @@ make_response(std::error_code ec, query_request& request, query_request::encoded
     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;
 }

data/ext/couchbase/operations/document_remove.hxx

@@ -0,0 +1,67 @@
+/* -*- 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_remove.hxx>
+
+namespace couchbase::operations
+{
+
+struct remove_response {
+    document_id id;
+    std::error_code ec{};
+    std::uint64_t cas{};
+    mutation_token token{};
+};
+
+struct remove_request {
+    using encoded_request_type = protocol::client_request<protocol::remove_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::remove_response_body>;
+
+    document_id id;
+    uint16_t partition{};
+    uint32_t opaque{};
+    protocol::durability_level durability_level{ protocol::durability_level::none };
+    std::optional<std::uint16_t> durability_timeout{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
+    }
+};
+
+remove_response
+make_response(std::error_code ec, remove_request& request, remove_request::encoded_response_type encoded)
+{
+    remove_response response{ request.id, ec };
+    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_replace.hxx

@@ -0,0 +1,76 @@
+/* -*- 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_replace.hxx>
+#include <protocol/durability_level.hxx>
+
+namespace couchbase::operations
+{
+
+struct replace_response {
+    document_id id;
+    std::error_code ec{};
+    std::uint64_t cas{};
+    mutation_token token{};
+};
+
+struct replace_request {
+    using encoded_request_type = protocol::client_request<protocol::replace_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::replace_response_body>;
+
+    document_id id;
+    std::string value;
+    uint16_t partition{};
+    uint32_t opaque{};
+    uint32_t flags{ 0 };
+    uint32_t expiration{ 0 };
+    uint64_t cas{ 0 };
+    protocol::durability_level durability_level{ protocol::durability_level::none };
+    std::optional<std::uint16_t> durability_timeout{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.cas(cas);
+        encoded.body().id(id);
+        encoded.body().expiration(expiration);
+        encoded.body().flags(flags);
+        encoded.body().content(value);
+        if (durability_level != protocol::durability_level::none) {
+            encoded.body().durability(durability_level, durability_timeout);
+        }
+    }
+};
+
+replace_response
+make_response(std::error_code ec, replace_request& request, replace_request::encoded_response_type encoded)
+{
+    replace_response response{ request.id, ec };
+    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/{upsert.hxx → document_touch.hxx}

@@ -17,44 +17,44 @@
 
 #pragma once
 
-#include <operations/document_id.hxx>
-#include <protocol/cmd_upsert.hxx>
+#include <document_id.hxx>
+#include <protocol/cmd_touch.hxx>
 
 namespace couchbase::operations
 {
 
-struct upsert_response {
+struct touch_response {
     document_id id;
     std::error_code ec{};
     std::uint64_t cas{};
 };
 
-struct upsert_request {
-    using encoded_request_type = protocol::client_request<protocol::upsert_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::upsert_response_body>;
+struct touch_request {
+    using encoded_request_type = protocol::client_request<protocol::touch_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::touch_response_body>;
 
     document_id id;
-    std::string value;
-    uint16_t partition{};
-    uint32_t opaque{};
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
+    std::uint32_t expiration{};
 
     void encode_to(encoded_request_type& encoded)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
-        encoded.body().content(value);
+        encoded.body().expiration(expiration);
     }
 };
 
-upsert_response
-make_response(std::error_code ec, upsert_request& request, upsert_request::encoded_response_type encoded)
+touch_response
+make_response(std::error_code ec, touch_request& request, touch_request::encoded_response_type encoded)
 {
-    upsert_response response{ request.id, ec };
+    touch_response response{ request.id, ec };
     if (!ec) {
         response.cas = encoded.cas();
     }
     return response;
 }
 
-} // namespace couchbase::operations
+} // namespace couchbase::operations

data/ext/couchbase/operations/{remove.hxx → document_unlock.hxx}

@@ -17,42 +17,44 @@
 
 #pragma once
 
-#include <operations/document_id.hxx>
-#include <protocol/cmd_remove.hxx>
+#include <document_id.hxx>
+#include <protocol/cmd_unlock.hxx>
 
 namespace couchbase::operations
 {
 
-struct remove_response {
+struct unlock_response {
     document_id id;
     std::error_code ec{};
     std::uint64_t cas{};
 };
 
-struct remove_request {
-    using encoded_request_type = protocol::client_request<protocol::remove_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::remove_response_body>;
+struct unlock_request {
+    using encoded_request_type = protocol::client_request<protocol::unlock_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::unlock_response_body>;
 
     document_id id;
     uint16_t partition{};
     uint32_t opaque{};
+    uint64_t cas{};
 
     void encode_to(encoded_request_type& encoded)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
         encoded.body().id(id);
+        encoded.cas(cas);
     }
 };
 
-remove_response
-make_response(std::error_code ec, remove_request& request, remove_request::encoded_response_type encoded)
+unlock_response
+make_response(std::error_code ec, unlock_request& request, unlock_request::encoded_response_type encoded)
 {
-    remove_response response{ request.id, ec };
+    unlock_response response{ request.id, ec };
     if (!ec) {
         response.cas = encoded.cas();
     }
     return response;
 }
 
-} // namespace couchbase::operations
+} // namespace couchbase::operations