couchbase 3.8.2 → 3.9.0

data/ext/couchbase/core/analytics_stream.cxx

@@ -0,0 +1,314 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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 "analytics_stream.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include "core/io/http_error.hxx"
+#include "core/operations/analytics_response_parsing.hxx"
+#include "free_form_http_request.hxx"
+#include "logger/logger.hxx"
+#include "row_streamer.hxx"
+#include "utils/json.hxx"
+#include "utils/movable_function.hxx"
+
+#include <tao/json/value.hpp>
+
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <system_error>
+#include <utility>
+
+namespace couchbase::core
+{
+namespace
+{
+constexpr auto ANALYTICS_RESULTS_POINTER = "/results/^";
+
+// Normalize a bounded-lexer failure (malformed / oversized JSON) to errc::common::parsing_failure,
+// matching the buffered analytics_query() path and row_streamer's own truncated-body terminal, so
+// the public streaming error contract is consistent.
+auto
+normalize_stream_error(std::error_code ec) -> std::error_code
+{
+  if (ec.category() == couchbase::core::impl::streaming_json_lexer_category()) {
+    return errc::common::parsing_failure;
+  }
+  return ec;
+}
+} // namespace
+
+namespace
+{
+// Lift the service-reported diagnostics out of a parsed preamble/trailer. Called for both sections,
+// so whichever one carried the failure is what the error context ends up describing.
+auto
+extract_error_details(const operations::analytics_response::analytics_meta_data& meta,
+                      std::string raw) -> stream_error_details
+{
+  stream_error_details details{};
+  details.client_context_id = meta.client_context_id;
+  // Retained whether or not the section reports an error: it becomes error_context::http_body,
+  // which the buffered path fills for every response, and even an error-free envelope names the
+  // request the service logged.
+  details.raw = std::move(raw);
+  if (!meta.errors.empty()) {
+    details.first_error_code = meta.errors.front().code;
+    details.first_error_message = meta.errors.front().message;
+  }
+  return details;
+}
+} // namespace
+
+class analytics_stream_impl : public std::enable_shared_from_this<analytics_stream_impl>
+{
+public:
+  analytics_stream_impl(asio::io_context& io,
+                        http_response_body body,
+                        row_streamer_options options,
+                        std::uint32_t http_status)
+    : streamer_{ io, std::move(body), ANALYTICS_RESULTS_POINTER, options }
+    , http_status_{ http_status }
+  {
+  }
+  analytics_stream_impl(const analytics_stream_impl&) = delete;
+  analytics_stream_impl(analytics_stream_impl&&) = delete;
+  auto operator=(const analytics_stream_impl&) -> analytics_stream_impl& = delete;
+  auto operator=(analytics_stream_impl&&) -> analytics_stream_impl& = delete;
+
+  // Runs with no handle left, no pull in flight and the preamble delivered: each pull, and start()
+  // until the preamble, holds this object.
+  //
+  // Cancels unless a pull delivered the terminal of a completed JSON document. Without the cancel,
+  // the read-ahead keeps the body and its session alive:
+  //  - through a read in flight, until the idle timer fires or the cluster closes;
+  //  - through a row send queued on a full channel, indefinitely.
+  // The cancel stops the connection only while the body is still being read. A body read to its
+  // end has already checked the connection in.
+  //
+  // After a completed document the read-ahead reads the trailing bytes and the connection is
+  // checked in, or the idle timer ends the body.
+  ~analytics_stream_impl()
+  {
+    if (!document_completed_) {
+      streamer_.cancel();
+    }
+  }
+
+  void start(utils::movable_function<void(std::error_code)>&& on_ready)
+  {
+    streamer_.start([self = shared_from_this(), on_ready = std::move(on_ready)](
+                      std::string preamble, std::error_code ec) mutable {
+      if (ec) {
+        return on_ready(normalize_stream_error(
+          io::invalid_argument_for_undecodable_400(ec, self->http_status_, {})));
+      }
+      operations::analytics_response::analytics_meta_data meta{};
+      try {
+        meta = operations::parse_analytics_meta(utils::json::parse(preamble));
+      } catch (const std::exception&) {
+        {
+          // Keep the unparseable preamble: it is the only diagnostic there is for a malformed
+          // response, and the buffered path reports the raw body in the same situation.
+          const std::scoped_lock lock{ self->mutex_ };
+          self->error_details_.raw = std::move(preamble);
+        }
+        return on_ready(io::invalid_argument_for_undecodable_400(
+          errc::common::parsing_failure, self->http_status_, {}));
+      }
+      {
+        const std::scoped_lock lock{ self->mutex_ };
+        self->signature_ = meta.signature;
+        self->error_details_ = extract_error_details(meta, std::move(preamble));
+      }
+      // An upfront error is rare for the streaming path (status/errors usually arrive in the
+      // trailer). The preamble status is typically "running", so only surface an early error when
+      // the preamble already carries error entries.
+      std::error_code early_error{};
+      if (!meta.errors.empty()) {
+        early_error = operations::map_analytics_error(meta, self->http_status_);
+      }
+      on_ready(early_error);
+    });
+  }
+
+  void next_row(
+    utils::movable_function<void(std::optional<std::string>, std::error_code)>&& handler)
+  {
+    // Terminal-sticky: once the stream has ended, re-deliver the stored terminal on every
+    // subsequent pull instead of issuing another receive that would park forever on the
+    // drained-but-open row channel. The public handle guards this too, but a core::-direct consumer
+    // (e.g. a wrapper) relies on this being safe.
+    std::optional<std::error_code> sticky_terminal;
+    {
+      const std::scoped_lock lock{ mutex_ };
+      if (terminal_reached_) {
+        sticky_terminal = terminal_ec_;
+      }
+    }
+    if (sticky_terminal) {
+      // Deliver outside the lock: the handler typically issues the next pull, which re-enters
+      // next_row and would re-lock the non-recursive mutex_ and deadlock if invoked while held.
+      return handler(std::nullopt, *sticky_terminal);
+    }
+    streamer_.next_row([self = shared_from_this(),
+                        handler = std::move(handler)](std::string row, std::error_code ec) mutable {
+      if (!row.empty()) {
+        return handler(std::move(row), {});
+      }
+      // Empty row marks the end of the stream. Classify the terminal, remember it (so later pulls
+      // are served the sticky terminal above), then deliver.
+      std::error_code terminal_ec{};
+      if (ec) {
+        // Normalize a mid-document lexer failure to parsing_failure, matching the buffered path.
+        terminal_ec = normalize_stream_error(
+          io::invalid_argument_for_undecodable_400(ec, self->http_status_, {}));
+      } else if (auto raw_meta = self->streamer_.metadata(); !raw_meta.has_value()) {
+        // A clean end without reconstructed metadata violates the row_streamer invariant; surface
+        // it rather than silently reporting success with no metadata.
+        CB_LOG_WARNING("analytics_stream: end reached but row_streamer returned no metadata");
+        terminal_ec = errc::common::internal_server_failure;
+      } else {
+        try {
+          auto meta = operations::parse_analytics_meta(utils::json::parse(raw_meta.value()));
+          terminal_ec = operations::map_analytics_error(meta, self->http_status_);
+          const std::scoped_lock lock{ self->mutex_ };
+          // The trailer is where a request that failed part-way reports itself, so its diagnostics
+          // supersede the preamble's for the terminal error.
+          self->error_details_ = extract_error_details(meta, std::move(raw_meta.value()));
+          self->meta_data_ = std::move(meta);
+        } catch (const std::exception&) {
+          terminal_ec = io::invalid_argument_for_undecodable_400(
+            errc::common::parsing_failure, self->http_status_, {});
+          const std::scoped_lock lock{ self->mutex_ };
+          self->error_details_.raw = std::move(raw_meta.value());
+        }
+      }
+      {
+        const std::scoped_lock lock{ self->mutex_ };
+        self->terminal_reached_ = true;
+        self->terminal_ec_ = terminal_ec;
+        self->document_completed_ = !ec;
+      }
+      handler(std::nullopt, terminal_ec);
+    });
+  }
+
+  [[nodiscard]] auto signature() const -> std::optional<std::string>
+  {
+    const std::scoped_lock lock{ mutex_ };
+    return signature_;
+  }
+
+  [[nodiscard]] auto meta_data() const
+    -> std::optional<operations::analytics_response::analytics_meta_data>
+  {
+    const std::scoped_lock lock{ mutex_ };
+    return meta_data_;
+  }
+
+  [[nodiscard]] auto error_details() const -> stream_error_details
+  {
+    const std::scoped_lock lock{ mutex_ };
+    return error_details_;
+  }
+
+  auto set_deadline(std::chrono::time_point<std::chrono::steady_clock> deadline_tp)
+    -> io::deadline_state
+  {
+    return streamer_.set_deadline(deadline_tp);
+  }
+
+  void cancel()
+  {
+    streamer_.cancel();
+  }
+
+private:
+  row_streamer streamer_;
+  std::uint32_t http_status_{};
+  mutable std::mutex mutex_{};
+  std::optional<std::string> signature_{};
+  std::optional<operations::analytics_response::analytics_meta_data> meta_data_{};
+  stream_error_details error_details_{};
+  // Terminal-sticky state (guarded by mutex_): once next_row reports the terminal, it is remembered
+  // so every later pull re-delivers it instead of parking on the drained channel.
+  bool terminal_reached_{ false };
+  std::error_code terminal_ec_{};
+  // Set when a pull delivers a terminal with no streamer error: the lexer completed the JSON
+  // document. Written under mutex_. The destructor reads it unlocked: the release of the last
+  // shared_ptr orders that read after every write.
+  bool document_completed_{ false };
+};
+
+analytics_stream::analytics_stream(asio::io_context& io,
+                                   http_response_body body,
+                                   row_streamer_options options,
+                                   std::uint32_t http_status)
+  : impl_{ std::make_shared<analytics_stream_impl>(io, std::move(body), options, http_status) }
+{
+}
+
+void
+analytics_stream::start(utils::movable_function<void(std::error_code)>&& on_ready)
+{
+  impl_->start(std::move(on_ready));
+}
+
+void
+analytics_stream::next_row(
+  utils::movable_function<void(std::optional<std::string>, std::error_code)>&& handler)
+{
+  impl_->next_row(std::move(handler));
+}
+
+auto
+analytics_stream::signature() const -> std::optional<std::string>
+{
+  return impl_->signature();
+}
+
+auto
+analytics_stream::error_details() const -> stream_error_details
+{
+  return impl_->error_details();
+}
+
+auto
+analytics_stream::meta_data() const
+  -> std::optional<operations::analytics_response::analytics_meta_data>
+{
+  return impl_->meta_data();
+}
+
+auto
+analytics_stream::set_deadline(std::chrono::time_point<std::chrono::steady_clock> deadline_tp)
+  -> io::deadline_state
+{
+  return impl_->set_deadline(deadline_tp);
+}
+
+void
+analytics_stream::cancel()
+{
+  impl_->cancel();
+}
+} // namespace couchbase::core

