couchbase 4.2.8 → 4.2.10

package/deps/couchbase-cxx-client/core/protocol/hello_feature_fmt.hxx

@@ -109,6 +109,9 @@ struct fmt::formatter<couchbase::core::protocol::hello_feature> {
             case couchbase::core::protocol::hello_feature::subdoc_replica_read:
                 name = "subdoc_replica_read";
                 break;
+            case couchbase::core::protocol::hello_feature::deduplicate_not_my_vbucket_clustermap:
+                name = "deduplicate_not_my_vbucket_clustermap";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }

package/deps/couchbase-cxx-client/core/protocol/status.cxx

@@ -75,8 +75,14 @@ map_status_code(protocol::client_opcode opcode, std::uint16_t status)
             return errc::common::bucket_not_found;
 
         case key_value_status_code::locked:
+            if (opcode == protocol::client_opcode::unlock) {
+                return errc::common::cas_mismatch;
+            }
             return errc::key_value::document_locked;
 
+        case key_value_status_code::not_locked:
+            return errc::key_value::document_not_locked;
+
         case key_value_status_code::auth_stale:
         case key_value_status_code::auth_error:
         case key_value_status_code::no_access:

package/deps/couchbase-cxx-client/core/protocol/status.hxx

@@ -41,6 +41,7 @@ is_valid_status(std::uint16_t code)
         case key_value_status_code::not_my_vbucket:
         case key_value_status_code::no_bucket:
         case key_value_status_code::locked:
+        case key_value_status_code::not_locked:
         case key_value_status_code::auth_stale:
         case key_value_status_code::auth_error:
         case key_value_status_code::auth_continue:

package/deps/couchbase-cxx-client/core/query_context.hxx

@@ -27,22 +27,23 @@ class query_context
 {
   public:
     query_context() = default;
+
     query_context(std::string namespace_id, std::string bucket_name, std::string scope_name)
-      : namespace_id_(namespace_id)
-      , bucket_name_(bucket_name)
-      , scope_name_(scope_name)
+      : namespace_id_(std::move(namespace_id))
+      , bucket_name_(std::move(bucket_name))
+      , scope_name_(std::move(scope_name))
     {
     }
 
     query_context(std::string bucket_name, std::string scope_name)
-      : bucket_name_(bucket_name)
-      , scope_name_(scope_name)
+      : bucket_name_(std::move(bucket_name))
+      , scope_name_(std::move(scope_name))
     {
     }
 
     bool has_value() const
     {
-        return bucket_name_.has_value() && scope_name_.has_value();
+        return bucket_name_.has_value() && !bucket_name_->empty() && scope_name_.has_value() && !scope_name_->empty();
     }
 
     std::string value() const
@@ -52,6 +53,7 @@ class query_context
         }
         return {};
     }
+
     std::string bucket_name() const
     {
         if (has_value()) {
@@ -59,6 +61,7 @@ class query_context
         }
         return "";
     }
+
     std::string scope_name() const
     {
         if (has_value()) {
@@ -66,6 +69,7 @@ class query_context
         }
         return "";
     }
+
     std::string namespace_id() const
     {
         return namespace_id_;
@@ -76,4 +80,4 @@ class query_context
     std::optional<std::string> bucket_name_;
     std::optional<std::string> scope_name_;
 };
-} // namespace couchbase::core
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/range_scan_orchestrator.cxx

@@ -673,7 +673,7 @@ class range_scan_orchestrator_impl
     topology::configuration::vbucket_map vbucket_map_;
     std::string scope_name_;
     std::string collection_name_;
-    std::uint32_t collection_id_;
+    std::uint32_t collection_id_{ 0 };
     std::variant<std::monostate, range_scan, prefix_scan, sampling_scan> scan_type_;
     range_scan_orchestrator_options options_;
     std::map<std::size_t, std::optional<range_snapshot_requirements>> vbucket_to_snapshot_requirements_;

package/deps/couchbase-cxx-client/core/topology/collections_manifest.hxx

