couchbase 3.8.1 → 3.9.0

data/ext/couchbase/core/impl/query_index_manager.cxx

@@ -84,7 +84,27 @@ public:
   watch_context(const watch_context&) = delete;
   auto operator=(const watch_context&) -> watch_context& = delete;
   auto operator=(watch_context&&) -> watch_context& = delete;
-  ~watch_context() = default;
+
+  ~watch_context()
+  {
+    // Fail closed. During the polling-interval backoff the context is kept alive only by its own
+    // timer on the io_context; if the io_context is torn down then, that pending wait is dropped
+    // without running and the context is destroyed here with handler_ still set. Deliver an error
+    // so a std::future caller never observes broken_promise and a callback caller never hangs. (The
+    // GET-ALL request phase already fails closed -- core_.execute delivers request_canceled on
+    // close.) A moved-from context has an empty handler_, so this is a no-op there. Mirror
+    // finish(): move the handler out before invoking it and end the observability span, so the
+    // watch metrics are not left dangling on shutdown.
+    if (handler_) {
+      watch_query_indexes_handler handler{};
+      std::swap(handler, handler_);
+      try {
+        observability_recorder_->finish(errc::network::cluster_closed);
+        handler(couchbase::error{ errc::network::cluster_closed });
+      } catch (...) { // NOLINT(bugprone-empty-catch)
+      }
+    }
+  }
 
   void execute()
   {
@@ -412,6 +432,39 @@ public:
                                     collection_name,
                                     options.parent_span);
 
