couchbase 4.4.2 → 4.4.3

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

@@ -269,7 +269,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), map_bucket_settings(resp.bucket));
       });
   }
@@ -282,7 +282,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), map_all_bucket_settings(resp.buckets));
       });
   }
@@ -297,7 +297,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -312,7 +312,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -327,7 +327,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -342,7 +342,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }

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

@@ -230,21 +230,8 @@ public:
     // We cannot use close() method here, as it is capturing self as a shared
     // pointer to extend lifetime for the user's callback. Here the reference
     // counter has reached zero already, so we can only capture `*this`.
-    std::thread([this, &barrier]() mutable {
-      if (auto txns = std::move(transactions_); txns != nullptr) {
-        // blocks until cleanup is finished
-        txns->close();
-      }
-      std::promise<void> core_stopped;
-      auto f = core_stopped.get_future();
-      core_.close([&core_stopped]() {
-        core_stopped.set_value();
-      });
-      f.get();
-      io_.stop();
-      if (io_thread_.joinable()) {
-        io_thread_.join();
-      }
+    std::thread([this, barrier = std::move(barrier)]() mutable {
+      do_close();
       barrier.set_value();
     }).detach();
 
@@ -291,7 +278,7 @@ public:
                 }));
               return;
             }
-            impl->transactions_ = txns;
+            impl->transactions_ = std::move(txns);
             handler(ec, couchbase::cluster(std::move(impl)));
           });
       });
@@ -323,16 +310,17 @@ public:
                       {},
                       core::impl::to_core_service_types(options.service_types),
                       options.timeout,
-                      [handler = std::move(handler)](auto resp) mutable {
+                      [handler = std::move(handler)](const auto& resp) mutable {
                         return handler({}, core::impl::build_result(resp));
                       });
   };
 
   void diagnostics(const diagnostics_options::built& options, diagnostics_handler&& handler) const
   {
-    return core_.diagnostics(options.report_id, [handler = std::move(handler)](auto resp) mutable {
-      return handler({}, core::impl::build_result(resp));
-    });
+    return core_.diagnostics(options.report_id,
+                             [handler = std::move(handler)](const auto& resp) mutable {
+                               return handler({}, core::impl::build_result(resp));
+                             });
   }
 
   void search(std::string index_name,
@@ -342,7 +330,7 @@ public:
   {
     return core_.execute(
       core::impl::build_search_request(std::move(index_name), std::move(request), options, {}, {}),
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx),
                        search_result{ internal_search_result{ resp } });
       });
@@ -371,20 +359,7 @@ public:
   {
     // Spawn new thread to avoid joining IO thread from the same thread
     std::thread([self = shared_from_this(), handler = std::move(handler)]() mutable {
-      if (auto txns = std::move(self->transactions_); txns != nullptr) {
-        // blocks until cleanup is finished
-        txns->close();
-      }
-      std::promise<void> barrier;
-      auto future = barrier.get_future();
-      self->core_.close([&barrier]() {
-        barrier.set_value();
-      });
-      future.get();
-      self->io_.stop();
-      if (self->io_thread_.joinable()) {
-        self->io_thread_.join();
-      }
+      self->do_close();
       handler();
     }).detach();
   }
@@ -400,7 +375,25 @@ public:
   }
 
 private:
-  asio::io_context io_{ ASIO_CONCURRENCY_HINT_1 };
+  void do_close()
+  {
+    if (auto txns = std::move(transactions_); txns != nullptr) {
+      // blocks until cleanup is finished
+      txns->close();
+    }
+    std::promise<void> core_stopped;
+    auto f = core_stopped.get_future();
+    core_.close([core_stopped = std::move(core_stopped)]() mutable {
+      core_stopped.set_value();
+    });
+    f.get();
+    io_.stop();
+    if (io_thread_.joinable()) {
+      io_thread_.join();
+    }
+  }
+
+  asio::io_context io_{ ASIO_CONCURRENCY_HINT_SAFE };
   core::cluster core_{ io_ };
   std::shared_ptr<core::transactions::transactions> transactions_{ nullptr };
   std::thread io_thread_{ [&io = io_] {
@@ -539,12 +532,15 @@ cluster::connect(const std::string& connection_string,
   // Spawn new thread for connection to ensure that cluster_impl pointer will
   // not be deallocated in IO thread in case of error.
   std::thread([connection_string, options, handler = std::move(handler)]() {
-    auto impl = std::make_shared<cluster_impl>();
     auto barrier = std::make_shared<std::promise<std::pair<error, cluster>>>();
     auto future = barrier->get_future();
-    impl->open(connection_string, options, [barrier](auto err, auto c) {
-      barrier->set_value({ std::move(err), std::move(c) });
-    });
+    {
+      auto impl = std::make_shared<cluster_impl>();
+      impl->open(connection_string, options, [barrier](auto err, auto c) {
+        barrier->set_value({ std::move(err), std::move(c) });
+      });
+    }
+
     auto [err, c] = future.get();
     handler(std::move(err), std::move(c));
   }).detach();

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

@@ -211,7 +211,7 @@ public:
         options.timeout,
         { options.retry_strategy },
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(std::move(resp.ctx)), result{ resp.cas });
       });
   }
