couchbase 3.8.2 → 3.9.1

data/ext/couchbase/core/utils/byteswap.hxx

@@ -22,8 +22,30 @@
 
 namespace couchbase::core::utils
 {
+namespace detail
+{
+/**
+ * Byte order of a host.
+ *
+ * Kept as a value that the conversions below take as a parameter, rather than as a preprocessor
+ * branch around them, so that both orders stay compilable and testable whatever host this is
+ * built on. Without that, the big-endian path could only ever be verified by running on a
+ * big-endian host, and nothing in CI does.
+ */
+enum class host_order {
+  little,
+  big,
+};
+
+#if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) &&                                    \
+  __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+inline constexpr host_order native_order = host_order::big;
+#else
+inline constexpr host_order native_order = host_order::little;
+#endif
+
 static constexpr auto
-byte_swap(std::uint16_t value) -> std::uint16_t
+swap_bytes(std::uint16_t value) -> std::uint16_t
 {
   auto hi = static_cast<std::uint16_t>(value << 8U);
   auto lo = static_cast<std::uint16_t>(value >> 8U);
@@ -31,7 +53,7 @@ byte_swap(std::uint16_t value) -> std::uint16_t
 }
 
 static constexpr auto
-byte_swap(std::uint32_t value) -> std::uint32_t
+swap_bytes(std::uint32_t value) -> std::uint32_t
 {
   std::uint32_t byte0 = value & 0x000000ffU;
   std::uint32_t byte1 = value & 0x0000ff00U;
@@ -41,21 +63,156 @@ byte_swap(std::uint32_t value) -> std::uint32_t
 }
 
 static constexpr auto
-byte_swap(std::uint64_t value) -> std::uint64_t
+swap_bytes(std::uint64_t value) -> std::uint64_t
 {
-  std::uint64_t hi = byte_swap(static_cast<std::uint32_t>(value));
-  std::uint32_t lo = byte_swap(static_cast<std::uint32_t>(value >> 32));
+  std::uint64_t hi = swap_bytes(static_cast<std::uint32_t>(value));
+  std::uint32_t lo = swap_bytes(static_cast<std::uint32_t>(value >> 32));
   return (hi << 32) | lo;
 }
+/**
+ * Convert a value between host order and network (big-endian) order, for a host whose byte order
+ * is Order.
+ *
+ * The two directions are the same operation, so one function serves both. On a big-endian host
+ * the value is already in network order and this is the identity; the callers pair it with a
+ * memcpy of the native integer, which on such a host already lays the bytes down big-endian.
+ */
+template<host_order Order>
+static constexpr auto
+convert(std::uint16_t value) -> std::uint16_t
+{
+  if constexpr (Order == host_order::big) {
+    return value;
+  } else {
+    return swap_bytes(value);
+  }
+}
+
+template<host_order Order>
+static constexpr auto
+convert(std::uint32_t value) -> std::uint32_t
+{
+  if constexpr (Order == host_order::big) {
+    return value;
+  } else {
+    return swap_bytes(value);
+  }
+}
+
+template<host_order Order>
+static constexpr auto
+convert(std::uint64_t value) -> std::uint64_t
+{
+  if constexpr (Order == host_order::big) {
+    return value;
+  } else {
+    return swap_bytes(value);
+  }
+}
+} // namespace detail
+
+/**
+ * Reverse the bytes of a value on every host, whatever this host's byte order is.
+ *
+ * This is deliberately not a host/network conversion, and the two are not interchangeable. Use
+ * it only where the byte order of the input is fixed by something other than this host. The one
+ * such case in this codebase is the ${Mutation.CAS} macro, which kvengine writes as
+ * 'macroToString(htonll(info.cas))', so the eight bytes inside that string carry the same order
+ * no matter which host later reads them.
+ */
+static constexpr auto
+reverse_bytes(std::uint16_t value) -> std::uint16_t
+{
+  return detail::swap_bytes(value);
+}
+
+static constexpr auto
+reverse_bytes(std::uint32_t value) -> std::uint32_t
+{
+  return detail::swap_bytes(value);
+}
+
+static constexpr auto
+reverse_bytes(std::uint64_t value) -> std::uint64_t
+{
+  return detail::swap_bytes(value);
+}
+
+// when 'unsigned long long' is not the same as 'std::uint64_t'
+template<typename Dummy = void>
+static constexpr auto
+reverse_bytes(
+  unsigned long long value,
+  std::enable_if_t<!std::is_same_v<unsigned long long, std::uint64_t>, Dummy>* /* dummy */
+  = nullptr) -> std::uint64_t
+{
+  return reverse_bytes(static_cast<std::uint64_t>(value));
+}
+
+/**
+ * Convert a value from this host's byte order to network (big-endian) order, ready to be copied
+ * into a wire buffer.
+ */
+static constexpr auto
+host_to_network(std::uint16_t value) -> std::uint16_t
+{
+  return detail::convert<detail::native_order>(value);
+}
+
+static constexpr auto
+host_to_network(std::uint32_t value) -> std::uint32_t
+{
+  return detail::convert<detail::native_order>(value);
+}
+
+static constexpr auto
+host_to_network(std::uint64_t value) -> std::uint64_t
+{
+  return detail::convert<detail::native_order>(value);
+}
+
+// when 'unsigned long long' is not the same as 'std::uint64_t'
+template<typename Dummy = void>
+static constexpr auto
+host_to_network(
+  unsigned long long value,
+  std::enable_if_t<!std::is_same_v<unsigned long long, std::uint64_t>, Dummy>* /* dummy */
+  = nullptr) -> std::uint64_t
+{
+  return host_to_network(static_cast<std::uint64_t>(value));
+}
+
+/**
+ * Convert a value read out of a wire buffer from network (big-endian) order to this host's byte
+ * order. The inverse of host_to_network, and the same operation.
+ */
+static constexpr auto
+network_to_host(std::uint16_t value) -> std::uint16_t
+{
+  return detail::convert<detail::native_order>(value);
+}
+
+static constexpr auto
+network_to_host(std::uint32_t value) -> std::uint32_t
+{
+  return detail::convert<detail::native_order>(value);
+}
+
+static constexpr auto
+network_to_host(std::uint64_t value) -> std::uint64_t
+{
+  return detail::convert<detail::native_order>(value);
+}
 
 // when 'unsigned long long' is not the same as 'std::uint64_t'
 template<typename Dummy = void>
 static constexpr auto
-byte_swap(unsigned long long value,
-          std::enable_if_t<!std::is_same_v<unsigned long long, std::uint64_t>, Dummy>* /* dummy */ =
-            nullptr) -> std::uint64_t
+network_to_host(
+  unsigned long long value,
+  std::enable_if_t<!std::is_same_v<unsigned long long, std::uint64_t>, Dummy>* /* dummy */
+  = nullptr) -> std::uint64_t
 {
-  return byte_swap(static_cast<std::uint64_t>(value));
+  return network_to_host(static_cast<std::uint64_t>(value));
 }
 
 } // namespace couchbase::core::utils