@@ -28,7 +28,7 @@ struct collections_manifest {
     struct collection {
         std::uint64_t uid;
         std::string name;
-        std::uint32_t max_expiry{ 0 };
+        std::int32_t max_expiry{ 0 };
         std::optional<bool> history{};
     };
 

package/deps/couchbase-cxx-client/core/topology/collections_manifest_json.hxx

@@ -41,7 +41,7 @@ struct traits<couchbase::core::topology::collections_manifest> {
                 collection.uid = std::stoull(c.at("uid").get_string(), nullptr, 16);
                 collection.name = c.at("name").get_string();
                 if (const auto* max_ttl = c.find("maxTTL"); max_ttl != nullptr) {
-                    collection.max_expiry = max_ttl->template as<std::uint32_t>();
+                    collection.max_expiry = max_ttl->template as<std::int32_t>();
                 }
                 if (const auto* history = c.find("history"); history != nullptr) {
                     collection.history = history->template as<std::optional<bool>>();

package/deps/couchbase-cxx-client/core/topology/configuration.cxx

@@ -19,6 +19,7 @@
 
 #include "core/logger/logger.hxx"
 #include "core/service_type_fmt.hxx"
+#include "core/utils/crc32.hxx"
 
 #include <gsl/narrow>
 
@@ -230,6 +231,28 @@ configuration::server_by_vbucket(std::uint16_t vbucket, std::size_t index)
     return {};
 }
 
+std::pair<std::uint16_t, std::optional<std::size_t>>
+configuration::map_key(const std::string& key, std::size_t index)
+{
+    if (!vbmap.has_value()) {
+        return { 0, {} };
+    }
+    const std::uint32_t crc = utils::hash_crc32(key.data(), key.size());
+    auto vbucket = static_cast<std::uint16_t>(crc % vbmap->size());
+    return { vbucket, server_by_vbucket(vbucket, index) };
+}
+
+std::pair<std::uint16_t, std::optional<std::size_t>>
+configuration::map_key(const std::vector<std::byte>& key, std::size_t index)
+{
+    if (!vbmap.has_value()) {
+        return { 0, {} };
+    }
+    const std::uint32_t crc = utils::hash_crc32(key.data(), key.size());
+    auto vbucket = static_cast<std::uint16_t>(crc % vbmap->size());
+    return { vbucket, server_by_vbucket(vbucket, index) };
+}
+
 configuration
 make_blank_configuration(const std::string& hostname, std::uint16_t plain_port, std::uint16_t tls_port)
 {

package/deps/couchbase-cxx-client/core/topology/configuration.hxx

@@ -20,9 +20,7 @@
 #include "capabilities.hxx"
 #include "core/platform/uuid.h"
 #include "core/service_type.hxx"
-#include "core/utils/crc32.hxx"
 
-#include <fmt/core.h>
 #include <map>
 #include <optional>
 #include <set>
@@ -63,6 +61,12 @@ struct configuration {
         port_map services_tls{};
         std::map<std::string, alternate_address> alt{};
 
+        bool operator!=(const node& other) const
+        {
+            return hostname != other.hostname || services_plain.key_value != other.services_plain.key_value ||
+                   services_tls.key_value != other.services_tls.key_value;
+        }
+
         [[nodiscard]] std::uint16_t port_or(service_type type, bool is_tls, std::uint16_t default_value) const;
 
         [[nodiscard]] std::uint16_t port_or(const std::string& network, service_type type, bool is_tls, std::uint16_t default_value) const;
@@ -146,16 +150,8 @@ struct configuration {
                                 const std::string& hostname,
                                 const std::string& port) const;
 
-    template<typename Key>
-    std::pair<std::uint16_t, std::optional<std::size_t>> map_key(const Key& key, std::size_t index)
-    {
-        if (!vbmap.has_value()) {
-            return { 0, {} };
-        }
-        std::uint32_t crc = utils::hash_crc32(key.data(), key.size());
-        auto vbucket = static_cast<std::uint16_t>(crc % vbmap->size());
-        return { vbucket, server_by_vbucket(vbucket, index) };
-    }
+    std::pair<std::uint16_t, std::optional<std::size_t>> map_key(const std::string& key, std::size_t index);
+    std::pair<std::uint16_t, std::optional<std::size_t>> map_key(const std::vector<std::byte>& key, std::size_t index);
 
     std::optional<std::size_t> server_by_vbucket(std::uint16_t vbucket, std::size_t index);
 };

package/deps/couchbase-cxx-client/core/topology/configuration_fmt.hxx

@@ -159,8 +159,8 @@ struct fmt::formatter<couchbase::core::topology::configuration> {
                          config.num_replicas ? fmt::format(", replicas={}", *config.num_replicas) : "",
                          config.vbmap.has_value() ? fmt::format(", partitions={}", config.vbmap->size()) : "",
                          config.nodes.size(),
-                         couchbase::core::utils::join_strings_fmt("{}", config.nodes, ", "),
-                         couchbase::core::utils::join_strings_fmt("{}", config.bucket_capabilities, ", "),
-                         couchbase::core::utils::join_strings_fmt("{}", config.cluster_capabilities, ", "));
+                         couchbase::core::utils::join_strings_fmt(config.nodes, ", "),
+                         couchbase::core::utils::join_strings_fmt(config.bucket_capabilities, ", "),
+                         couchbase::core::utils::join_strings_fmt(config.cluster_capabilities, ", "));
     }
 };