+    // A closed cluster is the only thing origin() reports an error for, and it cannot be asked
+    // which transport it is on. Report it here rather than routing on a state that could not be
+    // read: the composite below would open a sub-operation span for a request it never sends.
+    const auto [origin_ec, origin] = core_.origin();
+    if (origin_ec) {
+      top_obs_rec->finish(origin_ec);
+      return handler(couchbase::error{ origin_ec });
+    }
+
+    // Over couchbase2 the gateway does server-side what the two round trips below do here:
+    // BuildDeferredIndexes takes the keyspace and builds every deferred index in it. RFC 77 lists
+    // it among the single operations rather than the composite ones -- only WatchIndexes is
+    // composite there -- so it is dispatched as one request and carries no sub-operation spans.
+    if (origin.uses_protostellar()) {
+      core::operations::management::query_index_build_deferred_request request{
+        bucket_name,
+        scope_name.empty() ? std::optional<std::string>{}
+                           : std::optional<std::string>{ scope_name },
+        collection_name.empty() ? std::optional<std::string>{}
+                                : std::optional<std::string>{ collection_name },
+        {},
+        {},
+        timeout,
+        top_obs_rec->operation_span(),
+      };
+      return core_.execute(
+        std::move(request),
+        [top_obs_rec = std::move(top_obs_rec), handler = std::move(handler)](const auto& resp) {
+          top_obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
+          handler(core::impl::make_error(resp.ctx));
+        });
+    }
+
     auto get_all_deferred_obs_rec = create_suboperation_observability_recorder(
       core::tracing::operation::mgr_query_get_all_deferred_indexes,
       bucket_name,

data/ext/couchbase/core/impl/replica_utils.cxx

@@ -18,10 +18,111 @@
 
 #include "replica_utils.hxx"
 
+#include "core/impl/error.hxx"
 #include "core/logger/logger.hxx"
 
+#include <couchbase/error_codes.hxx>
+
+#include <cstddef>
+#include <optional>
+#include <utility>
+
 namespace couchbase::core::impl
 {
+auto
+make_get_replica_error(const key_value_error_context& ctx) -> couchbase::error
+{
+  if (ctx.ec() != errc::key_value::document_not_found) {
+    return make_error(ctx);
+  }
+  auto cause = make_error(ctx);
+  auto error_context = cause.ctx();
+  return { errc::key_value::document_not_found_on_replica,
+           {},
+           std::move(error_context),
+           std::move(cause),
+           ctx.last_dispatched_to_node_id() };
+}
+
+auto
+resolve_replica_index(const topology::configuration& config,
+                      std::uint16_t vbucket,
+                      std::size_t requested_replica,
+                      bool wrap) -> replica_route_decision
+{
+  replica_route_decision decision{};
+  decision.partition = vbucket;
+
+  if (!config.vbmap.has_value() || vbucket >= config.vbmap->size()) {
+    return decision;
+  }
+
+  if (!config.num_replicas.has_value()) {
+    // The configured count and the map are parsed independently, so a map can
+    // arrive without a count. Bounds cannot be decided without it, and taking
+    // the row as the count would route to a copy the bucket may not advertise,
+    // so this is treated the same as a map that has not arrived.
+    return decision;
+  }
+
+  // num_replicas bounds the index; the vbucket-map row bounds what is readable.
+  // A rebalance reshapes the rows after the new count is published, so a row
+  // can be shorter than the count. Such an index is valid and not yet readable,
+  // so it is not out of bounds.
+  const auto number_of_replicas = std::size_t{ *config.num_replicas };
+  if (number_of_replicas == 0) {
+    // This also keeps the wrap modulo below from dividing by zero.
+    decision.ec = errc::key_value::replica_index_out_of_bounds;
+    return decision;
+  }
+
+  // The row carries the active at position 0, so replica N is at N + 1 and the
+  // chain is one shorter than the row.
+  const auto& chain = config.vbmap->at(vbucket);
+  const auto chain_length = chain.empty() ? 0 : chain.size() - 1;
+
+  const auto readable = [&](std::size_t replica) -> std::optional<std::size_t> {
+    if (replica >= chain_length) {
+      return {};
+    }
+    // A -1 entry and a node index the topology does not list mean the same
+    // thing here: nothing to send to.
+    if (const auto server = config.server_by_vbucket(vbucket, replica + 1);
+        server.has_value() && server.value() < config.nodes.size()) {
+      return server;
+    }
+    return {};
+  };
+
+  if (!wrap) {
+    if (requested_replica >= number_of_replicas) {
+      decision.ec = errc::key_value::replica_index_out_of_bounds;
+      return decision;
+    }
+    if (const auto server = readable(requested_replica); server.has_value()) {
+      decision.replica_position = requested_replica + 1;
+      decision.server_index = server;
+      return decision;
+    }
+    decision.ec = errc::key_value::replica_index_currently_unavailable;
+    return decision;
+  }
+
+  // wrap walks num_replicas, not the row, so an index past a short row still
+  // reaches the replicas the row does list.
+  const auto start = requested_replica % number_of_replicas;
+  for (std::size_t offset = 0; offset < number_of_replicas; ++offset) {
+    const auto replica = (start + offset) % number_of_replicas;
+    if (const auto server = readable(replica); server.has_value()) {
+      decision.replica_position = replica + 1;
+      decision.server_index = server;
+      return decision;
+    }
+  }
+
+  decision.ec = errc::key_value::replica_index_currently_unavailable;
+  return decision;
+}
 
 auto
 effective_nodes(const document_id& id,

data/ext/couchbase/core/impl/replica_utils.hxx

@@ -19,12 +19,18 @@
 #pragma once
 
 #include "core/document_id.hxx"
+#include "core/error_context/key_value_error_context.hxx"
 #include "core/topology/configuration.hxx"
 
+#include "couchbase/error.hxx"
 #include "couchbase/read_preference.hxx"
 
+#include <cstddef>
+#include <cstdint>
 #include <memory>
+#include <optional>
 #include <string>
+#include <system_error>
 #include <vector>
 
 namespace couchbase::core::impl
@@ -34,6 +40,64 @@ struct readable_node {
   std::size_t index;
 };
 
+/**
+ * What a targeted replica read asks of the routing. Translated out of the
+ * public strategy, so core does not depend on a public options header.
+ */
+struct replica_selection {
+  std::size_t replica_index{};
+  bool wrap{};
+};
+
+/**
+ * Where a replica read should be sent, or why it cannot be sent at all.
+ *
+ * Exactly one of three states:
+ *
+ * - @c ec set: terminal, and completes the operation.
+ * - @c ec clear and @c server_index unset: the current topology cannot route
+ *   the request, so the caller takes its retry path.
+ * - @c server_index set: the node to dispatch to.
+ */
+struct replica_route_decision {
+  std::error_code ec{};
+  std::uint16_t partition{};
+  std::size_t replica_position{};
+  std::optional<std::size_t> server_index{};
+};
+
+/**
+ * Resolves a replica index, as the user requested it, against a vbucket map
+ * row.
+ *
+ * num_replicas bounds the index; the row bounds what is readable. A rebalance
+ * reshapes the rows after a new count is published, so the two can disagree.
+ *
+ * @param config current topology
+ * @param vbucket the vbucket the document belongs to
+ * @param requested_replica zero-based replica index, where 0 is the first
+ * replica and the active copy cannot be selected
+ * @param wrap walk on from an index that cannot be read to the next one that
+ * can, instead of failing
+ */
+auto
+resolve_replica_index(const topology::configuration& config,
+                      std::uint16_t vbucket,
+                      std::size_t requested_replica,
+                      bool wrap) -> replica_route_decision;
+
+/**
+ * Builds the error a replica read completes with.
+ *
+ * A document missing from the replica is reported as
+ * @ref errc::key_value::document_not_found_on_replica, with
+ * @ref errc::key_value::document_not_found as its cause so that a caller can
+ * opt into the general condition by reading the cause. Every other code is
+ * reported as it is.
+ */
+auto
+make_get_replica_error(const key_value_error_context& ctx) -> couchbase::error;
+
 /**
  * Returns list of server indexes to send operations. The index values are
  * in range [0, number_of_replicas).

data/ext/couchbase/core/impl/resolve_node_id.hxx

@@ -0,0 +1,125 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026-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/topology/configuration.hxx"
+
+#include <couchbase/error_codes.hxx>
+#include <couchbase/node_id.hxx>
+
+#include <memory>
+#include <string>
+#include <system_error>
+#include <utility>
+#include <vector>
+
+namespace couchbase::core::impl
+{
+/**
+ * Pure helper that resolves a document key to the owning node's identity
+ * against a topology snapshot. Extracted out of @c collection_impl::node_id_for
+ * so the error-mapping branches (no config, no vbmap, out-of-range
+ * server_index, success) can be unit-tested without an io_context or a live
+ * cluster.
+ *
+ * @param config        bucket configuration snapshot (may be null)
+ * @param document_key  document key to map; empty input is reported as
+ *                      @c errc::common::invalid_argument
+ * @param t             which port pair (plain/TLS) to use when deriving the
+ *                      node identity
+ * @return pair of (error_code, node_id). On success the @c error_code is
+ *         default and the @c node_id is truthy; on failure the @c node_id
+ *         is default-constructed (falsy).
+ */
+[[nodiscard]] inline auto
+resolve_node_id_from_config(const std::shared_ptr<topology::configuration>& config,
+                            const std::string& document_key,
+                            topology::transport t) -> std::pair<std::error_code, couchbase::node_id>
+{
+  if (document_key.empty()) {
+    return { errc::common::invalid_argument, {} };
+  }
+  if (!config || !config->vbmap.has_value() || config->vbmap->empty()) {
+    return { errc::network::configuration_not_available, {} };
+  }
+  // Only the server_index half of the mapping is needed here; the vbucket id
+  // is intentionally discarded (avoids an unused structured-binding name).
+  const auto server_index = config->map_key(document_key, 0).second;
+  if (!server_index.has_value() || server_index.value() >= config->nodes.size()) {
+    // An unresolvable server_index means the vBucket map is present but does
+    // not map this key to a known node (out-of-range or missing entry).
+    // Surface this as configuration_not_available rather than
+    // request_canceled so callers can distinguish an unusable map from an
+    // actual caller-initiated cancellation.
+    return { errc::network::configuration_not_available, {} };
+  }
+  auto resolved = config->nodes[server_index.value()].effective_node_id(t);
+  if (!resolved) {
+    // The node maps to the key but carries no identity for the selected
+    // transport (e.g. no KV port for that port pair). Returning success here
+    // would violate the contract that a non-error result is always truthy,
+    // so report it as an unusable configuration instead.
+    return { errc::network::configuration_not_available, {} };
+  }
+  // Type the first element explicitly so the pair's perfect-forwarding
+  // constructor is selected and `resolved` is genuinely moved (a leading `{}`
+  // would bind the const-reference constructor instead, defeating the move).
+  return { std::error_code{}, std::move(resolved) };
+}
+
+/**
+ * Pure helper that enumerates the KV-serving nodes of a bucket configuration
+ * snapshot. Extracted out of @c collection_impl::node_ids so the
+ * error-mapping branches (no config, empty KV-serving set, success) can be
+ * unit-tested without an io_context or a live cluster — and so the branch
+ * matches the contract of the sibling resolver above:
+ *
+ * - A missing/null config snapshot is reported as
+ *   @c errc::network::configuration_not_available (it must not be a silent
+ *   empty success: the caller cannot distinguish "the cluster has zero KV
+ *   nodes" from "we don't know the topology yet").
+ * - An empty effective-node-ids set is reported the same way; this is the
+ *   mid-rebalance transient that the original commit silently surfaced as
+ *   a successful empty vector.
+ *
+ * @param config  bucket configuration snapshot (may be null)
+ * @param t       which port pair (plain/TLS) to use when deriving identity
+ * @return pair of (error_code, vector<node_id>). On success the @c
+ *         error_code is default and the vector is non-empty; on failure the
+ *         vector is empty.
+ */
+[[nodiscard]] inline auto
+resolve_node_ids_from_config(const std::shared_ptr<topology::configuration>& config,
+                             topology::transport t)
+  -> std::pair<std::error_code, std::vector<couchbase::node_id>>
+{
+  if (!config) {
+    return { errc::network::configuration_not_available, {} };
+  }
+  auto nids = config->effective_node_ids(t);
+  if (nids.empty()) {
+    // Tighter than the original "return {}" — a momentarily-empty
+    // topology (e.g. mid-rebalance) is reported as unavailable rather
+    // than as a successful empty list, so registry-sweep loops keyed on
+    // node_id don't conclude the cluster has zero KV-serving nodes and
+    // discard every entry.
+    return { errc::network::configuration_not_available, {} };
+  }
+  return { {}, std::move(nids) };
+}
+} // namespace couchbase::core::impl

data/ext/couchbase/core/impl/scope.cxx

@@ -92,6 +92,22 @@ public:
       });
   }
 