@@ -1390,7 +1390,7 @@ collection::scan(const couchbase::scan_type& scan_type, const couchbase::scan_op
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, scan_result>>>();
   auto future = barrier->get_future();
-  scan(scan_type, options, [barrier](auto err, auto result) {
+  scan(scan_type, options, [barrier](const auto& err, auto result) {
     barrier->set_value({ err, std::move(result) });
   });
   return future;

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

@@ -101,7 +101,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -122,7 +122,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -143,7 +143,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -173,7 +173,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -189,7 +189,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }

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

@@ -26,6 +26,7 @@
 
 #include <memory>
 #include <mutex>
+#include <system_error>
 
 namespace couchbase::core::impl
 {
@@ -240,8 +241,7 @@ public:
   void handle_response(observe_seqno_response&& response)
   {
     --expect_number_of_responses_;
-    auto r = std::move(response);
-    status_.examine(r);
+    status_.examine(response);
     maybe_finish();
   }
 
@@ -249,6 +249,8 @@ public:
   {
     poll_backoff_.cancel();
     poll_deadline_.cancel();
+    on_last_response(0, [](std::error_code) {
+    });
     observe_handler handler{};
     {
       const std::scoped_lock lock(handler_mutex_);
@@ -268,10 +270,16 @@ public:
         return;
       }
       if (status_.meets_condition(persist_to_, replicate_to_)) {
+        poll_backoff_.cancel();
+        poll_deadline_.cancel();
+        on_last_response(0, [](std::error_code) {
+        });
         std::swap(handler_, handler);
-      } else if (expect_number_of_responses_ == 0 && on_last_response_) {
-        poll_backoff_.expires_after(poll_backoff_interval_);
-        return poll_backoff_.async_wait(std::move(on_last_response_));
+      } else if (expect_number_of_responses_ == 0) {
+        if (auto on_last_response = std::move(on_last_response_); on_last_response) {
+          poll_backoff_.expires_after(poll_backoff_interval_);
+          return poll_backoff_.async_wait(std::move(on_last_response));
+        }
       }
     }
     if (handler) {

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

@@ -17,7 +17,6 @@
 
 #pragma once
 
-#include "core/error_context/key_value_error_context.hxx"
 #include <couchbase/mutation_token.hxx>
 #include <couchbase/persist_to.hxx>
 #include <couchbase/replicate_to.hxx>
@@ -26,8 +25,7 @@
 #include "core/utils/movable_function.hxx"
 
 #include <chrono>
-#include <functional>
-#include <memory>
+#include <system_error>
 
 namespace couchbase::core
 {

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

@@ -232,7 +232,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -259,7 +259,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -283,7 +283,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -342,7 +342,7 @@ public:
                                                                    std::move(list_resp.index_names),
                                                                    {},
                                                                    timeout },
-          [handler = std::move(handler)](auto build_resp) {
+          [handler = std::move(handler)](const auto& build_resp) {
             return handler(core::impl::make_error(build_resp.ctx));
           });
       });
@@ -390,7 +390,7 @@ query_index_manager::get_all_indexes(const std::string& bucket_name,
   auto barrier =
     std::make_shared<std::promise<std::pair<error, std::vector<management::query_index>>>>();
   auto future = barrier->get_future();
-  get_all_indexes(bucket_name, options, [barrier](auto err, auto resp) mutable {
+  get_all_indexes(bucket_name, options, [barrier](auto err, const auto& resp) mutable {
     barrier->set_value({ std::move(err), resp });
   });
   return future;
@@ -563,7 +563,7 @@ collection_query_index_manager::get_all_indexes(const get_all_query_indexes_opti
   auto barrier =
     std::make_shared<std::promise<std::pair<error, std::vector<management::query_index>>>>();
   auto future = barrier->get_future();
-  get_all_indexes(options, [barrier](auto err, auto resp) mutable {
+  get_all_indexes(options, [barrier](auto err, const auto& resp) mutable {
     barrier->set_value({ std::move(err), resp });
   });
   return future;

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

@@ -97,7 +97,7 @@ scan_result::next() const -> std::future<std::pair<error, std::optional<scan_res
 {
   auto barrier =
     std::make_shared<std::promise<std::pair<error, std::optional<scan_result_item>>>>();
-  internal_->next([barrier](auto err, auto item) mutable {
+  internal_->next([barrier](const auto& err, const auto& item) mutable {
     barrier->set_value({ err, item });
   });
   return barrier->get_future();

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

@@ -150,7 +150,7 @@ public:
     core_.execute(
       core::operations::management::search_index_get_request{
         std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), map_search_index(resp.index));
       });
   }
@@ -161,7 +161,7 @@ public:
     core_.execute(
       core::operations::management::search_index_get_all_request{
         bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), map_all_search_indexes(resp.indexes));
       });
   }
@@ -173,7 +173,7 @@ public:
     core_.execute(
       core::operations::management::search_index_upsert_request{
         map_search_index(search_index), bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -185,7 +185,7 @@ public:
     core_.execute(
       core::operations::management::search_index_drop_request{
         std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -197,7 +197,7 @@ public:
     core_.execute(
       core::operations::management::search_index_get_documents_count_request{
         std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), resp.count);
       });
   }
@@ -209,7 +209,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_ingest_request{
         std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -221,7 +221,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_ingest_request{
         std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -233,7 +233,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_query_request{
         std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -245,7 +245,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_query_request{
         std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -257,7 +257,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_plan_freeze_request{
         std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -269,7 +269,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_plan_freeze_request{
         std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -286,7 +286,7 @@ public:
                                                                            scope_name_,
                                                                            {},
                                                                            options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), convert_analysis(resp.analysis));
       });
   }

package/deps/couchbase-cxx-client/core/io/http_command.hxx

@@ -19,13 +19,15 @@
 
 #include <couchbase/build_config.hxx>
 
+#include "core/impl/bootstrap_error.hxx"
+#include "core/metrics/meter_wrapper.hxx"
 #include "core/service_type_fmt.hxx"
 #include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 #include "core/utils/movable_function.hxx"
 #include "http_session.hxx"
 #include "http_traits.hxx"
 
-#include <couchbase/metrics/meter.hxx>
 #include <couchbase/tracing/request_tracer.hxx>
 
 #include <utility>
@@ -33,7 +35,11 @@
 namespace couchbase::core::operations
 {
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+using http_command_handler = utils::movable_function<void(error_union, io::http_response&&)>;
+#else
 using http_command_handler = utils::movable_function<void(std::error_code, io::http_response&&)>;
+#endif
 
 template<typename Request>
 struct http_command : public std::enable_shared_from_this<http_command<Request>> {
@@ -43,9 +49,9 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
   asio::steady_timer deadline;
   Request request;
   encoded_request_type encoded;
-  std::shared_ptr<couchbase::tracing::request_tracer> tracer_;
+  std::shared_ptr<tracing::tracer_wrapper> tracer_;
   std::shared_ptr<couchbase::tracing::request_span> span_{ nullptr };
-  std::shared_ptr<couchbase::metrics::meter> meter_{};
+  std::shared_ptr<metrics::meter_wrapper> meter_{};
   std::shared_ptr<io::http_session> session_{};
   http_command_handler handler_{};
   std::chrono::milliseconds timeout_{};
@@ -57,8 +63,8 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
 
   http_command(asio::io_context& ctx,
                Request req,
-               std::shared_ptr<couchbase::tracing::request_tracer> tracer,
-               std::shared_ptr<couchbase::metrics::meter> meter,
+               std::shared_ptr<tracing::tracer_wrapper> tracer,
+               std::shared_ptr<metrics::meter_wrapper> meter,
                std::chrono::milliseconds default_timeout,
                std::chrono::milliseconds dispatch_timeout)
     : deadline(ctx)
@@ -77,8 +83,8 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
 #else
   http_command(asio::io_context& ctx,
                Request req,
-               std::shared_ptr<couchbase::tracing::request_tracer> tracer,
-               std::shared_ptr<couchbase::metrics::meter> meter,
+               std::shared_ptr<tracing::tracer_wrapper> tracer,
+               std::shared_ptr<metrics::meter_wrapper> meter,
                std::chrono::milliseconds default_timeout)
     : deadline(ctx)
     , request(req)
@@ -108,12 +114,13 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
 
   void start(http_command_handler&& handler)
   {
-    span_ = tracer_->start_span(tracing::span_name_for_http_service(request.type), parent_span);
-    if (span_->uses_tags())
+    span_ = tracer_->create_span(tracing::span_name_for_http_service(request.type), parent_span);
+    if (span_->uses_tags()) {
       span_->add_tag(tracing::attributes::service,
                      tracing::service_name_for_http_service(request.type));
-    if (span_->uses_tags())
       span_->add_tag(tracing::attributes::operation_id, client_context_id_);
+    }
+
     handler_ = std::move(handler);
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
     dispatch_deadline_.expires_after(dispatch_timeout_);
@@ -158,17 +165,24 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
     }
   }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void invoke_handler(error_union error, io::http_response&& msg)
+#else
   void invoke_handler(std::error_code ec, io::http_response&& msg)
+#endif
   {
     if (span_ != nullptr) {
       span_->end();
       span_ = nullptr;
     }
     if (auto handler = std::move(handler_); handler) {
-      handler(ec, std::move(msg));
-    }
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+      handler(error, std::move(msg));
+    }
     dispatch_deadline_.cancel();
+#else
+      handler(ec, std::move(msg));
+    }
 #endif
     deadline.cancel();
   }
@@ -231,15 +245,12 @@ private:
           return self->invoke_handler(errc::common::ambiguous_timeout, std::move(msg));
         }
         if (self->meter_) {
-          static std::string meter_name = "db.couchbase.operations";
-          static std::map<std::string, std::string> tags = {
-            { "db.couchbase.service", fmt::format("{}", self->request.type) },
-            { "db.operation", self->encoded.path },
+          metrics::metric_attributes attrs{
+            service_type::key_value,
+            fmt::format("{}", self->encoded.path),
+            ec,
           };
-          self->meter_->get_value_recorder(meter_name, tags)
-            ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(
-                             std::chrono::steady_clock::now() - start)
-                             .count());
+          self->meter_->record_value(std::move(attrs), start);
         }
         self->deadline.cancel();
         self->finish_dispatch(self->session_->remote_address(), self->session_->local_address());

package/deps/couchbase-cxx-client/core/io/http_session.cxx

@@ -395,7 +395,12 @@ http_session::flush()
 void
 http_session::write_and_stream(
   io::http_request& request,
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  utils::movable_function<void(couchbase::core::error_union, io::http_streaming_response)>
+    resp_handler,
+#else
   utils::movable_function<void(std::error_code, io::http_streaming_response)> resp_handler,
+#endif
   utils::movable_function<void()> stream_end_handler)
 {
   if (stopped_) {

package/deps/couchbase-cxx-client/core/io/http_session.hxx

@@ -17,7 +17,10 @@
 
 #pragma once
 
+#include <couchbase/build_config.hxx>
+
 #include "core/diagnostics.hxx"
+#include "core/impl/bootstrap_error.hxx"
 #include "core/origin.hxx"
 #include "core/platform/base64.h"
 #include "core/utils/movable_function.hxx"
@@ -140,10 +143,15 @@ public:
     flush();
   }
 
-  void write_and_stream(
-    io::http_request& request,
-    utils::movable_function<void(std::error_code, io::http_streaming_response)> resp_handler,
-    utils::movable_function<void()> stream_end_handler);
+  void write_and_stream(io::http_request& request,
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+                        utils::movable_function<void(couchbase::core::error_union,
+                                                     io::http_streaming_response)> resp_handler,
+#else
+                        utils::movable_function<void(std::error_code, io::http_streaming_response)>
+                          resp_handler,
+#endif
+                        utils::movable_function<void()> stream_end_handler);
 
   void set_idle(std::chrono::milliseconds timeout);
   auto reset_idle() -> bool;
@@ -155,7 +163,12 @@ public:
 
 private:
   struct streaming_response_context {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    utils::movable_function<void(couchbase::core::error_union, io::http_streaming_response)>
+      resp_handler{};
+#else
     utils::movable_function<void(std::error_code, io::http_streaming_response)> resp_handler{};
+#endif
     utils::movable_function<void()> stream_end_handler{};
     std::optional<io::http_streaming_response> resp{};
     http_streaming_parser parser{};