package/deps/couchbase-cxx-client/core/topology/configuration_json.hxx

@@ -21,6 +21,8 @@
 
 #include <tao/json/forward.hpp>
 
+#include <limits>
+
 namespace tao::json
 {
 template<>

package/deps/couchbase-cxx-client/core/topology/error_map.hxx

@@ -27,8 +27,8 @@
 namespace couchbase::core
 {
 struct error_map {
-    uuid::uuid_t id;
-    std::uint16_t version;
+    uuid::uuid_t id{};
+    std::uint16_t version{};
     std::uint16_t revision{};
     std::map<std::uint16_t, couchbase::key_value_error_map_info> errors{};
 };

package/deps/couchbase-cxx-client/core/topology/error_map_json.hxx

@@ -77,6 +77,10 @@ struct traits<couchbase::core::error_map> {
                     attributes.insert(couchbase::key_value_error_map_attribute::item_deleted);
                 } else if (attr_val == "rate-limit") {
                     attributes.insert(couchbase::key_value_error_map_attribute::rate_limit);
+                } else if (attr_val == "no-retry") {
+                    attributes.insert(couchbase::key_value_error_map_attribute::no_retry);
+                } else if (attr_val == "system-constraint") {
+                    attributes.insert(couchbase::key_value_error_map_attribute::system_constraint);
                 } else {
                     CB_LOG_WARNING(R"(skipping unknown attribute "{}" in error map for code={} and name="{}")", attr_val, code, name);
                 }

package/deps/couchbase-cxx-client/core/transactions/active_transaction_record.cxx

@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2021-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.
+ */
+
+#include "active_transaction_record.hxx"
+
+namespace couchbase::core::transactions
+{
+active_transaction_record
+active_transaction_record::map_to_atr(const operations::lookup_in_response& resp)
+{
+    std::vector<atr_entry> entries;
+    if (resp.fields[0].status == key_value_status_code::success) {
+        auto attempts = core::utils::json::parse_binary(resp.fields[0].value);
+        auto vbucket = core::utils::json::parse_binary(resp.fields[1].value);
+        auto now_ns = now_ns_from_vbucket(vbucket);
+        entries.reserve(attempts.get_object().size());
+        for (const auto& [key, val] : attempts.get_object()) {
+            std::optional<tao::json::value> forward_compat;
+            if (const auto* compat = val.find(ATR_FIELD_FORWARD_COMPAT); compat != nullptr) {
+                forward_compat = *compat;
+            }
+            std::optional<uint32_t> expires_after_msec = std::max(val.optional<int32_t>(ATR_FIELD_EXPIRES_AFTER_MSECS).value_or(0), 0);
+            entries.emplace_back(resp.ctx.bucket(),
+                                 resp.ctx.id(),
+                                 key,
+                                 attempt_state_value(val.at(ATR_FIELD_STATUS).get_string()),
+                                 parse_mutation_cas(val.optional<std::string>(ATR_FIELD_START_TIMESTAMP).value_or("")),
+                                 parse_mutation_cas(val.optional<std::string>(ATR_FIELD_START_COMMIT).value_or("")),
+                                 parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_COMPLETE).value_or("")),
+                                 parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_ROLLBACK_START).value_or("")),
+                                 parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_ROLLBACK_COMPLETE).value_or("")),
+                                 expires_after_msec,
+                                 process_document_ids(val, ATR_FIELD_DOCS_INSERTED),
+                                 process_document_ids(val, ATR_FIELD_DOCS_REPLACED),
+                                 process_document_ids(val, ATR_FIELD_DOCS_REMOVED),
+                                 forward_compat,
+                                 now_ns,
+                                 val.optional<std::string>(ATR_FIELD_DURABILITY_LEVEL));
+        }
+    }
+    return active_transaction_record(
+      { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() }, resp.cas.value(), std::move(entries));
+}
+} // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/active_transaction_record.hxx