+  void query_stream(std::string statement,
+                    query_options::built options,
+                    query_stream_handler&& handler) const
+  {
+    // Instrument the streaming operation exactly like the buffered scope query() above: build the
+    // recorder, thread its operation span into the request, and hand the recorder to the stream so
+    // it finishes at the terminal.
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::query, core::service_type::query, options.parent_span);
+    obs_rec->with_query_statement(statement, options);
+    auto request = core::impl::build_query_request(
+      std::move(statement), query_context_, std::move(options), obs_rec->operation_span());
+    core::impl::dispatch_query_stream(
+      core_, std::move(request), std::move(obs_rec), std::move(handler));
+  }
+
   void analytics_query(std::string statement,
                        analytics_options::built options,
                        analytics_handler&& handler) const
@@ -111,6 +127,20 @@ public:
       });
   }
 
+  void analytics_query_stream(std::string statement,
+                              analytics_options::built options,
+                              analytics_stream_handler&& handler) const
+  {
+    // Instrument the streaming operation exactly like the buffered scope analytics_query() above.
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::analytics, core::service_type::analytics, options.parent_span);
+    obs_rec->with_query_statement(statement, options);
+    auto request = core::impl::build_analytics_request(
+      std::move(statement), std::move(options), bucket_name_, name_, obs_rec->operation_span());
+    core::impl::dispatch_analytics_stream(
+      core_, std::move(request), std::move(obs_rec), std::move(handler));
+  }
+
   void search(std::string index_name,
               couchbase::search_request request,
               search_options::built options,
@@ -205,6 +235,26 @@ scope::query(std::string statement, const query_options& options) const
   return future;
 }
 
