couchbase 3.6.0 → 3.7.0

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

@@ -0,0 +1,182 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/scan_result.hxx>
+#include <couchbase/scan_result_item.hxx>
+
+#include "core/range_scan_options.hxx"
+#include "core/scan_result.hxx"
+
+#include "internal_scan_result.hxx"
+
+#include <future>
+#include <memory>
+#include <optional>
+#include <system_error>
+#include <utility>
+
+namespace couchbase
+{
+namespace
+{
+auto
+to_scan_result_item(core::range_scan_item core_item,
+                    const std::shared_ptr<crypto::manager>& crypto_manager) -> scan_result_item
+{
+  if (!core_item.body) {
+    return scan_result_item{ std::move(core_item.key) };
+  }
+  return scan_result_item{
+    std::move(core_item.key),
+    core_item.body.value().cas,
+    codec::encoded_value{ std::move(core_item.body.value().value), core_item.body.value().flags },
+    core_item.body.value().expiry_time(),
+    crypto_manager,
+  };
+}
+} // namespace
+
+internal_scan_result::internal_scan_result(core::scan_result core_result,
+                                           std::shared_ptr<crypto::manager> crypto_manager)
+  : core_result_{ std::move(core_result) }
+  , crypto_manager_{ std::move(crypto_manager) }
+{
+}
+
+void
+internal_scan_result::next(scan_item_handler&& handler)
+{
+  return core_result_.next([&crypto_manager = crypto_manager_, handler = std::move(handler)](
+                             core::range_scan_item item, std::error_code ec) mutable {
+    if (ec == couchbase::errc::key_value::range_scan_completed) {
+      return handler({}, {});
+    }
+    if (ec) {
+      return handler(error(ec, "Error getting the next scan result item."), {});
+    }
+    handler({}, to_scan_result_item(std::move(item), crypto_manager));
+  });
+}
+
+void
+internal_scan_result::cancel()
+{
+  return core_result_.cancel();
+}
+
+internal_scan_result::~internal_scan_result()
+{
+  cancel();
+}
+
+scan_result::scan_result(std::shared_ptr<couchbase::internal_scan_result> internal)
+  : internal_{ std::move(internal) }
+{
+}
+
+void
+scan_result::next(couchbase::scan_item_handler&& handler) const
+{
+  return internal_->next(std::move(handler));
+}
+
+auto
+scan_result::next() const -> std::future<std::pair<error, std::optional<scan_result_item>>>
+{
+  auto barrier =
+    std::make_shared<std::promise<std::pair<error, std::optional<scan_result_item>>>>();
+  internal_->next([barrier](const auto& err, const auto& item) mutable {
+    barrier->set_value({ err, item });
+  });
+  return barrier->get_future();
+}
+
+void
+scan_result::cancel()
+{
+  if (internal_) {
+    return internal_->cancel();
+  }
+}
+
+auto
+scan_result::begin() -> scan_result::iterator
+{
+  return scan_result::iterator(internal_);
+}
+
+auto
+scan_result::end() -> scan_result::iterator
+{
+  return scan_result::iterator({ error(errc::key_value::range_scan_completed), {} });
+}
+
+scan_result::iterator::iterator(std::shared_ptr<internal_scan_result> internal)
+  : internal_{ std::move(internal) }
+{
+  fetch_item();
+}
+
+scan_result::iterator::iterator(std::pair<error, scan_result_item> item)
+  : item_{ std::move(item) }
+{
+}
+
+void
+scan_result::iterator::fetch_item()
+{
+  auto barrier = std::make_shared<std::promise<std::pair<error, scan_result_item>>>();
+  internal_->next([barrier](const error& err, std::optional<scan_result_item> item) mutable {
+    if (err) {
+      return barrier->set_value({ err, {} });
+    }
+    if (!item.has_value()) {
+      return barrier->set_value({ error(errc::key_value::range_scan_completed), {} });
+    }
+    barrier->set_value({ {}, item.value() });
+  });
+  auto f = barrier->get_future();
+  item_ = f.get();
+}
+
+auto
+scan_result::iterator::operator*() -> std::pair<error, scan_result_item>
+{
+  return item_;
+}
+
+auto
+scan_result::iterator::operator++() -> scan_result::iterator&
+{
+  fetch_item();
+  return *this;
+}
+
+auto
+scan_result::iterator::operator==(const couchbase::scan_result::iterator& other) const -> bool
+{
+  return item_ == other.item_;
+}
+
+auto
+scan_result::iterator::operator!=(const couchbase::scan_result::iterator& other) const -> bool
+{
+  return item_ != other.item_;
+}
+} // namespace couchbase

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