@@ -35,9 +35,8 @@ namespace couchbase::core::transactions
 class active_transaction_record
 {
   public:
-    // TODO: we should get the kv_timeout and put it in the request (pass in the transactions_config)
     template<typename Callback>
-    static void get_atr(std::shared_ptr<core::cluster> cluster, const core::document_id& atr_id, Callback&& cb)
+    static void get_atr(const core::cluster& cluster, const core::document_id& atr_id, Callback&& cb)
     {
         core::operations::lookup_in_request req{ atr_id };
         req.specs =
@@ -46,7 +45,7 @@ class active_transaction_record
               lookup_in_specs::get(subdoc::lookup_in_macro::vbucket).xattr(),
           }
             .specs();
-        cluster->execute(req, [atr_id, cb = std::move(cb)](core::operations::lookup_in_response resp) mutable {
+        cluster.execute(req, [atr_id, cb = std::move(cb)](core::operations::lookup_in_response resp) mutable {
             try {
                 if (resp.ctx.ec() == couchbase::errc::key_value::document_not_found) {
                     // that's ok, just return an empty one.
@@ -69,7 +68,7 @@ class active_transaction_record
         });
     }
 
-    static std::optional<active_transaction_record> get_atr(std::shared_ptr<core::cluster> cluster, const core::document_id& atr_id)
+    static std::optional<active_transaction_record> get_atr(const core::cluster& cluster, const core::document_id& atr_id)
     {
         auto barrier = std::promise<std::optional<active_transaction_record>>();
         auto f = barrier.get_future();
@@ -82,7 +81,7 @@ class active_transaction_record
         return f.get();
     }
 
-    active_transaction_record(const core::document_id& id, uint64_t, std::vector<atr_entry> entries)
+    active_transaction_record(core::document_id id, uint64_t, std::vector<atr_entry> entries)
       : id_(std::move(id))
       , entries_(std::move(entries))
     {
@@ -140,41 +139,7 @@ class active_transaction_record
         return records;
     }
 
-    static inline active_transaction_record map_to_atr(const core::operations::lookup_in_response& resp)
-    {
-        std::vector<atr_entry> entries;
-        if (resp.fields[0].status == key_value_status_code::success) {
-            auto attempts = core::utils::json::parse_binary(resp.fields[0].value);
-            auto vbucket = core::utils::json::parse_binary(resp.fields[1].value);
-            auto now_ns = now_ns_from_vbucket(vbucket);
-            entries.reserve(attempts.get_object().size());
-            for (const auto& [key, val] : attempts.get_object()) {
-                std::optional<tao::json::value> forward_compat;
-                if (const auto* compat = val.find(ATR_FIELD_FORWARD_COMPAT); compat != nullptr) {
-                    forward_compat = *compat;
-                }
-                std::optional<uint32_t> expires_after_msec = std::max(val.optional<int32_t>(ATR_FIELD_EXPIRES_AFTER_MSECS).value_or(0), 0);
-                entries.emplace_back(resp.ctx.bucket(),
-                                     resp.ctx.id(),
-                                     key,
-                                     attempt_state_value(val.at(ATR_FIELD_STATUS).get_string()),
-                                     parse_mutation_cas(val.optional<std::string>(ATR_FIELD_START_TIMESTAMP).value_or("")),
-                                     parse_mutation_cas(val.optional<std::string>(ATR_FIELD_START_COMMIT).value_or("")),
-                                     parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_COMPLETE).value_or("")),
-                                     parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_ROLLBACK_START).value_or("")),
-                                     parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_ROLLBACK_COMPLETE).value_or("")),
-                                     expires_after_msec,
-                                     process_document_ids(val, ATR_FIELD_DOCS_INSERTED),
-                                     process_document_ids(val, ATR_FIELD_DOCS_REPLACED),
-                                     process_document_ids(val, ATR_FIELD_DOCS_REMOVED),
-                                     forward_compat,
-                                     now_ns,
-                                     val.optional<std::string>(ATR_FIELD_DURABILITY_LEVEL));
-            }
-        }
-        return active_transaction_record(
-          { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() }, resp.cas.value(), std::move(entries));
-    }
+    static active_transaction_record map_to_atr(const core::operations::lookup_in_response& resp);
 };
 
 } // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/async_attempt_context.cxx