data/ext/couchbase/core/analytics_stream.hxx

@@ -0,0 +1,129 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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/io/stream_deadline.hxx"
+#include "core/operations/document_analytics.hxx"
+#include "row_streamer.hxx"
+#include "stream_error_details.hxx"
+#include "utils/movable_function.hxx"
+
+#include <chrono>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <system_error>
+
+namespace asio
+{
+class io_context;
+} // namespace asio
+
+namespace couchbase::core
+{
+class analytics_stream_impl;
+class http_response_body;
+
+/**
+ * L3 streaming state machine for analytics responses.
+ *
+ * Mirrors query_stream but with analytics-specific semantics: it wraps a row_streamer (pointed at
+ * "/results/^", the same pointer the buffered analytics path uses) and adds preamble parsing
+ * (signature + upfront error detection), late trailer metadata, and terminal error classification
+ * via map_analytics_error.
+ */
+class analytics_stream
+{
+public:
+  /**
+   * Constructs an empty handle (no underlying stream). Used to carry the "no stream" outcome on
+   * the error path of the dispatch; none of the streaming methods may be called on it.
+   */
+  analytics_stream() = default;
+
+  /**
+   * http_status is the status of the response the body belongs to; an HTTP 400 that matches no
+   * specific error is reported as invalid_argument.
+   */
+  analytics_stream(asio::io_context& io,
+                   http_response_body body,
+                   row_streamer_options options = {},
+                   std::uint32_t http_status = 0);
+
+  /**
+   * Starts the stream. Resolves once the preamble has been parsed. The early_error is set when
+   * the response carried an upfront error (or the preamble failed to parse).
+   */
+  void start(utils::movable_function<void(std::error_code early_error)>&& on_ready);
+
+  /**
+   * Service-reported diagnostics from the most recently parsed JSON section — the preamble after
+   * start(), the trailer once the terminal has been reached. The dispatch layer stamps these into
+   * the error context so a streaming failure reports the same detail as a buffered one.
+   */
+  [[nodiscard]] auto error_details() const -> stream_error_details;
+
+  /**
+   * Retrieves the next row. A populated row is delivered with a falsy error_code. An empty row
+   * (std::nullopt) signals the end: a falsy error_code means a clean success end, a truthy
+   * error_code means a trailing analytics/transport error.
+   */
+  void next_row(
+    utils::movable_function<void(std::optional<std::string> row, std::error_code)>&& handler);
+
+  /**
+   * Signature captured from the preamble (available after start resolves).
+   */
+  [[nodiscard]] auto signature() const -> std::optional<std::string>;
+
+  /**
+   * Trailer metadata. Valid only after the stream has reached its end.
+   */
+  [[nodiscard]] auto meta_data() const
+    -> std::optional<operations::analytics_response::analytics_meta_data>;
+
+  /**
+   * Closes the HTTP body at `deadline_tp`, whether or not a row is being pulled, releasing the
+   * connection where one is still held. A response received in full holds none: once its bytes
+   * have also been parsed the call arms nothing and reports body_already_ended, and while bytes
+   * remain unparsed it ends the body, dropping those and reporting the timeout. Rows already
+   * parsed stay consumable either way. The inter-read idle timer is armed only while a socket
+   * read is in flight, and a consumer stopped above the high-water mark has none.
+   *
+   * The terminal reaches the consumer through a pull. A pull outstanding at expiry completes
+   * with the timeout. A read that completes the response is the exception: the whole response
+   * arrived, so those bytes are delivered as a clean end. Otherwise the next pull reports the
+   * terminal, after any rows already buffered.
+   *
+   * Optional. The terminal is unambiguous_timeout for a read-only request, ambiguous_timeout
+   * otherwise. Re-arming before expiry replaces the deadline. Once the stream has ended a
+   * further call arms nothing and reports body_already_ended. Callable from any thread.
+   */
+  [[nodiscard]] auto set_deadline(std::chrono::time_point<std::chrono::steady_clock> deadline_tp)
+    -> io::deadline_state;
+
+  /**
+   * Cancels the stream & closes the HTTP connection.
+   */
+  void cancel();
+
+private:
+  std::shared_ptr<analytics_stream_impl> impl_;
+};
+} // namespace couchbase::core