+void
+scope::query_stream(std::string statement,
+                    const query_options& options,
+                    query_stream_handler&& handler) const
+{
+  return impl_->query_stream(std::move(statement), options.build(), std::move(handler));
+}
+
+auto
+scope::query_stream(std::string statement, const query_options& options) const
+  -> std::future<std::pair<error, query_stream_result>>
+{
+  auto barrier = std::make_shared<std::promise<std::pair<error, query_stream_result>>>();
+  auto future = barrier->get_future();
+  query_stream(std::move(statement), options, [barrier](auto err, auto result) {
+    barrier->set_value({ std::move(err), std::move(result) });
+  });
+  return future;
+}
+
 void
 scope::analytics_query(std::string statement,
                        const analytics_options& options,
@@ -225,6 +275,26 @@ scope::analytics_query(std::string statement, const analytics_options& options)
   return future;
 }
 
+void
+scope::analytics_query_stream(std::string statement,
+                              const analytics_options& options,
+                              analytics_stream_handler&& handler) const
+{
+  return impl_->analytics_query_stream(std::move(statement), options.build(), std::move(handler));
+}
+
+auto
+scope::analytics_query_stream(std::string statement, const analytics_options& options) const
+  -> std::future<std::pair<error, analytics_stream_result>>
+{
+  auto barrier = std::make_shared<std::promise<std::pair<error, analytics_stream_result>>>();
+  auto future = barrier->get_future();
+  analytics_query_stream(std::move(statement), options, [barrier](auto err, auto result) {
+    barrier->set_value({ std::move(err), std::move(result) });
+  });
+  return future;
+}
+
 void
 scope::search(std::string index_name,
               search_request request,

data/ext/couchbase/core/impl/search.cxx

@@ -17,6 +17,7 @@
 
 #include "core/cluster.hxx"
 #include "core/operations/document_search.hxx"
+#include "core/search_scoring.hxx"
 #include "core/utils/json.hxx"
 #include "encoded_search_facet.hxx"
 #include "encoded_search_query.hxx"
@@ -100,7 +101,7 @@ map_facets(const std::map<std::string, std::shared_ptr<search_facet>, std::less<
 }
 
 auto
-map_raw(std::map<std::string, codec::binary, std::less<>>& raw)
+map_raw(const std::map<std::string, codec::binary, std::less<>>& raw)
   -> std::map<std::string, couchbase::core::json_string>
 {
   std::map<std::string, couchbase::core::json_string> core_raw{};
@@ -125,6 +126,33 @@ map_vector_query_combination(const std::optional<couchbase::vector_query_combina
   return {};
 }
 
+auto
+map_scoring(const search_scoring::built& scoring) -> core::search_scoring_mode
+{
+  return std::visit(
+    [](const auto& mode) -> core::search_scoring_mode {
+      using T = std::decay_t<decltype(mode)>;
+      if constexpr (std::is_same_v<T, search_scoring::built::none>) {
+        return core::search_scoring_none{};
+      } else if constexpr (std::is_same_v<T, search_scoring::built::reciprocal_rank_fusion>) {
+        return core::search_scoring_reciprocal_rank_fusion{ mode.rank_constant, mode.window_size };
+      } else if constexpr (std::is_same_v<T, search_scoring::built::relative_score_fusion>) {
+        return core::search_scoring_relative_score_fusion{ mode.window_size };
+      }
+    },
+    scoring.mode);
+}
+
+void
+apply_scoring(core::operations::search_request& request,
+              const std::optional<search_scoring::built>& scoring)
+{
+  if (!scoring.has_value()) {
+    return;
+  }
+  request.scoring = map_scoring(scoring.value());
+}
+
 } // namespace
 
 auto
@@ -168,6 +196,7 @@ build_search_request(std::string index_name,
     options.timeout,
   };
   request.parent_span = std::move(op_span);
+  apply_scoring(request, options.scoring);
   return request;
 }
 