data/ext/couchbase/core/utils/connection_string.cxx

@@ -15,8 +15,6 @@
  *   limitations under the License.
  */
 
-#include <couchbase/build_config.hxx>
-
 #include "connection_string.hxx"
 #include "core/logger/logger.hxx"
 #include "core/meta/version.hxx"
@@ -91,6 +89,12 @@ struct action<scheme> {
       cs.default_port = 18091;
       cs.default_mode = connection_string::bootstrap_mode::http;
       cs.tls = true;
+    } else if (cs.scheme == "couchbase2") {
+      // Protostellar: the gateway does routing, so there is no MCBP-style config bootstrap.
+      cs.default_port = 18098;
+      cs.default_mode = connection_string::bootstrap_mode::unspecified;
+      cs.tls = true;
+      cs.protocol = connection_string::protocol_type::protostellar;
     } else {
       cs.default_mode = connection_string::bootstrap_mode::unspecified;
       cs.default_port = 0;
@@ -256,37 +260,6 @@ parse_option(io::ip_protocol& receiver,
   }
 }
 
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-void
-parse_option(std::chrono::milliseconds& receiver,
-             const std::string& name,
-             const std::string& value,
-             std::vector<std::string>& warnings)
-{
-  try {
-    receiver = std::chrono::duration_cast<std::chrono::milliseconds>(
-      parse_duration(string_codec::url_decode(value)));
-  } catch (const duration_parse_error& dpe) {
-    warnings.push_back(
-      fmt::format(R"(unable to parse "{}" parameter in connection string (value: "{}"): {})",
-                  name,
-                  value,
-                  dpe.what()));
-  } catch (const std::invalid_argument& ex1) {
-    warnings.push_back(fmt::format(
-      R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})",
-      name,
-      value,
-      ex1.what()));
-  } catch (const std::out_of_range& ex2) {
-    warnings.push_back(fmt::format(
-      R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})",
-      name,
-      value,
-      ex2.what()));
-  }
-}
-#else
 void
 parse_option(tls_verify_mode& receiver,
              const std::string& name,
@@ -354,7 +327,6 @@ parse_option(std::chrono::milliseconds& receiver,
     }
   }
 }
