couchbase 4.2.8 → 4.2.10

package/deps/couchbase-cxx-client/core/{operations/mcbp_noop.cxx → impl/doc_id_query.cxx}

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2023-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -15,24 +15,28 @@
  *   limitations under the License.
  */
 
-#include "mcbp_noop.hxx"
+#include "encoded_search_query.hxx"
 
+#include <couchbase/doc_id_query.hxx>
 #include <couchbase/error_codes.hxx>
 
-namespace couchbase::core::operations
+#include <tao/json/contrib/traits.hpp>
+
+namespace couchbase
 {
-std::error_code
-mcbp_noop_request::encode_to(mcbp_noop_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
+auto
+doc_id_query::encode() const -> encoded_search_query
 {
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    return {};
-}
+    if (ids_.empty()) {
+        return { errc::common::invalid_argument };
+    }
 
-mcbp_noop_response
-mcbp_noop_request::make_response(key_value_error_context&& ctx, const encoded_response_type& /* encoded */) const
-{
-    mcbp_noop_response response{ std::move(ctx) };
-    return response;
+    encoded_search_query built;
+    built.query = tao::json::value{ { "ids", ids_ } };
+
+    if (boost_.has_value()) {
+        built.query["boost"] = boost_.value();
+    }
+    return built;
 }
-} // namespace couchbase::core::operations
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/key_value_error_category.cxx

@@ -80,10 +80,12 @@ struct key_value_error_category : std::error_category {
                 return "xattr_unknown_virtual_attribute (127)";
             case errc::key_value::xattr_cannot_modify_virtual_attribute:
                 return "xattr_cannot_modify_virtual_attribute (128)";
-            case errc::key_value::cannot_revive_living_document:
-                return "cannot_revive_living_document (131)";
             case errc::key_value::xattr_no_access:
                 return "xattr_no_access (130)";
+            case errc::key_value::document_not_locked:
+                return "document_not_locked (131)";
+            case errc::key_value::cannot_revive_living_document:
+                return "cannot_revive_living_document (132)";
             case errc::key_value::mutation_token_outdated:
                 return "mutation_token_outdated (133)";
             case errc::key_value::range_scan_completed:

package/deps/couchbase-cxx-client/core/impl/lookup_in_all_replicas.hxx

@@ -67,14 +67,4 @@ class lookup_in_all_replicas_request
 
 using movable_lookup_in_all_replicas_handler =
   utils::movable_function<void(couchbase::subdocument_error_context, lookup_in_all_replicas_result)>;
-
-void
-initiate_lookup_in_all_replicas_operation(std::shared_ptr<cluster> core,
-                                          const std::string& bucket_name,
-                                          const std::string& scope_name,
-                                          const std::string& collection_name,
-                                          std::string document_key,
-                                          const std::vector<subdoc::command>& specs,
-                                          std::optional<std::chrono::milliseconds> timeout,
-                                          movable_lookup_in_all_replicas_handler&& handler);
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/lookup_in_any_replica.hxx

@@ -62,14 +62,4 @@ class lookup_in_any_replica_request
 };
 
 using movable_lookup_in_any_replica_handler = utils::movable_function<void(couchbase::subdocument_error_context, lookup_in_replica_result)>;
-
-void
-initiate_lookup_in_any_replica_operation(std::shared_ptr<cluster> core,
-                                         const std::string& bucket_name,
-                                         const std::string& scope_name,
-                                         const std::string& collection_name,
-                                         std::string document_key,
-                                         const std::vector<subdoc::command>& specs,
-                                         std::optional<std::chrono::milliseconds> timeout,
-                                         movable_lookup_in_any_replica_handler&& handler);
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/observe_poll.cxx

@@ -20,12 +20,18 @@
 #include "core/cluster.hxx"
 #include "core/impl/observe_seqno.hxx"
 
+#include <couchbase/error_codes.hxx>
+
+#include <asio/steady_timer.hpp>
+
 #include <memory>
 #include <mutex>
 
 namespace couchbase::core::impl
 {
-static constexpr bool
+namespace
+{
+constexpr bool
 touches_replica(couchbase::persist_to persist_to, couchbase::replicate_to replicate_to)
 {
 
@@ -53,7 +59,7 @@ touches_replica(couchbase::persist_to persist_to, couchbase::replicate_to replic
     return false;
 }
 
-static constexpr std::uint32_t
+constexpr std::uint32_t
 number_of_replica_nodes_required(couchbase::persist_to persist_to)
 {
     switch (persist_to) {
@@ -72,7 +78,7 @@ number_of_replica_nodes_required(couchbase::persist_to persist_to)
     return 0U;
 }
 
-static constexpr std::uint32_t
+constexpr std::uint32_t
 number_of_replica_nodes_required(couchbase::replicate_to replicate_to)
 {
     switch (replicate_to) {
@@ -88,7 +94,7 @@ number_of_replica_nodes_required(couchbase::replicate_to replicate_to)
     return 0U;
 }
 
-static std::pair<std::error_code, std::uint32_t>
+std::pair<std::error_code, std::uint32_t>
 validate_replicas(const topology::configuration& config, couchbase::persist_to persist_to, couchbase::replicate_to replicate_to)
 {
     if (config.node_locator != topology::configuration::node_locator_type::vbucket) {
@@ -158,8 +164,8 @@ class observe_status
 };
 
 class observe_context;
-static void
-observe_poll(std::shared_ptr<couchbase::core::cluster> core, std::shared_ptr<observe_context> ctx);
+void
+observe_poll(cluster core, std::shared_ptr<observe_context> ctx);
 
 class observe_context : public std::enable_shared_from_this<observe_context>
 {
@@ -270,13 +276,13 @@ class observe_context : public std::enable_shared_from_this<observe_context>
         }
     }
 
-    void on_last_response(std::size_t expected_number_of_responses, std::function<void(std::error_code)> handler)
+    void on_last_response(std::size_t expected_number_of_responses, utils::movable_function<void(std::error_code)> handler)
     {
         expect_number_of_responses_ = expected_number_of_responses;
         on_last_response_ = std::move(handler);
     }
 
-    void execute(std::shared_ptr<couchbase::core::cluster> core)
+    void execute(cluster core)
     {
         auto requests = std::move(requests_);
         status_.reset();
@@ -287,8 +293,8 @@ class observe_context : public std::enable_shared_from_this<observe_context>
             observe_poll(std::move(core), std::move(ctx));
         });
         for (auto&& request : requests) {
-            core->execute(std::move(request),
-                          [ctx = shared_from_this()](observe_seqno_response&& response) { ctx->handle_response(std::move(response)); });
+            core.execute(std::move(request),
+                         [ctx = shared_from_this()](observe_seqno_response&& response) { ctx->handle_response(std::move(response)); });
         }
     }
 
@@ -304,16 +310,16 @@ class observe_context : public std::enable_shared_from_this<observe_context>
     std::atomic_size_t expect_number_of_responses_{};
     std::mutex handler_mutex_{};
     observe_handler handler_{};
-    std::function<void(std::error_code)> on_last_response_{};
+    utils::movable_function<void(std::error_code)> on_last_response_{};
     std::chrono::milliseconds poll_backoff_interval_{ 500 };
     std::chrono::milliseconds poll_deadline_interval_{ 5'000 };
 };
 
-static void
-observe_poll(std::shared_ptr<couchbase::core::cluster> core, std::shared_ptr<observe_context> ctx)
+void
+observe_poll(cluster core, std::shared_ptr<observe_context> ctx)
 {
-    std::string bucket_name = ctx->bucket_name();
-    core->with_bucket_configuration(
+    const std::string bucket_name = ctx->bucket_name();
+    core.with_bucket_configuration(
       bucket_name, [core, ctx = std::move(ctx)](std::error_code ec, const core::topology::configuration& config) mutable {
           if (ec) {
               return ctx->finish(ec);
@@ -337,9 +343,10 @@ observe_poll(std::shared_ptr<couchbase::core::cluster> core, std::shared_ptr<obs
           ctx->execute(core);
       });
 }
+} // namespace
 
 void
-initiate_observe_poll(std::shared_ptr<couchbase::core::cluster> core,
+initiate_observe_poll(cluster core,
                       document_id id,
                       mutation_token token,
                       std::optional<std::chrono::milliseconds> timeout,
@@ -348,7 +355,7 @@ initiate_observe_poll(std::shared_ptr<couchbase::core::cluster> core,
                       observe_handler&& handler)
 {
     auto ctx = std::make_shared<observe_context>(
-      core->io_context(), std::move(id), std::move(token), timeout, persist_to, replicate_to, std::move(handler));
+      core.io_context(), std::move(id), std::move(token), timeout, persist_to, replicate_to, std::move(handler));
     ctx->start();
     return observe_poll(std::move(core), std::move(ctx));
 }

package/deps/couchbase-cxx-client/core/impl/observe_poll.hxx

@@ -38,7 +38,7 @@ namespace impl
 using observe_handler = utils::movable_function<void(std::error_code)>;
 
 void
-initiate_observe_poll(std::shared_ptr<couchbase::core::cluster> core,
+initiate_observe_poll(cluster core,
                       document_id id,
                       mutation_token token,
                       std::optional<std::chrono::milliseconds> timeout,

package/deps/couchbase-cxx-client/core/impl/query.cxx

@@ -21,33 +21,13 @@
 
 #include "core/cluster.hxx"
 #include "core/operations/document_query.hxx"
+#include "core/utils/binary.hxx"
 
 namespace couchbase::core::impl
 {
-static query_error_context
-build_context(operations::query_response& resp)
+namespace
 {
-    return {
-        resp.ctx.ec,
-        resp.ctx.last_dispatched_to,
-        resp.ctx.last_dispatched_from,
-        resp.ctx.retry_attempts,
-        std::move(resp.ctx.retry_reasons),
-        resp.ctx.first_error_code,
-        std::move(resp.ctx.first_error_message),
-        std::move(resp.ctx.client_context_id),
-        std::move(resp.ctx.statement),
-        std::move(resp.ctx.parameters),
-        std::move(resp.ctx.method),
-        std::move(resp.ctx.path),
-        resp.ctx.http_status,
-        std::move(resp.ctx.http_body),
-        std::move(resp.ctx.hostname),
-        resp.ctx.port,
-    };
-}
-
-static query_status
+query_status
 map_status(std::string status)
 {
     std::transform(status.cbegin(), status.cend(), status.begin(), [](unsigned char c) { return std::tolower(c); });
@@ -73,7 +53,7 @@ map_status(std::string status)
     return query_status::unknown;
 }
 
-static std::vector<codec::binary>
+std::vector<codec::binary>
 map_rows(operations::query_response& resp)
 {
     std::vector<codec::binary> rows;
@@ -84,7 +64,7 @@ map_rows(operations::query_response& resp)
     return rows;
 }
 
-static std::vector<query_warning>
+std::vector<query_warning>
 map_warnings(operations::query_response& resp)
 {
     std::vector<query_warning> warnings;
@@ -102,7 +82,7 @@ map_warnings(operations::query_response& resp)
     return warnings;
 }
 
-static std::optional<query_metrics>
+std::optional<query_metrics>
 map_metrics(operations::query_response& resp)
 {
     if (!resp.meta.metrics) {
@@ -116,7 +96,7 @@ map_metrics(operations::query_response& resp)
     };
 }
 
-static std::optional<std::vector<std::byte>>
+std::optional<std::vector<std::byte>>
 map_signature(operations::query_response& resp)
 {
     if (!resp.meta.signature) {
@@ -125,7 +105,7 @@ map_signature(operations::query_response& resp)
     return utils::to_binary(resp.meta.signature.value());
 }
 
-static std::optional<std::vector<std::byte>>
+std::optional<std::vector<std::byte>>
 map_profile(operations::query_response& resp)
 {
     if (!resp.meta.profile) {
@@ -133,8 +113,32 @@ map_profile(operations::query_response& resp)
     }
     return utils::to_binary(resp.meta.profile.value());
 }
+} // namespace
 
-static query_result
+query_error_context
+build_context(operations::query_response& resp)
+{
+    return {
+        resp.ctx.ec,
+        resp.ctx.last_dispatched_to,
+        resp.ctx.last_dispatched_from,
+        resp.ctx.retry_attempts,
+        std::move(resp.ctx.retry_reasons),
+        resp.ctx.first_error_code,
+        std::move(resp.ctx.first_error_message),
+        std::move(resp.ctx.client_context_id),
+        std::move(resp.ctx.statement),
+        std::move(resp.ctx.parameters),
+        std::move(resp.ctx.method),
+        std::move(resp.ctx.path),
+        resp.ctx.http_status,
+        std::move(resp.ctx.http_body),
+        std::move(resp.ctx.hostname),
+        resp.ctx.port,
+    };
+}
+
+query_result
 build_result(operations::query_response& resp)
 {
     return {
@@ -151,28 +155,19 @@ build_result(operations::query_response& resp)
     };
 }
 
-static core::operations::query_request
-build_query_request(std::string statement, query_options::built options)
+core::operations::query_request
+build_query_request(std::string statement, std::optional<std::string> query_context, query_options::built options)
 {
     operations::query_request request{
-        std::move(statement),
-        options.adhoc,
-        options.metrics,
-        options.readonly,
-        options.flex_index,
-        options.preserve_expiry,
-        options.use_replica,
-        options.max_parallelism,
-        options.scan_cap,
-        options.scan_wait,
-        options.pipeline_batch,
-        options.pipeline_cap,
-        options.scan_consistency,
-        std::move(options.mutation_state),
-        std::move(options.client_context_id),
-        {}, // we put the query_context in later, if one was specified.
-        options.timeout,
-        options.profile,
+        std::move(statement),     options.adhoc,
+        options.metrics,          options.readonly,
+        options.flex_index,       options.preserve_expiry,
+        options.use_replica,      options.max_parallelism,
+        options.scan_cap,         options.scan_wait,
+        options.pipeline_batch,   options.pipeline_cap,
+        options.scan_consistency, std::move(options.mutation_state),
+        std::move(query_context), std::move(options.client_context_id),
+        options.timeout,          options.profile,
     };
     if (!options.raw.empty()) {
         for (auto& [name, value] : options.raw) {
@@ -223,24 +218,6 @@ build_transaction_query_result(operations::query_response resp, std::error_code
 core::operations::query_request
 build_transaction_query_request(query_options::built opts)
 {
-    return build_query_request("", opts);
-}
-
-void
-initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
-                         std::string statement,
-                         std::optional<std::string> query_context,
-                         query_options::built options,
-                         query_handler&& handler)
-{
-    auto request = build_query_request(std::move(statement), options);
-    if (query_context) {
-        request.query_context = std::move(query_context);
-    }
-
-    core->execute(std::move(request), [core, handler = std::move(handler)](operations::query_response resp) mutable {
-        auto r = std::move(resp);
-        return handler(build_context(r), build_result(r));
-    });
+    return core::impl::build_query_request("", {}, opts);
 }
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/query.hxx

@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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 "core/operations/document_query.hxx"
+
+#include <couchbase/query_options.hxx>
+
+namespace couchbase::core::impl
+{
+core::operations::query_request
+build_query_request(std::string statement, std::optional<std::string> query_context, query_options::built options);
+
+query_result
+build_result(operations::query_response& resp);
+
+query_error_context
+build_context(operations::query_response& resp);
+} // namespace couchbase::core::impl