data/ext/couchbase/core/analytics_stream_component.cxx

@@ -0,0 +1,245 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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 "analytics_stream_component.hxx"
+
+#include "free_form_http_request.hxx"
+#include "http_component.hxx"
+#include "impl/bootstrap_error.hxx"
+#include "operations/document_analytics.hxx"
+#include "platform/uuid.h"
+#include "service_type.hxx"
+#include "utils/json.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <asio/io_context.hpp>
+#include <spdlog/fmt/bundled/core.h>
+#include <tao/json/value.hpp>
+
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <system_error>
+#include <utility>
+
+namespace couchbase::core
+{
+namespace
+{
+auto
+to_error_code(std::error_code err) -> std::error_code
+{
+  return err;
+}
+
+auto
+build_streaming_analytics_body(const operations::analytics_request& request,
+                               const std::string& client_context_id,
+                               std::chrono::milliseconds timeout) -> std::string
+{
+  tao::json::value body{};
+
+  // The remaining options are identical to the buffered analytics path; share one encoder so the
+  // two stay byte-for-byte consistent. This runs first so the control fields set below always win
+  // over any same-named `raw` entry a caller may have supplied.
+  operations::encode_analytics_options(body, request);
+
+  body["client_context_id"] = client_context_id;
+  body["statement"] = request.statement;
+  // The server-side timeout is sent unmodified here — unlike the query path, which shaves 500ms so
+  // it observes the engine's timeout before its own. This mirrors the buffered analytics path
+  // (document_analytics), which likewise does not tighten the engine deadline; keep them
+  // consistent.
+  body["timeout"] = fmt::format("{}ms", timeout.count());
+
+  return utils::json::generate(body);
+}
+} // namespace
+
+class analytics_stream_component_impl
+  : public std::enable_shared_from_this<analytics_stream_component_impl>
+{
+public:
+  analytics_stream_component_impl(asio::io_context& io,
+                                  http_component http,
+                                  std::chrono::milliseconds default_timeout,
+                                  row_streamer_options streaming_options)
+    : io_{ io }
+    , http_{ std::move(http) }
+    , default_timeout_{ default_timeout }
+    , streaming_options_{ streaming_options }
+  {
+  }
+
+  void execute(operations::analytics_request request,
+               analytics_stream_component::handler_type&& handler)
+  {
+    const std::string client_context_id =
+      request.client_context_id.value_or(uuid::to_string(uuid::random()));
+    const std::chrono::milliseconds timeout = request.timeout.value_or(default_timeout_);
+
+    http_request http_req{ service_type::analytics, "POST" };
+    http_req.path = "/query/service";
+
+    // Everything about the request that an error context reports, known before dispatch. The
+    // response-side fields (HTTP status, the service's first error, the endpoint) are filled in as
+    // they become available, so a failure at any stage carries as much detail as the buffered path.
+    // Held behind a shared_ptr, not by value: it carries the encoded request body in
+    // `parameters`, and both the dispatch callback and the synchronous dispatch-failure branch
+    // below need it, so sharing avoids deep-copying that body on every streaming request.
+    auto base_ctx = std::make_shared<error_context::analytics>();
+    base_ctx->client_context_id = client_context_id;
+    base_ctx->statement = request.statement;
+    base_ctx->method = http_req.method;
+    base_ctx->path = http_req.path;
+
+    try {
+      http_req.body = build_streaming_analytics_body(request, client_context_id, timeout);
+    } catch (const std::exception&) {
+      // A caller-supplied raw/parameter value that is not valid JSON fails encoding; surface it as
+      // invalid_argument rather than letting the exception escape the public API.
+      base_ctx->ec = errc::common::invalid_argument;
+      return handler({}, std::move(*base_ctx));
+    }
+    base_ctx->parameters = http_req.body;
+    http_req.timeout = timeout;
+    http_req.client_context_id = client_context_id;
+    http_req.is_read_only = request.readonly;
+    http_req.headers["connection"] = "keep-alive";
+    http_req.headers["content-type"] = "application/json";
+    if (request.priority) {
+      http_req.headers["analytics-priority"] = "-1";
+    }
+    if (request.parent_span) {
+      http_req.parent_span = request.parent_span;
+    }
+
+    auto callback_state = std::make_shared<callback_state_type>(std::move(handler));
+
+    using dispatch_error = std::error_code;
+
+    const bool read_only = request.readonly;
+    auto op = http_.do_http_request(
+      http_req,
+      [self = shared_from_this(), callback_state, timeout, read_only, base_ctx](
+        http_response resp, dispatch_error err) mutable {
+        if (auto ec = to_error_code(err)) {
+          base_ctx->ec = ec;
+          self->invoke(callback_state, {}, std::move(*base_ctx));
+          return;
+        }
+        // The response is in hand, so the context can now name the endpoint and HTTP status.
+        base_ctx->http_status = resp.status_code();
+        const auto dispatch_info = resp.dispatch_info();
+        base_ctx->hostname = dispatch_info.hostname;
+        base_ctx->port = dispatch_info.port;
+        if (!dispatch_info.remote_address.empty()) {
+          base_ctx->last_dispatched_to = dispatch_info.remote_address;
+        }
+        if (!dispatch_info.local_address.empty()) {
+          base_ctx->last_dispatched_from = dispatch_info.local_address;
+        }
+        // Use the cluster's streaming tuning, but bound the server between reads with this
+        // request's timeout: if it stalls mid-body the stream times out rather than hanging next()
+        // forever (the request timeout is otherwise released once headers arrive).
+        auto options = self->streaming_options_;
+        options.idle_timeout = timeout;
+        options.is_read_only = read_only;
+        auto stream =
+          std::make_shared<analytics_stream>(self->io_, resp.body(), options, resp.status_code());
+        stream->start(
+          [self, callback_state, stream, base_ctx](std::error_code early_error) mutable {
+            if (early_error) {
+              // The preamble is what carried the failure, so stamp its diagnostics before tearing
+              // the stream down.
+              base_ctx->ec = early_error;
+              apply_error_details(*base_ctx, stream->error_details());
+              // No consumer will ever take ownership of this stream, so tear the underlying body
+              // (socket + timers) down now rather than when the last handle drops.
+              stream->cancel();
+              self->invoke(callback_state, {}, std::move(*base_ctx));
+              return;
+            }
+            // Hand the base context to the consumer alongside the stream: a terminal error reached
+            // later is stamped onto it, so a mid-stream failure reports the same detail as this
+            // one.
+            self->invoke(callback_state, std::move(*stream), std::move(*base_ctx));
+          });
+      });
+
+    if (!op.has_value()) {
+      base_ctx->ec = to_error_code(op.error());
+      invoke(callback_state, {}, std::move(*base_ctx));
+    }
+  }
+
+private:
+  struct callback_state_type {
+    explicit callback_state_type(analytics_stream_component::handler_type h)
+      : handler{ std::move(h) }
+    {
+    }
+
+    analytics_stream_component::handler_type handler;
+    std::mutex mutex{};
+    bool invoked{ false };
+  };
+
+  void invoke(const std::shared_ptr<callback_state_type>& state,
+              analytics_stream stream,
+              error_context::analytics ctx)
+  {
+    analytics_stream_component::handler_type handler;
+    {
+      const std::scoped_lock lock{ state->mutex };
+      if (state->invoked) {
+        return;
+      }
+      state->invoked = true;
+      handler = std::move(state->handler);
+    }
+    if (handler) {
+      handler(std::move(stream), std::move(ctx));
+    }
+  }
+
+  asio::io_context& io_;
+  http_component http_;
+  std::chrono::milliseconds default_timeout_;
+  row_streamer_options streaming_options_;
+};
+
+analytics_stream_component::analytics_stream_component(asio::io_context& io,
+                                                       http_component http,
+                                                       std::chrono::milliseconds default_timeout,
+                                                       row_streamer_options streaming_options)
+  : impl_{ std::make_shared<analytics_stream_component_impl>(io,
+                                                             std::move(http),
+                                                             default_timeout,
+                                                             streaming_options) }
+{
+}
+
+void
+analytics_stream_component::execute(operations::analytics_request request,
+                                    handler_type&& handler) const
+{
+  impl_->execute(std::move(request), std::move(handler));
+}
+} // namespace couchbase::core