@@ -41,11 +41,15 @@ namespace couchbase
 class scope_impl
 {
 public:
-  scope_impl(core::cluster core, std::string_view bucket_name, std::string_view name)
+  scope_impl(core::cluster core,
+             std::string_view bucket_name,
+             std::string_view name,
+             std::shared_ptr<crypto::manager> crypto_manager)
     : core_{ std::move(core) }
     , bucket_name_{ bucket_name }
     , name_{ name }
     , query_context_{ fmt::format("default:`{}`.`{}`", bucket_name_, name_) }
+    , crypto_manager_{ std::move(crypto_manager) }
   {
   }
 
@@ -64,6 +68,11 @@ public:
     return core_;
   }
 
+  [[nodiscard]] auto crypto_manager() const -> const std::shared_ptr<crypto::manager>&
+  {
+    return crypto_manager_;
+  }
+
   void query(std::string statement, query_options::built options, query_handler&& handler) const
   {
     return core_.execute(
@@ -104,10 +113,15 @@ private:
   std::string bucket_name_;
   std::string name_;
   std::string query_context_;
+  std::shared_ptr<crypto::manager> crypto_manager_;
 };
 
-scope::scope(core::cluster core, std::string_view bucket_name, std::string_view name)
-  : impl_(std::make_shared<scope_impl>(std::move(core), bucket_name, name))
+scope::scope(core::cluster core,
+             std::string_view bucket_name,
+             std::string_view name,
+             std::shared_ptr<crypto::manager> crypto_manager)
+  : impl_(
+      std::make_shared<scope_impl>(std::move(core), bucket_name, name, std::move(crypto_manager)))
 {
 }
 
@@ -126,7 +140,9 @@ scope::name() const -> const std::string&
 auto
 scope::collection(std::string_view collection_name) const -> couchbase::collection
 {
-  return { impl_->core(), impl_->bucket_name(), impl_->name(), collection_name };
+  return {
+    impl_->core(), impl_->bucket_name(), impl_->name(), collection_name, impl_->crypto_manager()
+  };
 }
 
 void

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

@@ -26,6 +26,14 @@ vector_query::encode() const -> encoded_search_query
 {
   encoded_search_query built;
   built.query = tao::json::empty_object;
+  if (prefilter_) {
+    auto [ec, encoded_prefilter] = prefilter_->encode();
+    if (ec) {
+      built.ec = ec;
+      return built;
+    }
+    built.query["filter"] = encoded_prefilter;
+  }
   if (boost_) {
     built.query["boost"] = boost_.value();
   }

data/ext/couchbase/core/io/config_tracker.cxx

@@ -449,9 +449,9 @@ private:
       if (!should_update_config(config)) {
         return;
       }
-      if (config_) {
-        diff_nodes(config_->nodes, config.nodes, added);
-        diff_nodes(config.nodes, config_->nodes, removed);
+      if (auto current_config = config_; current_config) {
+        diff_nodes(current_config->nodes, config.nodes, added);
+        diff_nodes(config.nodes, current_config->nodes, removed);
       } else {
         added = config.nodes;
       }
@@ -474,12 +474,14 @@ private:
   void restart_sessions()
   {
     const std::scoped_lock lock(config_mutex_, sessions_mutex_);
-    if (!config_.has_value()) {
+
+    std::optional<topology::configuration> current_config = config_;
+    if (!current_config.has_value()) {
       return;
     }
 
-    for (std::size_t index = 0; index < config_->nodes.size(); ++index) {
-      const auto& node = config_->nodes[index];
+    for (std::size_t index = 0; index < current_config->nodes.size(); ++index) {
+      const auto& node = current_config->nodes[index];
 
       const auto& hostname = node.hostname_for(origin_.options().network);
       auto port = node.port_or(
@@ -504,7 +506,7 @@ private:
           : io::mcbp_session(client_id_, node.node_uuid, ctx_, origin, state_listener_);
       CB_LOG_DEBUG(R"({} rev={}, restart cluster session="{}", address="{}:{}")",
                    log_prefix_,
-                   config_->rev_str(),
+                   current_config->rev_str(),
                    session.id(),
                    hostname,
                    port);

data/ext/couchbase/core/io/http_session.cxx

@@ -61,9 +61,10 @@ http_session_info::http_session_info(const std::string& client_id,
       fmt::format("{}:{}", remote_endpoint_address_, remote_endpoint_.port());
   }
 
-  log_prefix_ = fmt::format("[{}/{}] <{}:{}>",
+  log_prefix_ = fmt::format("[{}/{}] <{}:{}:{}>",
                             client_id,
                             session_id,
+                            local_endpoint_.port(),
                             remote_endpoint_.address().to_string(),
                             remote_endpoint_.port());
 }

data/ext/couchbase/core/io/http_session_manager.hxx

@@ -114,8 +114,11 @@ public:
   void update_config(topology::configuration config) override
   {
     {
-      std::scoped_lock config_lock(config_mutex_, sessions_mutex_);
+      std::scoped_lock config_lock(config_mutex_, sessions_mutex_, next_index_mutex_);
       config_ = std::move(config);
+      if (!config_.nodes.empty() && next_index_ >= config_.nodes.size()) {
+        next_index_ = 0;
+      }
       for (auto& [type, sessions] : idle_sessions_) {
         sessions.remove_if([&opts = options_, &cfg = config_](const auto& session) {
           return session && !cfg.has_node(opts.network,

data/ext/couchbase/core/io/mcbp_session.cxx

@@ -60,7 +60,9 @@
 #include <couchbase/fmt/retry_reason.hxx>
 
 #include <asio.hpp>
+#include <asio/ssl/error.hpp>
 #include <spdlog/fmt/bin_to_hex.h>
+#include <spdlog/fmt/chrono.h>
 
 #include <cstring>
 #include <utility>
@@ -876,6 +878,7 @@ public:
     , resolver_(ctx_)
     , stream_(std::make_unique<plain_stream_impl>(ctx_))
     , bootstrap_deadline_(ctx_)
+    , resolve_deadline_(ctx_)
     , connection_deadline_(ctx_)
     , retry_backoff_(ctx_)
     , ping_timeout_(ctx_)
@@ -904,6 +907,7 @@ public:
     , resolver_(ctx_)
     , stream_(std::make_unique<tls_stream_impl>(ctx_, tls))
     , bootstrap_deadline_(ctx_)
+    , resolve_deadline_(ctx_)
     , connection_deadline_(ctx_)
     , retry_backoff_(ctx_)
     , ping_timeout_(ctx_)
@@ -1030,61 +1034,67 @@ public:
     retry_bootstrap_on_bucket_not_found_ = retry_on_bucket_not_found;
     bootstrap_callback_ = std::move(callback);
     bootstrap_deadline_.expires_after(origin_.options().bootstrap_timeout);
-    bootstrap_deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
-      if (ec == asio::error::operation_aborted || self->stopped_) {
-        return;
-      }
-      if (self->state_listener_) {
-        self->state_listener_->report_bootstrap_error(
-          fmt::format("{}:{}", self->bootstrap_hostname_, self->bootstrap_port_), ec);
-      }
+    bootstrap_deadline_.async_wait(
+      [self = shared_from_this(),
+       bootstrap_timeout = origin_.options().bootstrap_timeout](std::error_code ec) {
+        if (ec == asio::error::operation_aborted || self->stopped_) {
+          return;
+        }
+        if (self->state_listener_) {
+          self->state_listener_->report_bootstrap_error(
+            fmt::format("{}:{}", self->bootstrap_hostname_, self->bootstrap_port_), ec);
+        }
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-      // an existing background bootstrap listener means we want to infinitely
-      // attempt to connect.
-      if (self->background_bootstrap_listener_) {
-        if (self->last_bootstrap_error_.has_value()) {
-          self->background_bootstrap_listener_->notify_bootstrap_error(
-            self->last_bootstrap_error_.value());
+        // an existing background bootstrap listener means we want to infinitely
+        // attempt to connect.
+        if (self->background_bootstrap_listener_) {
+          if (self->last_bootstrap_error_.has_value()) {
+            self->background_bootstrap_listener_->notify_bootstrap_error(
+              self->last_bootstrap_error_.value());
+          } else {
+            self->background_bootstrap_listener_->notify_bootstrap_error(
+              { make_error_code(errc::common::unambiguous_timeout),
+                "Unable to connect in time.",
+                self->bootstrap_hostname_,
+                self->bootstrap_port_ });
+          }
+          auto backoff = std::chrono::milliseconds(500);
+          CB_LOG_DEBUG("{} unable to connect in time, waiting for {}ms before retry",
+                       self->log_prefix_,
+                       backoff.count());
+          self->retry_backoff_.expires_after(backoff);
+          self->retry_backoff_.async_wait([self](std::error_code ec) mutable {
+            if (ec == asio::error::operation_aborted || self->stopped_) {
+              return;
+            }
+            self->origin_.restart();
+            self->initiate_bootstrap();
+          });
         } else {
-          self->background_bootstrap_listener_->notify_bootstrap_error(
-            { make_error_code(errc::common::unambiguous_timeout),
-              "Unable to connect in time.",
-              self->bootstrap_hostname_,
-              self->bootstrap_port_ });
-        }
-        auto backoff = std::chrono::milliseconds(500);
-        CB_LOG_DEBUG("{} unable to connect in time, waiting for {}ms before retry",
-                     self->log_prefix_,
-                     backoff.count());
-        self->retry_backoff_.expires_after(backoff);
-        self->retry_backoff_.async_wait([self](std::error_code ec) mutable {
-          if (ec == asio::error::operation_aborted || self->stopped_) {
-            return;
+          if (!ec) {
+            ec = errc::common::unambiguous_timeout;
           }
-          self->origin_.restart();
-          self->initiate_bootstrap();
-        });
-      } else {
+          CB_LOG_WARNING("{} unable to bootstrap in time, bootstrap_timeout: {}",
+                         self->log_prefix_,
+                         bootstrap_timeout);
+          if (auto h = std::move(self->bootstrap_callback_); h) {
+            h(ec, {});
+          }
+          self->stop(retry_reason::do_not_retry);
+        }
+#else
         if (!ec) {
           ec = errc::common::unambiguous_timeout;
         }
-        CB_LOG_WARNING("{} unable to bootstrap in time", self->log_prefix_);
+        CB_LOG_WARNING("{} unable to bootstrap in time, bootstrap_timeout: {}",
+                       self->log_prefix_,
+                       bootstrap_timeout);
         if (auto h = std::move(self->bootstrap_callback_); h) {
           h(ec, {});
         }
         self->stop(retry_reason::do_not_retry);
-      }
-#else
-      if (!ec) {
-        ec = errc::common::unambiguous_timeout;
-      }
-      CB_LOG_WARNING("{} unable to bootstrap in time", self->log_prefix_);
-      if (auto h = std::move(self->bootstrap_callback_); h) {
-        h(ec, {});
-      }
-      self->stop(retry_reason::do_not_retry);
 #endif
-    });
+      });
     initiate_bootstrap();
   }
 
@@ -1149,13 +1159,19 @@ public:
                               bootstrap_address_);
     CB_LOG_DEBUG("{} attempt to establish MCBP connection", log_prefix_);
 
+    resolve_deadline_.expires_after(origin_.options().resolve_timeout);
+    resolve_deadline_.async_wait([self = shared_from_this()](const auto ec) {
+      if (ec == asio::error::operation_aborted || self->stopped_) {
+        return;
+      }
+      self->initiate_bootstrap();
+    });
     async_resolve(origin_.options().use_ip_protocol,
                   resolver_,
                   bootstrap_hostname_,
                   bootstrap_port_,
-                  [capture0 = shared_from_this()](auto&& PH1, auto&& PH2) {
-                    capture0->on_resolve(std::forward<decltype(PH1)>(PH1),
-                                         std::forward<decltype(PH2)>(PH2));
+                  [self = shared_from_this()](auto ec, auto& endpoints) {
+                    self->on_resolve(ec, endpoints);
                   });
   }
 
@@ -1207,6 +1223,7 @@ public:
     CB_LOG_DEBUG("{} stop MCBP connection, reason={}", log_prefix_, reason);
     stopped_ = true;
     bootstrap_deadline_.cancel();
+    resolve_deadline_.cancel();
     connection_deadline_.cancel();
     retry_backoff_.cancel();
     ping_timeout_.cancel();
@@ -1748,12 +1765,12 @@ private:
     }
   }
 
-  void on_resolve(std::error_code ec, const asio::ip::tcp::resolver::results_type& endpoints)
+  void on_resolve(const std::error_code& ec, const asio::ip::tcp::resolver::results_type& endpoints)
   {
     if (ec == asio::error::operation_aborted || stopped_) {
       return;
     }
-    connection_deadline_.cancel();
+    resolve_deadline_.cancel();
     last_active_ = std::chrono::steady_clock::now();
     if (ec) {
       CB_LOG_ERROR("{} error on resolve: {} ({})", log_prefix_, ec.value(), ec.message());
@@ -1767,13 +1784,6 @@ private:
                  bootstrap_port_,
                  endpoints_.size());
     do_connect(endpoints_.begin());
-    connection_deadline_.expires_after(origin_.options().resolve_timeout);
-    connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
-      if (timer_ec == asio::error::operation_aborted || self->stopped_) {
-        return;
-      }
-      self->initiate_bootstrap();
-    });
   }
 
   void do_connect(const asio::ip::tcp::resolver::results_type::iterator& it)
@@ -1872,15 +1882,17 @@ private:
     } else {
       stream_->set_options();
       connection_endpoints_ = { it->endpoint(), stream_->local_endpoint() };
-      CB_LOG_DEBUG("{} connected to {}:{}",
+      CB_LOG_DEBUG("{} connected to {}:{}:{}",
                    log_prefix_,
+                   connection_endpoints_.local.port(),
                    connection_endpoints_.remote_address,
                    connection_endpoints_.remote.port());
-      log_prefix_ = fmt::format("[{}/{}/{}/{}] <{}/{}:{}>",
+      log_prefix_ = fmt::format("[{}/{}/{}/{}] <{}:{}/{}:{}>",
                                 client_id_,
                                 id_,
                                 stream_->log_prefix(),
                                 bucket_name_.value_or("-"),
+                                connection_endpoints_.local.port(),
                                 bootstrap_hostname_,
                                 connection_endpoints_.remote_address,
                                 connection_endpoints_.remote.port());
@@ -1896,12 +1908,14 @@ private:
         if (timer_ec == asio::error::operation_aborted || self->stopped_) {
           return;
         }
-        CB_LOG_DEBUG("{} unable to boostrap single node at {}:{} (\"{}:{}\") in time, reconnecting",
-                     self->log_prefix_,
-                     self->connection_endpoints_.remote_address,
-                     self->connection_endpoints_.remote.port(),
-                     self->bootstrap_hostname_,
-                     self->bootstrap_port_);
+        CB_LOG_DEBUG(
+          "{} unable to boostrap single node at {}:{}:{} (\"{}:{}\") in time, reconnecting",
+          self->log_prefix_,
+          self->connection_endpoints_.local.port(),
+          self->connection_endpoints_.remote_address,
+          self->connection_endpoints_.remote.port(),
+          self->bootstrap_hostname_,
+          self->bootstrap_port_);
         return self->initiate_bootstrap();
       });
     }
@@ -1919,15 +1933,17 @@ private:
                                                              std::size_t bytes_transferred) {
         if (ec == asio::error::operation_aborted || self->stopped_) {
           self->reading_ = false;
-          CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", port={}, rc={}, bytes_received={}",
+          CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", sport={}, dport={}, rc={}, bytes_received={}",
                           self->connection_endpoints_.remote_address,
+                          self->connection_endpoints_.local.port(),
                           self->connection_endpoints_.remote.port(),
                           ec ? ec.message() : "ok",
                           bytes_transferred);
           return;
         }
-        CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", port={}, rc={}, bytes_received={}{:a}",
+        CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", sport={}, dport={}, rc={}, bytes_received={}{:a}",
                         self->connection_endpoints_.remote_address,
+                        self->connection_endpoints_.local.port(),
                         self->connection_endpoints_.remote.port(),
                         ec ? ec.message() : "ok",
                         bytes_transferred,
@@ -2003,8 +2019,9 @@ private:
     std::vector<asio::const_buffer> buffers;
     buffers.reserve(writing_buffer_.size());
     for (auto& buf : writing_buffer_) {
-      CB_LOG_PROTOCOL("[MCBP, OUT] host=\"{}\", port={}, buffer_size={}{:a}",
+      CB_LOG_PROTOCOL("[MCBP, OUT] host=\"{}\", sport={}, dport={}, buffer_size={}{:a}",
                       connection_endpoints_.remote_address,
+                      connection_endpoints_.local.port(),
                       connection_endpoints_.remote.port(),
                       buf.size(),
                       spdlog::to_hex(buf));
@@ -2012,8 +2029,9 @@ private:
     }
     stream_->async_write(
       buffers, [self = shared_from_this()](std::error_code ec, std::size_t bytes_transferred) {
-        CB_LOG_PROTOCOL("[MCBP, OUT] host=\"{}\", port={}, rc={}, bytes_sent={}",
+        CB_LOG_PROTOCOL("[MCBP, OUT] host=\"{}\", sport={}, dport={}, rc={}, bytes_sent={}",
                         self->connection_endpoints_.remote_address,
+                        self->connection_endpoints_.local.port(),
                         self->connection_endpoints_.remote.port(),
                         ec ? ec.message() : "ok",
                         bytes_transferred);
@@ -2048,6 +2066,7 @@ private:
   asio::ip::tcp::resolver resolver_;
   std::unique_ptr<stream_impl> stream_;
   asio::steady_timer bootstrap_deadline_;
+  asio::steady_timer resolve_deadline_;
   asio::steady_timer connection_deadline_;
   asio::steady_timer retry_backoff_;
   asio::steady_timer ping_timeout_;

data/ext/couchbase/core/io/retry_context.hxx

@@ -20,7 +20,6 @@
 #include <couchbase/retry_reason.hxx>
 #include <couchbase/retry_strategy.hxx>
 
-#include <chrono>
 #include <memory>
 #include <mutex>
 #include <set>

data/ext/couchbase/core/logger/custom_rotating_file_sink.hxx

@@ -55,8 +55,11 @@ public:
   ~custom_rotating_file_sink() override;
 
 protected:
+  // Explicitly instantiated in custom_rotating_file_sink.cxx
+  // NOLINTBEGIN(portability-template-virtual-member-function)
   void sink_it_(const spdlog::details::log_msg& msg) override;
   void flush_() override;
+  // NOLINTEND(portability-template-virtual-member-function)
 
 private:
   void add_hook(const std::string& hook);

data/ext/couchbase/core/mcbp/big_endian.cxx

@@ -70,4 +70,12 @@ put_uint32(gsl::span<std::byte> bytes, std::uint32_t value)
   bytes[2] = static_cast<std::byte>(value >> 8);
   bytes[3] = static_cast<std::byte>(value);
 }
+
+void
+put_uint64(gsl::span<std::byte> bytes, std::uint64_t value)
+{
+  for (std::size_t i = 0; i < 8; ++i) {
+    bytes[i] = static_cast<std::byte>(value >> (56 - i * 8));
+  }
+}
 } // namespace couchbase::core::mcbp::big_endian

data/ext/couchbase/core/mcbp/big_endian.hxx

@@ -43,4 +43,7 @@ read(gsl::span<std::byte> buffer, std::size_t offset, std::size_t length) -> std
 
 void
 put_uint32(gsl::span<std::byte> bytes, std::uint32_t value);
+
+void
+put_uint64(gsl::span<std::byte> bytes, std::uint64_t value);
 } // namespace couchbase::core::mcbp::big_endian

data/ext/couchbase/core/meta/features.hxx

@@ -243,3 +243,13 @@
  * get_multi API is implemented for transactions
  */
 #define COUCHBASE_CXX_CLIENT_HAS_TRANSACTIONS_GET_MULTI 1
+
+/**
+ * couchbase::transactions::transaction_query_options has a flex_index option
+ */
+#define COUCHBASE_CXX_CLIENT_TRANSACTION_QUERY_OPTIONS_HAVE_FLEX_INDEX 1
+
+/**
+ * couchbase::vector_query has a prefilter option.
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_VECTOR_SEARCH_PREFILTER 1

data/ext/couchbase/core/meta/version.cxx

@@ -26,11 +26,11 @@
 #include <couchbase/build_info.hxx>
 #include <couchbase/build_version.hxx>
 
+#include "include_ssl/crypto.h"
+#include "include_ssl/x509.h"
 #include <asio/version.hpp>
 #include <hdr/hdr_histogram_version.h>
 #include <llhttp.h>
-#include <openssl/crypto.h>
-#include <openssl/x509.h>
 #include <snappy-stubs-public.h>
 #include <spdlog/fmt/bundled/core.h>
 #include <spdlog/version.h>