@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2021-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.
+ */
+
+#include <couchbase/scope.hxx>
+#include <couchbase/transactions/async_attempt_context.hxx>
+
+#include <fmt/core.h>
+
+namespace couchbase::transactions
+{
+void
+async_attempt_context::query(const scope& scope, std::string statement, transaction_query_options opts, async_query_handler&& handler)
+{
+    return query(std::move(statement), std::move(opts), fmt::format("{}.{}", scope.bucket_name(), scope.name()), std::move(handler));
+}
+} // namespace couchbase::transactions

package/deps/couchbase-cxx-client/core/transactions/atr_cleanup_entry.cxx

@@ -22,11 +22,13 @@
 
 #include "core/transactions.hxx"
 #include "internal/atr_cleanup_entry.hxx"
+#include "internal/doc_record_fmt.hxx"
 #include "internal/exceptions_internal.hxx"
 #include "internal/logging.hxx"
 #include "internal/transactions_cleanup.hxx"
 #include "internal/utils.hxx"
 #include "result.hxx"
+#include "result_fmt.hxx"
 
 #include <optional>
 
@@ -189,10 +191,9 @@ atr_cleanup_entry::do_per_doc(std::vector<doc_record> docs,
               }
                 .specs();
             req.access_deleted = true;
-            wrap_request(req, cleanup_->config());
             // now a blocking lookup_in...
             auto barrier = std::make_shared<std::promise<result>>();