@@ -213,6 +242,7 @@ build_search_request(std::string index_name,
     options.timeout,
   };
   core_request.parent_span = std::move(op_span);
+  apply_scoring(core_request, options.scoring);
 
   if (auto vector_search = request.vector_search(); vector_search.has_value()) {
     core_request.vector_search = core::utils::json::generate_binary(vector_search->query);

data/ext/couchbase/core/impl/transactions.cxx

@@ -0,0 +1,130 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026-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/cluster.hxx>
+#include <couchbase/transactions.hxx>
+
+#include "core/impl/error.hxx"
+#include "core/transactions.hxx"
+#include "core/transactions/attempt_context_impl.hxx"
+#include "core/transactions/exceptions.hxx"
+
+#include <spdlog/fmt/bundled/format.h>
+
+#include <couchbase/fmt/error.hxx>
+
+namespace couchbase::transactions
+{
+void
+maybe_throw(error err)
+{
+  if (err && err.ec() != errc::transaction_op::transaction_op_failed) {
+    // We intentionally don't handle transaction_op_failed here, as we must have cached the
+    // transaction error internally already, which has the full context with the right error class
+    // etc.
+    if (err.ec().category() == core::impl::transaction_op_category()) {
+      throw core::transactions::op_exception(std::move(err));
+    }
+    throw std::system_error(err.ec(), fmt::format("{}", err));
+  }
+}
+
+class transactions_impl
+{
+public:
+  explicit transactions_impl(std::shared_ptr<core::transactions::transactions> core_txns)
+    : core_txns_{ std::move(core_txns) }
+  {
+  }
+
+  auto run(txn_logic&& logic, const transaction_options& options) const
+    -> std::pair<error, transaction_result>
+  {
+    try {
+      auto res = core_txns_->run(options, [logic = std::move(logic)](auto ctx) mutable {
+        const auto err =
+          logic(std::static_pointer_cast<core::transactions::attempt_context_impl>(ctx));
+        maybe_throw(std::move(err));
+      });
+      return { {}, res };
+    } catch (const core::transactions::transaction_exception& e) {
+      auto [err_ctx, res_from_exc] = e.get_transaction_result();
+      return std::make_pair(core::impl::make_error(err_ctx), std::move(res_from_exc));
+    }
+  }
+
+  void run(async_txn_logic&& logic,
+           async_txn_complete_logic&& callback,
+           const transaction_options& options) const
+  {
+    core_txns_->run(
+      options,
+      [logic = std::move(logic)](auto ctx) mutable {
+        auto err = logic(std::static_pointer_cast<core::transactions::attempt_context_impl>(ctx));
+        maybe_throw(std::move(err));
+      },
+      [callback = std::move(callback)](auto exc, auto res) mutable {
+        if (exc.has_value()) {
+          auto [err_ctx, res_from_exc] = exc.value().get_transaction_result();
+          return callback(core::impl::make_error(err_ctx), std::move(res_from_exc));
+        }
+        return callback({}, std::move(res.value()));
+      });
+  }
+
+  [[nodiscard]] auto core() const -> std::shared_ptr<core::transactions::transactions>
+  {
+    return core_txns_;
+  }
+
+private:
+  std::shared_ptr<core::transactions::transactions> core_txns_;
+};
+
+transactions::transactions(std::shared_ptr<core::transactions::transactions> core_txns)
+  : impl_{ std::make_shared<transactions_impl>(std::move(core_txns)) }
+{
+}
+
+auto
+transactions::run(txn_logic&& logic, const transaction_options& cfg)
+  -> std::pair<error, transaction_result>
+{
+  return impl_->run(std::move(logic), cfg);
+}
+
+void
+transactions::run(async_txn_logic&& logic,
+                  async_txn_complete_logic&& complete_callback,
+                  const transaction_options& cfg)
+{
+  return impl_->run(std::move(logic), std::move(complete_callback), cfg);
+}
+} // namespace couchbase::transactions
+
+namespace couchbase::core::transactions
+{
+auto
+get_core_transactions(const std::shared_ptr<couchbase::transactions::transactions>& transactions)
+  -> std::shared_ptr<core::transactions::transactions>
+{
+  return reinterpret_cast<const std::shared_ptr<couchbase::transactions::transactions_impl>*>(
+           transactions.get())
+    ->get()
+    ->core();
+}
+} // namespace couchbase::core::transactions