-#endif
 
 void
 extract_options(connection_string& connstr)
@@ -364,55 +336,20 @@ extract_options(connection_string& connstr)
       connstr.bootstrap_nodes[0].type != connection_string::address_type::dns) {
     connstr.options.enable_dns_srv = false;
   }
+  // couchbase2:// never resolves DNS *SRV*: there are no _couchbaseXXX._tcp records for a gateway,
+  // which is addressed directly and does its own routing. This does not turn off name resolution --
+  // ordinary A/AAAA lookup still happens inside gRPC, which is how a CNG cluster behind a network
+  // load balancer is reached (one hostname, one address per instance).
+  //
+  // cluster::open() already returns into open_protostellar() before reaching the DNS SRV branch, so
+  // this changes no behaviour today; it keeps the parsed options honest -- to_json() reports
+  // enable_dns_srv in diagnostics -- and stops the option becoming live if that ordering changes.
+  // Placed with the rule above, before the parameter loop, so an explicit enable_dns_srv= still
+  // wins, same as the single-node rule it sits next to.
+  if (connstr.protocol == connection_string::protocol_type::protostellar) {
+    connstr.options.enable_dns_srv = false;
+  }
   for (const auto& [name, value] : connstr.params) {
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-    if (name == "security.trust_only_pem_file") {
-      /**
-       * Set the trust cert path
-       */
-      parse_option(connstr.options.trust_certificate, name, value, connstr.warnings);
-    } else if (name == "security.disable_server_certificate_verification") {
-      /**
-       * Disable TLS server cert verification if set to true.
-       */
-      if (value == "true" || value == "yes" || value == "on" || value == "1") {
-        connstr.options.tls_verify = tls_verify_mode::none;
-      } else if (value == "false" || value == "no" || value == "off" || value == "0") {
-        connstr.options.tls_verify = tls_verify_mode::peer;
-      } else {
-        connstr.warnings.push_back(fmt::format(
-          R"(unable to parse "{}" parameter in connection string (value "{}" cannot be interpreted as a boolean))",
-          name,
-          value));
-      }
-
-    } else if (name == "timeout.connect_timeout") {
-      /**
-       * The period of time allocated to complete bootstrap
-       */
-      parse_option(connstr.options.bootstrap_timeout, name, value, connstr.warnings);
-    } else if (name == "timeout.dispatch_timeout") {
-      /**
-       * Number of seconds to wait before timing out a Query or N1QL request by the client.
-       */
-      parse_option(connstr.options.dispatch_timeout, name, value, connstr.warnings);
-    } else if (name == "timeout.query_timeout") {
-      /**
-       * Number of seconds to wait before timing out a Query or N1QL request by the client.
-       */
-      parse_option(connstr.options.query_timeout, name, value, connstr.warnings);
-    } else if (name == "timeout.resolve_timeout") {
-      /**
-       * The period of time to resolve DNS name of the node to IP address
-       */
-      parse_option(connstr.options.resolve_timeout, name, value, connstr.warnings);
-    } else if (name == "timeout.socket_connect_timeout") {
-      /**
-       * Number of seconds the client should wait while attempting to connect to a node’s KV service
-       * via a socket. Initial connection, reconnecting, node added, etc.
-       */
-      parse_option(connstr.options.connect_timeout, name, value, connstr.warnings);
-#else
     if (name == "kv_connect_timeout") {
       /**
        * Number of seconds the client should wait while attempting to connect to a node’s KV service
@@ -484,7 +421,6 @@ extract_options(connection_string& connstr)
       if (force_ipv4) {
         connstr.options.use_ip_protocol = io::ip_protocol::force_ipv4;
       }
-#endif
     } else if (name == "ip_protocol") {
       /**
        * Controls preference of IP protocol for name resolution
@@ -524,7 +460,6 @@ extract_options(connection_string& connstr)
       parse_option(connstr.options.enable_clustermap_notification, name, value, connstr.warnings);
     } else if (name == "disable_mozilla_ca_certificates") {
       parse_option(connstr.options.disable_mozilla_ca_certificates, name, value, connstr.warnings);
-#ifndef COUCHBASE_CXX_CLIENT_COLUMNAR
     } else if (name == "max_http_connections") {
       /**
        * The maximum number of HTTP connections allowed on a per-host and per-port basis.  0
@@ -581,7 +516,6 @@ extract_options(connection_string& connstr)
       parse_option(connstr.options.tls_disable_v1_2, name, value, connstr.warnings);
     } else if (name == "server_group") {
       parse_option(connstr.options.server_group, name, value, connstr.warnings);
-#endif
     } else if (name == "enable_app_telemetry") {
       parse_option(connstr.options.enable_app_telemetry, name, value, connstr.warnings);
     } else if (name == "app_telemetry_endpoint") {
@@ -592,12 +526,42 @@ extract_options(connection_string& connstr)
       parse_option(connstr.options.allow_enterprise_analytics, name, value, connstr.warnings);
     } else if (name == "enable_lazy_connections") {
       parse_option(connstr.options.enable_lazy_connections, name, value, connstr.warnings);
+    } else if (name == "log_redaction") {
+      parse_option(connstr.options.log_redaction, name, value, connstr.warnings);
     } else {
       connstr.warnings.push_back(
         fmt::format(R"(unknown parameter "{}" in connection string (value "{}"))", name, value));
     }
   }
 }
+// couchbase2:// addresses one CNG endpoint. The gateway performs routing, so there is no node list
+// to rotate through and no MCBP bootstrap mode to select per node. Reject strings that ask for
+// either instead of silently honouring only the first host. couchbase-jvm-clients does the same,
+// though it validates at transport construction (CoreProtostellar) rather than while parsing; here
+// connection_string already carries an error field, so failing at the parse boundary keeps the
+// diagnosis next to the input that caused it.
+void
+validate_protostellar(connection_string& connstr)
+{
+  if (connstr.error.has_value() ||
+      connstr.protocol != connection_string::protocol_type::protostellar) {
+    return;
+  }
+  if (connstr.bootstrap_nodes.size() != 1) {
+    connstr.error =
+      fmt::format(R"(connection string with scheme "couchbase2" must have exactly one host, )"
+                  R"(but got {}: "{}")",
+                  connstr.bootstrap_nodes.size(),
+                  connstr.input);
+    return;
+  }
+  if (connstr.bootstrap_nodes[0].mode != connection_string::bootstrap_mode::unspecified) {
+    connstr.error =
+      fmt::format(R"(connection string with scheme "couchbase2" does not accept a bootstrap mode )"
+                  R"(suffix, because the gateway does not use MCBP or HTTP config bootstrap: "{}")",
+                  connstr.input);
+  }
+}
 } // namespace
 
 auto
@@ -630,6 +594,7 @@ parse_connection_string(const std::string& input, cluster_options options) -> co
     }
   }
   extract_options(res);
+  validate_protostellar(res);
   return res;
 }
 } // namespace couchbase::core::utils

data/ext/couchbase/core/utils/connection_string.hxx

@@ -34,6 +34,13 @@ struct connection_string {
     http,
   };
 
+  // Which client protocol the scheme selects. The classic MCBP stack (couchbase/couchbases/
+  // http/https) versus the Protostellar gRPC transport (couchbase2).
+  enum class protocol_type {
+    mcbp,
+    protostellar,
+  };
+
   enum class address_type {
     ipv4,
     ipv6,
@@ -68,9 +75,17 @@ struct connection_string {
   std::optional<std::string> default_bucket_name{};
   bootstrap_mode default_mode{ connection_string::bootstrap_mode::gcccp };
   std::uint16_t default_port{ 11210 };
+  protocol_type protocol{ protocol_type::mcbp };
 
   std::vector<std::string> warnings{};
   std::optional<std::string> error{};
+
+  // True for the couchbase2:// (Protostellar) transport. The upper layer branches on this to
+  // pick the gRPC client instead of the MCBP stack.
+  [[nodiscard]] auto uses_protostellar() const -> bool
+  {
+    return protocol == protocol_type::protostellar;
+  }
 };
 
 auto

data/ext/couchbase/core/{columnar/backoff_calculator.hxx → utils/deadline.hxx}

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2024. Couchbase, Inc.
+ *   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.
@@ -17,18 +17,18 @@
 
 #pragma once
 
+#include <algorithm>
 #include <chrono>
-#include <functional>
 
-namespace couchbase::core::columnar
+namespace couchbase::core::utils
 {
-using backoff_calculator = std::function<std::chrono::milliseconds(std::size_t retry_attempts)>;
-
-auto
-exponential_backoff_with_full_jitter(std::chrono::milliseconds min_backoff,
-                                     std::chrono::milliseconds max_backoff,
-                                     double backoff_factor) -> backoff_calculator;
-
-auto
-default_backoff_calculator(std::size_t retry_attempts) -> std::chrono::milliseconds;
-} // namespace couchbase::core::columnar
+// The time from now until `deadline`, as a request timeout. At least a millisecond: a zero timeout
+// means "use the default".
+inline auto
+remaining_until(std::chrono::steady_clock::time_point deadline) -> std::chrono::milliseconds
+{
+  return std::max(std::chrono::duration_cast<std::chrono::milliseconds>(
+                    deadline - std::chrono::steady_clock::now()),
+                  std::chrono::milliseconds{ 1 });
+}
+} // namespace couchbase::core::utils

data/ext/couchbase/core/utils/duration_parser.cxx

@@ -40,7 +40,7 @@ leading_int(std::string& s, std::int64_t& v) -> bool
       return false;
     }
 
-    v = v * 10 + static_cast<std::int64_t>(c) - '0';
+    v = (v * 10) + static_cast<std::int64_t>(c) - '0';
 
     if (v < 0) {
       return false;

data/ext/couchbase/core/utils/json_streaming_lexer.cxx

@@ -52,9 +52,10 @@ noop_on_meta_header_complete(std::error_code /* ec */, std::string&& /* meta_hea
 #define STATE_MARKER_ROWSET (reinterpret_cast<void*>(2))
 
 struct streaming_lexer_impl {
-  streaming_lexer_impl(jsonsl_t lexer, jsonsl_jpr_t pointer)
+  streaming_lexer_impl(jsonsl_t lexer, jsonsl_jpr_t pointer, std::size_t max_buffer)
     : lexer_(lexer)
     , pointer_(pointer)
+    , max_buffer_(max_buffer)
   {
   }
 
@@ -90,8 +91,8 @@ struct streaming_lexer_impl {
     state->data = STATE_MARKER_ROOT;
   }
 
-  [[nodiscard]] auto get_buffer_region(std::size_t pos,
-                                       std::size_t desired = 0) const -> std::string_view
+  [[nodiscard]] auto get_buffer_region(std::size_t pos, std::size_t desired = 0) const
+    -> std::string_view
   {
     if (min_pos_ > pos) {
       /* swallowed */
@@ -149,6 +150,8 @@ struct streaming_lexer_impl {
   std::function<void(std::error_code, std::size_t, std::string&&)> on_complete_{ noop_on_complete };
   std::function<stream_control(std::string&&)> on_row_{ noop_on_row };
   bool root_has_been_validated_{ false };
+  std::size_t max_buffer_{ 0 };
+  bool aborted_{ false };
 };
 } // namespace detail
 
@@ -264,6 +267,10 @@ error_callback(jsonsl_t lexer,
   return 0;
 }
 
+// NOLINTBEGIN(misc-const-correctness): these are jsonsl stack callbacks whose signatures must match
+// jsonsl_stack_callback exactly (void(jsonsl_t, jsonsl_action_t, struct jsonsl_state_st*, const
+// char*)); the state pointer cannot be const or the assignment to action_callback_* would be
+// ill-formed.
 void
 meta_header_complete_callback(jsonsl_t lexer,
                               jsonsl_action_t /* action */,
@@ -307,6 +314,9 @@ trailer_pop_callback(jsonsl_t lexer,
   impl->on_meta_header_complete_ = detail::noop_on_meta_header_complete;
 
   impl->on_complete_({}, impl->number_of_rows_, std::move(impl->meta_buffer_));
+  // Reset so trailing bytes after a well-formed document (which would drive error_callback) cannot
+  // fire a second terminal, mirroring the reset applied to on_meta_header_complete_ above.
+  impl->on_complete_ = detail::noop_on_complete;
 }
 
 void
@@ -399,9 +409,12 @@ initial_action_push_callback(jsonsl_t lexer,
     state->data = STATE_MARKER_ROWSET;
   }
 }
+// NOLINTEND(misc-const-correctness)
 } // namespace
 
-json::streaming_lexer::streaming_lexer(const std::string& pointer_expression, std::uint32_t depth)
+json::streaming_lexer::streaming_lexer(const std::string& pointer_expression,
+                                       std::uint32_t depth,
+                                       std::size_t max_buffer)
 {
   jsonsl_error_t error = JSONSL_ERROR_SUCCESS;
   jsonsl_jpr_t ptr = jsonsl_jpr_new(pointer_expression.c_str(), &error);
@@ -413,7 +426,7 @@ json::streaming_lexer::streaming_lexer(const std::string& pointer_expression, st
                                 jsonsl_strerror(error));
   }
 
-  impl_ = std::make_shared<detail::streaming_lexer_impl>(jsonsl_new(512), ptr);
+  impl_ = std::make_shared<detail::streaming_lexer_impl>(jsonsl_new(512), ptr, max_buffer);
   impl_->lexer_->data = impl_.get();
   impl_->lexer_->action_callback_PUSH = initial_action_push_callback;
   impl_->lexer_->action_callback_POP = initial_action_pop_callback;
@@ -426,7 +439,37 @@ json::streaming_lexer::streaming_lexer(const std::string& pointer_expression, st
 void
 streaming_lexer::feed(std::string_view data)
 {
+  if (impl_->aborted_) {
+    return;
+  }
+
+  /* Enforce the single-row / trailer buffer ceiling BEFORE appending, so a huge chunk that has not
+   * yet been parsed cannot grow buffer_ (and OOM the process) before the ceiling is detected. The
+   * un-consumed portion is everything buffered since the last keep_position_ trim — buffer_.size()
+   * minus the bytes already consumed — plus the incoming chunk about to be appended.
+   *
+   * This bounds the trailing metadata too: after the last row, keep_position_
+   * stops advancing, so the accumulating trailer counts as un-consumed and trips
+   * this same ceiling. Rows and trailer are therefore each capped at max_buffer_.
+   */
+  if (impl_->max_buffer_ != 0) {
+    const auto consumed = impl_->keep_position_ - impl_->min_pos_;
+    const auto unconsumed = impl_->buffer_.size() > consumed ? impl_->buffer_.size() - consumed : 0;
+    if (unconsumed + data.size() > impl_->max_buffer_) {
+      impl_->aborted_ = true;
+      impl_->error_ = errc::streaming_json_lexer::generic;
+
+      impl_->on_meta_header_complete_(impl_->error_, {});
+      impl_->on_meta_header_complete_ = detail::noop_on_meta_header_complete;
+
+      impl_->on_complete_(impl_->error_, impl_->number_of_rows_, {});
+      impl_->on_complete_ = detail::noop_on_complete;
+      return;
+    }
+  }
+
   impl_->buffer_.append(data);
+
   jsonsl_feed(impl_->lexer_, data.data(), data.size());
 
   /* Do we need to cut off some bytes? */

data/ext/couchbase/core/utils/json_streaming_lexer.hxx

@@ -23,6 +23,7 @@
 
 #include "movable_function.hxx"
 
+#include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <memory>
@@ -50,7 +51,9 @@ public:
    *
    * @throws std::invalid_argument if pointer cannot be created from the expression.
    */
-  streaming_lexer(const std::string& pointer_expression, std::uint32_t depth);
+  streaming_lexer(const std::string& pointer_expression,
+                  std::uint32_t depth,
+                  std::size_t max_buffer = 0);
 
   void feed(std::string_view data);