-            cleanup_->cluster_ref()->execute(
+            cleanup_->cluster_ref().execute(
               req, [barrier](core::operations::lookup_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
             auto f = barrier->get_future();
             auto res = wrap_operation_future(f);
@@ -253,10 +254,9 @@ atr_cleanup_entry::commit_docs(std::optional<std::vector<doc_record>> docs, dura
                     core::operations::insert_request req{ doc.id(), content };
                     auto barrier = std::make_shared<std::promise<result>>();
                     auto f = barrier->get_future();
-                    cleanup_->cluster_ref()->execute(wrap_durable_request(req, cleanup_->config(), dl),
-                                                     [barrier](core::operations::insert_response resp) {
-                                                         barrier->set_value(result::create_from_mutation_response(resp));
-                                                     });
+                    cleanup_->cluster_ref().execute(wrap_durable_request(req, dl), [barrier](core::operations::insert_response resp) {
+                        barrier->set_value(result::create_from_mutation_response(resp));
+                    });
                     wrap_operation_future(f);
                 } else {
                     core::operations::mutate_in_request req{ doc.id() };
@@ -268,10 +268,10 @@ atr_cleanup_entry::commit_docs(std::optional<std::vector<doc_record>> docs, dura
                         .specs();
                     req.cas = doc.cas();
                     req.store_semantics = couchbase::store_semantics::replace;
-                    wrap_durable_request(req, cleanup_->config(), dl);
+                    wrap_durable_request(req, dl);
                     auto barrier = std::make_shared<std::promise<result>>();
                     auto f = barrier->get_future();
-                    cleanup_->cluster_ref()->execute(req, [barrier](core::operations::mutate_in_response resp) {
+                    cleanup_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
                         barrier->set_value(result::create_from_subdoc_response(resp));
                     });
                     wrap_operation_future(f);
@@ -301,20 +301,20 @@ atr_cleanup_entry::remove_docs(std::optional<std::vector<doc_record>> docs, dura
                     .specs();
                 req.cas = doc.cas();
                 req.access_deleted = true;
-                wrap_durable_request(req, cleanup_->config(), dl);
+                wrap_durable_request(req, dl);
                 auto barrier = std::make_shared<std::promise<result>>();
                 auto f = barrier->get_future();
-                cleanup_->cluster_ref()->execute(req, [barrier](core::operations::mutate_in_response resp) {
+                cleanup_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
                     barrier->set_value(result::create_from_subdoc_response(resp));
                 });
                 wrap_operation_future(f);
             } else {
                 core::operations::remove_request req{ doc.id() };
                 req.cas = doc.cas();
-                wrap_durable_request(req, cleanup_->config(), dl);
+                wrap_durable_request(req, dl);
                 auto barrier = std::make_shared<std::promise<result>>();
                 auto f = barrier->get_future();
-                cleanup_->cluster_ref()->execute(req, [barrier](core::operations::remove_response resp) {
+                cleanup_->cluster_ref().execute(req, [barrier](core::operations::remove_response resp) {
                     barrier->set_value(result::create_from_mutation_response(resp));
                 });
                 wrap_operation_future(f);
@@ -336,10 +336,10 @@ atr_cleanup_entry::remove_docs_staged_for_removal(std::optional<std::vector<doc_
                 }
                 core::operations::remove_request req{ doc.id() };
                 req.cas = doc.cas();
-                wrap_durable_request(req, cleanup_->config(), dl);
+                wrap_durable_request(req, dl);
                 auto barrier = std::make_shared<std::promise<result>>();
                 auto f = barrier->get_future();
-                cleanup_->cluster_ref()->execute(req, [barrier](core::operations::remove_response resp) {
+                cleanup_->cluster_ref().execute(req, [barrier](core::operations::remove_response resp) {
                     barrier->set_value(result::create_from_mutation_response(resp));
                 });
                 wrap_operation_future(f);
@@ -370,10 +370,10 @@ atr_cleanup_entry::remove_txn_links(std::optional<std::vector<doc_record>> docs,
                 .specs();
             req.access_deleted = true;
             req.cas = doc.cas();
-            wrap_durable_request(req, cleanup_->config(), dl);
+            wrap_durable_request(req, dl);
             auto barrier = std::make_shared<std::promise<result>>();
             auto f = barrier->get_future();
-            cleanup_->cluster_ref()->execute(
+            cleanup_->cluster_ref().execute(
               req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
             wrap_operation_future(f);
             CB_ATTEMPT_CLEANUP_LOG_TRACE("remove_txn_links removed links for doc {}", doc.id());
@@ -397,10 +397,10 @@ atr_cleanup_entry::cleanup_entry(durability_level dl)
         }
         mut_specs.push_back(couchbase::mutate_in_specs::remove("attempts." + atr_entry_->attempt_id()).xattr());
         req.specs = mut_specs.specs();
-        wrap_durable_request(req, cleanup_->config(), dl);
+        wrap_durable_request(req, dl);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        cleanup_->cluster_ref()->execute(
+        cleanup_->cluster_ref().execute(
           req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         wrap_operation_future(f);
         CB_ATTEMPT_CLEANUP_LOG_TRACE("successfully removed attempt {}", attempt_id_);

package/deps/couchbase-cxx-client/core/transactions/attempt_context.cxx

@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2021-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.
+ */
+
+#include <couchbase/scope.hxx>
+#include <couchbase/transactions/attempt_context.hxx>
+
+#include <fmt/core.h>
+
+namespace couchbase::transactions
+{
+std::pair<transaction_op_error_context, transaction_query_result>
+attempt_context::query(const scope& scope, const std::string& statement, const transaction_query_options& opts)
+{
+    return do_public_query(statement, opts, fmt::format("{}.{}", scope.bucket_name(), scope.name()));
+}
+
+std::pair<transaction_op_error_context, transaction_query_result>
+attempt_context::query(const std::string& statement, const transaction_query_options& options)
+{
+    return do_public_query(statement, options, {});
+}
+} // namespace couchbase::transactions