couchbase 3.8.2 → 3.9.1

data/ext/couchbase/core/operations/document_query.cxx

@@ -16,12 +16,11 @@
  */
 
 #include "document_query.hxx"
+#include "query_response_parsing.hxx"
 
 #include "core/cluster_options.hxx"
 #include "core/logger/logger.hxx"
-#include "core/operations/management/error_utils.hxx"
-#include "core/utils/contains_string.hxx"
-#include "core/utils/duration_parser.hxx"
+#include "core/logger/redaction.hxx"
 #include "core/utils/json.hxx"
 
 #include <couchbase/error_codes.hxx>
@@ -31,40 +30,10 @@
 
 namespace couchbase::core::operations
 {
-auto
-query_request::encode_to(query_request::encoded_request_type& encoded, http_context& context)
-  -> std::error_code
+void
+encode_query_options(tao::json::value& body, const query_request& request)
 {
-  ctx_.emplace(context);
-  tao::json::value body{
-    { "client_context_id", encoded.client_context_id },
-  };
-  if (adhoc) {
-    body["statement"] = statement;
-  } else {
-    if (auto entry = ctx_->cache.get(statement)) {
-      body["prepared"] = entry->name;
-      if (entry->plan) {
-        body["encoded_plan"] = entry->plan.value();
-      }
-    } else {
-      body["statement"] = "PREPARE " + statement;
-      if (context.config.capabilities.supports_enhanced_prepared_statements()) {
-        body["auto_execute"] = true;
-      } else {
-        extract_encoded_plan_ = true;
-      }
-    }
-  }
-  auto timeout_for_service = encoded.timeout;
-  if (timeout_for_service > std::chrono::milliseconds(5'000)) {
-    /* if allocated timeout is large enough, tell query engine, that it is 500ms smaller, to make
-     * sure we will always get response */
-    timeout_for_service -= std::chrono::milliseconds(500);
-  }
-  body["timeout"] = fmt::format("{}ms", timeout_for_service.count());
-
-  for (const auto& [name, value] : named_parameters) {
+  for (const auto& [name, value] : request.named_parameters) {
     Expects(name.empty() == false);
     std::string key = name;
     if (key[0] != '$') {
@@ -72,16 +41,16 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
     }
     body[key] = utils::json::parse(value);
   }
-  if (!positional_parameters.empty()) {
+  if (!request.positional_parameters.empty()) {
     std::vector<tao::json::value> parameters;
-    parameters.reserve(positional_parameters.size());
-    for (const auto& value : positional_parameters) {
+    parameters.reserve(request.positional_parameters.size());
+    for (const auto& value : request.positional_parameters) {
       parameters.emplace_back(utils::json::parse(value));
     }
     body["args"] = std::move(parameters);
   }
-  if (profile.has_value()) {
-    switch (profile.value()) {
+  if (request.profile.has_value()) {
+    switch (request.profile.value()) {
       case couchbase::query_profile::phases:
         body["profile"] = "phases";
         break;
@@ -93,44 +62,38 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
         break;
     }
   }
-  if (use_replica.has_value()) {
-    if (context.config.capabilities.supports_read_from_replica()) {
-      if (use_replica.value()) {
-        body["use_replica"] = "on";
-      } else {
-        body["use_replica"] = "off";
-      }
-    } else {
-      return errc::common::feature_not_available;
-    }
+  if (request.use_replica.has_value()) {
+    // The capability gate is enforced by the caller (encode_to for buffered, cluster::query_stream
+    // for streaming); here we only emit the encoded field.
+    body["use_replica"] = request.use_replica.value() ? "on" : "off";
   }
-  if (max_parallelism) {
-    body["max_parallelism"] = std::to_string(max_parallelism.value());
+  if (request.max_parallelism) {
+    body["max_parallelism"] = std::to_string(request.max_parallelism.value());
   }
-  if (pipeline_cap) {
-    body["pipeline_cap"] = std::to_string(pipeline_cap.value());
+  if (request.pipeline_cap) {
+    body["pipeline_cap"] = std::to_string(request.pipeline_cap.value());
   }
-  if (pipeline_batch) {
-    body["pipeline_batch"] = std::to_string(pipeline_batch.value());
+  if (request.pipeline_batch) {
+    body["pipeline_batch"] = std::to_string(request.pipeline_batch.value());
   }
-  if (scan_cap) {
-    body["scan_cap"] = std::to_string(scan_cap.value());
+  if (request.scan_cap) {
+    body["scan_cap"] = std::to_string(request.scan_cap.value());
   }
-  if (!metrics) {
+  if (!request.metrics) {
     body["metrics"] = false;
   }
-  if (readonly) {
+  if (request.readonly) {
     body["readonly"] = true;
   }
-  if (flex_index) {
+  if (request.flex_index) {
     body["use_fts"] = true;
   }
-  if (preserve_expiry) {
+  if (request.preserve_expiry) {
     body["preserve_expiry"] = true;
   }
   bool check_scan_wait = false;
-  if (scan_consistency) {
-    switch (scan_consistency.value()) {
+  if (request.scan_consistency) {
+    switch (request.scan_consistency.value()) {
       case query_scan_consistency::not_bounded:
         body["scan_consistency"] = "not_bounded";
         break;
@@ -139,11 +102,11 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
         body["scan_consistency"] = "request_plus";
         break;
     }
-  } else if (!mutation_state.empty()) {
+  } else if (!request.mutation_state.empty()) {
     check_scan_wait = true;
     body["scan_consistency"] = "at_plus";
     tao::json::value scan_vectors = tao::json::empty_object;
-    for (const auto& token : mutation_state) {
+    for (const auto& token : request.mutation_state) {
       auto* bucket = scan_vectors.find(token.bucket_name());
       if (bucket == nullptr) {
         scan_vectors[token.bucket_name()] = tao::json::empty_object;
@@ -156,16 +119,58 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
     }
     body["scan_vectors"] = scan_vectors;
   }
-  if (check_scan_wait && scan_wait) {
-    body["scan_wait"] = fmt::format("{}ms", scan_wait.value().count());
+  if (check_scan_wait && request.scan_wait) {
+    body["scan_wait"] = fmt::format("{}ms", request.scan_wait.value().count());
   }
-
-  if (query_context) {
-    body["query_context"] = query_context.value();
+  if (request.query_context) {
+    body["query_context"] = request.query_context.value();
   }
-  for (const auto& [name, value] : raw) {
+  for (const auto& [name, value] : request.raw) {
     body[name] = utils::json::parse(value);
   }
+}
+
+auto
+query_request::encode_to(query_request::encoded_request_type& encoded, http_context& context)
+  -> std::error_code
+{
+  ctx_.emplace(context);
+  tao::json::value body{
+    { "client_context_id", encoded.client_context_id },
+  };
+  if (adhoc) {
+    body["statement"] = statement;
+  } else {
+    if (auto entry = ctx_->cache.get(statement)) {
+      body["prepared"] = entry->name;
+      if (entry->plan) {
+        body["encoded_plan"] = entry->plan.value();
+      }
+    } else {
+      body["statement"] = "PREPARE " + statement;
+      if (context.config.capabilities.supports_enhanced_prepared_statements()) {
+        body["auto_execute"] = true;
+      } else {
+        extract_encoded_plan_ = true;
+      }
+    }
+  }
+  auto timeout_for_service = encoded.timeout;
+  if (timeout_for_service > std::chrono::milliseconds(5'000)) {
+    /* if allocated timeout is large enough, tell query engine, that it is 500ms smaller, to make
+     * sure we will always get response */
+    timeout_for_service -= std::chrono::milliseconds(500);
+  }
+  body["timeout"] = fmt::format("{}ms", timeout_for_service.count());
+
+  // use_replica is only honored when the cluster advertises read-from-replica support; reject the
+  // request up front otherwise. The field itself is encoded by encode_query_options below.
+  if (use_replica.has_value() && !context.config.capabilities.supports_read_from_replica()) {
+    return errc::common::feature_not_available;
+  }
+
+  encode_query_options(body, *this);
+
   encoded.type = type;
   encoded.headers["connection"] = "keep-alive";
   encoded.headers["content-type"] = "application/json";
@@ -184,18 +189,21 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
   }
   body.erase("statement");
   body.erase("prepared");
+  // prep is either the prepared statement name or the boolean false, and only the name is user
+  // data. Tagging the boolean hashes a two-value domain to a fixed digest, which hides nothing
+  // and destroys the answer to "was this query prepared?" in a redacted log.
   if (ctx_->options.show_queries) {
     CB_LOG_INFO("QUERY: client_context_id=\"{}\", prep={}, {}, options={}",
                 encoded.client_context_id,
-                utils::json::generate(prep),
-                utils::json::generate(stmt),
-                utils::json::generate(body));
+                logger::user_data_if(prep.is_string(), utils::json::generate(prep)),
+                logger::user_data(utils::json::generate(stmt)),
+                logger::user_data(utils::json::generate(body)));
   } else {
     CB_LOG_DEBUG("QUERY: client_context_id=\"{}\", prep={}, {}, options={}",
                  encoded.client_context_id,
-                 utils::json::generate(prep),
-                 utils::json::generate(stmt),
-                 utils::json::generate(body));
+                 logger::user_data_if(prep.is_string(), utils::json::generate(prep)),
+                 logger::user_data(utils::json::generate(stmt)),
+                 logger::user_data(utils::json::generate(body)));
   }
   if (row_callback) {
     encoded.streaming.emplace(couchbase::core::io::streaming_settings{
@@ -222,6 +230,10 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
           response.ctx.ec = errc::common::service_not_available;
           break;
 
+        case 400:
+          response.ctx.ec = errc::common::invalid_argument;
+          break;
+
         case 500:
         default:
           response.ctx.ec = errc::common::internal_server_failure;
@@ -236,70 +248,18 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    if (const auto* i = payload.find("requestID"); i != nullptr) {
-      response.meta.request_id = i->get_string();
-    }
+    response.meta = parse_query_meta(payload);
 
-    if (const auto* i = payload.find("clientContextID"); i != nullptr) {
-      response.meta.client_context_id = i->get_string();
-      if (response.ctx.client_context_id != response.meta.client_context_id) {
-        CB_LOG_WARNING(R"(unexpected clientContextID returned by service: "{}", expected "{}")",
-                       response.meta.client_context_id,
-                       response.ctx.client_context_id);
-      }
-    }
-    if (const auto* s = payload.find("status"); s != nullptr) {
-      response.meta.status = payload.at("status").get_string();
-    }
-    if (const auto* s = payload.find("signature"); s != nullptr) {
-      response.meta.signature = couchbase::core::utils::json::generate(*s);
+    if (response.ctx.client_context_id != response.meta.client_context_id &&
+        !response.meta.client_context_id.empty()) {
+      CB_LOG_WARNING(R"(unexpected clientContextID returned by service: "{}", expected "{}")",
+                     response.meta.client_context_id,
+                     response.ctx.client_context_id);
     }
+
     if (const auto* c = payload.find("prepared"); c != nullptr) {
       response.prepared = c->get_string();
     }
-    if (const auto* p = payload.find("profile"); p != nullptr) {
-      response.meta.profile = couchbase::core::utils::json::generate(*p);
-    }
-
-    if (const auto* m = payload.find("metrics"); m != nullptr) {
-      query_response::query_metrics meta_metrics{};
-      meta_metrics.result_count = m->at("resultCount").get_unsigned();
-      meta_metrics.result_size = m->at("resultSize").get_unsigned();
-      meta_metrics.elapsed_time = utils::parse_duration(m->at("elapsedTime").get_string());
-      meta_metrics.execution_time = utils::parse_duration(m->at("executionTime").get_string());
-      meta_metrics.sort_count = m->template optional<std::uint64_t>("sortCount").value_or(0);
-      meta_metrics.mutation_count =
-        m->template optional<std::uint64_t>("mutationCount").value_or(0);
-      meta_metrics.error_count = m->template optional<std::uint64_t>("errorCount").value_or(0);
-      meta_metrics.warning_count = m->template optional<std::uint64_t>("warningCount").value_or(0);
-      response.meta.metrics.emplace(meta_metrics);
-    }
-
-    if (const auto* e = payload.find("errors"); e != nullptr) {
-      std::vector<couchbase::core::operations::query_response::query_problem> problems{};
-      for (const auto& err : e->get_array()) {
-        couchbase::core::operations::query_response::query_problem problem;
-        problem.code = err.at("code").get_unsigned();
-        problem.message = err.at("msg").get_string();
-        if (const auto* reason = err.find("reason"); reason != nullptr && reason->is_object()) {
-          problem.reason = reason->optional<std::uint64_t>("code");
-          problem.retry = reason->optional<bool>("retry");
-        }
-        problems.emplace_back(problem);
-      }
-      response.meta.errors.emplace(problems);
-    }
-
-    if (const auto* w = payload.find("warnings"); w != nullptr) {
-      std::vector<couchbase::core::operations::query_response::query_problem> problems{};
-      for (const auto& warn : w->get_array()) {
-        couchbase::core::operations::query_response::query_problem problem;
-        problem.code = warn.at("code").get_unsigned();
-        problem.message = warn.at("msg").get_string();
-        problems.emplace_back(problem);
-      }
-      response.meta.warnings.emplace(problems);
-    }
 
     if (const auto* r = payload.find("results"); r != nullptr) {
       response.rows.reserve(r->get_array().size());
@@ -308,7 +268,8 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
       }
     }
 
-    if (response.meta.status == "success") {
+    // RFC-58: a 400 is a failure whatever status the body reports.
+    if (response.meta.status == "success" && encoded.status_code != 400) {
       if (response.prepared) {
         if (ctx_.has_value()) {
           ctx_->cache.put(statement, response.prepared.value());
@@ -341,22 +302,10 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
       if (response.meta.errors && !response.meta.errors->empty()) {
         response.ctx.first_error_code = response.meta.errors->front().code;
         response.ctx.first_error_message = response.meta.errors->front().message;
+
+        // Prepared-statement codes that require cache eviction + retry must be handled
+        // before delegating to the pure map_query_error classifier.
         switch (response.ctx.first_error_code) {
-          case 1065: /* IKey: "service.io.request.unrecognized_parameter" */
-            if ((response.ctx.first_error_message.find("Unrecognized parameter in request") !=
-                 std::string::npos) &&
-                (response.ctx.first_error_message.find("preserve_expiry") != std::string::npos)) {
-              response.ctx.ec = errc::common::feature_not_available;
-            } else {
-              response.ctx.ec = errc::common::invalid_argument;
-            }
-            break;
-          case 1080: /* IKey: "timeout" */
-            response.ctx.ec = errc::common::unambiguous_timeout;
-            break;
-          case 3000: /* IKey: "parse.syntax_error" */
-            response.ctx.ec = errc::common::parsing_failure;
-            break;
           case 4040: /* IKey: "plan.build_prepared.no_such_name" */
           case 4050: /* IKey: "plan.build_prepared.unrecognized_prepared" */
           case 4070: /* IKey: "plan.build_prepared.decoding" */
@@ -364,80 +313,18 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
               ctx_->cache.erase(statement);
             }
             throw couchbase::core::priv::retry_http_request{};
-          case 4060: /* IKey: "plan.build_prepared.no_such_name" */
-          case 4080: /* IKey: "plan.build_prepared.name_encoded_plan_mismatch" */
-          case 4090: /* IKey: "plan.build_prepared.name_not_in_encoded_plan" */
-            response.ctx.ec = errc::query::prepared_statement_failure;
-            break;
-          case 4300: /* IKey: "plan.new_index_already_exists" */
-            response.ctx.ec = errc::common::index_exists;
-            break;
-          case 5000: /* IKey: "Internal Error" */
-            if (utils::contains_string(response.ctx.first_error_message, "index", true) &&
-                utils::contains_string(response.ctx.first_error_message, "already exist", true)) {
-              response.ctx.ec = errc::common::index_exists;
-            } else if (utils::contains_string(response.ctx.first_error_message,
-                                              "Index does not exist") ||
-                       (utils::contains_string(response.ctx.first_error_message, "index", true) &&
-                        utils::contains_string(
-                          response.ctx.first_error_message, "not found", true))) {
-              response.ctx.ec = errc::common::index_not_found;
-            } else if (response.ctx.first_error_message.find("Bucket Not Found") !=
-                       std::string::npos) {
-              response.ctx.ec = errc::common::bucket_not_found;
-            }
-            break;
-          case 12009: /* IKey: "datastore.couchbase.DML_error" */
-            if (response.ctx.first_error_message.find("CAS mismatch") != std::string::npos) {
-              response.ctx.ec = errc::common::cas_mismatch;
-            } else {
-              switch (response.meta.errors->front().reason.value_or(0)) {
-                case 12033:
-                  response.ctx.ec = errc::common::cas_mismatch;
-                  break;
-                case 17014:
-                  response.ctx.ec = errc::key_value::document_not_found;
-                  break;
-                case 17012:
-                  response.ctx.ec = errc::key_value::document_exists;
-                  break;
-                default:
-                  response.ctx.ec = errc::query::dml_failure;
-                  break;
-              }
-            }
-            break;
-
-          case 12004: /* IKey: "datastore.couchbase.primary_idx_not_found" */
-          case 12016: /* IKey: "datastore.couchbase.index_not_found" */
-            response.ctx.ec = errc::common::index_not_found;
-            break;
-          case 13014: /* IKey: "datastore.couchbase.insufficient_credentials" */
-            response.ctx.ec = errc::common::authentication_failure;
-            break;
           default:
-            if ((response.ctx.first_error_code >= 12000 && response.ctx.first_error_code < 13000) ||
-                (response.ctx.first_error_code >= 14000 && response.ctx.first_error_code < 15000)) {
-              response.ctx.ec = errc::query::index_failure;
-            } else if (response.ctx.first_error_code >= 4000 &&
-                       response.ctx.first_error_code < 5000) {
-              response.ctx.ec = errc::query::planning_failure;
-            }
             break;
         }
-        if (!response.ctx.ec) {
-          auto common_ec = management::extract_common_query_error_code(
-            response.ctx.first_error_code, response.ctx.first_error_message);
-          if (common_ec) {
-            response.ctx.ec = common_ec.value();
-          }
-        }
+
+        response.ctx.ec = map_query_error(response.meta, encoded.status_code);
       }
       if (!response.ctx.ec) {
         CB_LOG_TRACE("Unexpected error returned by query engine: client_context_id=\"{}\", body={}",
                      response.ctx.client_context_id,
-                     encoded.body.data());
-        response.ctx.ec = errc::common::internal_server_failure;
+                     logger::user_data(encoded.body.data()));
+        response.ctx.ec = encoded.status_code == 400 ? errc::common::invalid_argument
+                                                     : errc::common::internal_server_failure;
       }
     }
   }

data/ext/couchbase/core/operations/document_query.hxx

@@ -29,6 +29,8 @@
 
 #include <couchbase/mutation_token.hxx>
 
+#include <tao/json/forward.hpp>
+
 namespace couchbase::tracing
 {
 class request_span;
@@ -36,6 +38,18 @@ class request_span;
 
 namespace couchbase::core::operations
 {
+struct query_request;
+
+/**
+ * Encodes the shared N1QL request-body options (parameters, profile, replica, consistency, raw,
+ * …) common to the buffered and streaming query paths onto @p body. The two paths differ only in
+ * how they set the statement/prepared fields, the timeout, and the capability gate; the option
+ * block is identical and lives here so both paths stay byte-for-byte consistent. `use_replica` is
+ * always encoded when present — the capability gate is the caller's responsibility.
+ */
+void
+encode_query_options(tao::json::value& body, const query_request& request);
+
 struct query_response {
   struct query_metrics {
     std::chrono::nanoseconds elapsed_time{};
@@ -110,11 +124,11 @@ struct query_request {
   std::optional<std::function<utils::json::stream_control(std::string)>> row_callback{};
   std::optional<std::string> send_to_node{};
 
-  [[nodiscard]] auto encode_to(encoded_request_type& encoded,
-                               http_context& context) -> std::error_code;
+  [[nodiscard]] auto encode_to(encoded_request_type& encoded, http_context& context)
+    -> std::error_code;
 
-  [[nodiscard]] auto make_response(error_context::query&& ctx,
-                                   const encoded_response_type& encoded) -> query_response;
+  [[nodiscard]] auto make_response(error_context::query&& ctx, const encoded_response_type& encoded)
+    -> query_response;
 
   std::optional<http_context> ctx_{};
   bool extract_encoded_plan_{ false };

data/ext/couchbase/core/operations/document_search.cxx

@@ -19,7 +19,9 @@
 
 #include "core/cluster_options.hxx"
 #include "core/logger/logger.hxx"
+#include "core/logger/redaction.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 
 #include <couchbase/error_codes.hxx>
 
@@ -31,6 +33,10 @@ auto
 search_request::encode_to(search_request::encoded_request_type& encoded,
                           http_context& context) -> std::error_code
 {
+  if (disable_scoring && !std::holds_alternative<std::monostate>(scoring)) {
+    return errc::common::invalid_argument;
+  }
+
   auto body = tao::json::value{
     { "query", utils::json::parse(query) },
     { "ctl", { { "timeout", encoded.timeout.count() } } },
@@ -66,6 +72,39 @@ search_request::encode_to(search_request::encoded_request_type& encoded,
   if (disable_scoring) {
     body["score"] = "none";
   }
+  if (!std::holds_alternative<std::monostate>(scoring)) {
+    std::optional<std::uint32_t> score_rank_constant{};
+    std::optional<std::uint32_t> score_window_size{};
+    std::visit(
+      [&body, &score_rank_constant, &score_window_size](const auto& value) {
+        using T = std::decay_t<decltype(value)>;
+        if constexpr (std::is_same_v<T, couchbase::core::search_scoring_none>) {
+          body["score"] = "none";
+        } else if constexpr (std::is_same_v<
+                               T,
+                               couchbase::core::search_scoring_reciprocal_rank_fusion>) {
+          body["score"] = "rrf";
+          score_rank_constant = value.rank_constant;
+          score_window_size = value.window_size;
+        } else if constexpr (std::is_same_v<
+                               T,
+                               couchbase::core::search_scoring_relative_score_fusion>) {
+          body["score"] = "rsf";
+          score_window_size = value.window_size;
+        }
+      },
+      scoring);
+    tao::json::value params = tao::json::empty_object;
+    if (score_rank_constant.has_value()) {
+      params["score_rank_constant"] = score_rank_constant.value();
+    }
+    if (score_window_size.has_value()) {
+      params["score_window_size"] = score_window_size.value();
+    }
+    if (!params.get_object().empty()) {
+      body["params"] = params;
+    }
+  }
   if (include_locations) {
     body["includeLocations"] = true;
   }
@@ -126,11 +165,12 @@ search_request::encode_to(search_request::encoded_request_type& encoded,
 
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/query",
-                               bucket_name.value(),
-                               scope_name.value(),
-                               index_name);
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()),
+                               utils::string_codec::v2::path_escape(index_name));
   } else {
-    encoded.path = fmt::format("/api/index/{}/query", index_name);
+    encoded.path =
+      fmt::format("/api/index/{}/query", utils::string_codec::v2::path_escape(index_name));
   }
 
   encoded.type = type;
@@ -139,9 +179,9 @@ search_request::encode_to(search_request::encoded_request_type& encoded,
   body_str = utils::json::generate(body);
   encoded.body = body_str;
   if (context.options.show_queries || (log_request.has_value() && log_request.value())) {
-    CB_LOG_INFO("SEARCH: {}", utils::json::generate(body));
+    CB_LOG_INFO("SEARCH: {}", logger::user_data(utils::json::generate(body)));
   } else {
-    CB_LOG_DEBUG("SEARCH: {}", utils::json::generate(body));
+    CB_LOG_DEBUG("SEARCH: {}", logger::user_data(utils::json::generate(body)));
   }
   if (row_callback) {
     encoded.streaming.emplace(couchbase::core::io::streaming_settings{
@@ -172,7 +212,7 @@ search_request::make_response(error_context::search&& ctx,
         return response;
       }
       if (log_response.has_value() && log_response.value()) {
-        CB_LOG_INFO("SEARCH RESPONSE: {}", utils::json::generate(payload));
+        CB_LOG_INFO("SEARCH RESPONSE: {}", logger::user_data(utils::json::generate(payload)));
       }
       response.meta.metrics.took = std::chrono::nanoseconds(payload.at("took").get_unsigned());
       response.meta.metrics.max_score = payload.at("max_score").as<double>();
@@ -346,7 +386,11 @@ search_request::make_response(error_context::search&& ctx,
         response.ctx.ec = errc::common::quota_limited;
         return response;
       }
-    } else if (encoded.status_code == 429) {
+      // RFC-58: a 400 not mapped above is invalid_argument.
+      response.ctx.ec = errc::common::invalid_argument;
+      return response;
+    }
+    if (encoded.status_code == 429) {
       tao::json::value payload{};
       try {
         payload = utils::json::parse(encoded.body.data());

data/ext/couchbase/core/operations/document_search.hxx

@@ -26,6 +26,7 @@
 #include "core/public_fwd.hxx"
 #include "core/search_highlight_style.hxx"
 #include "core/search_scan_consistency.hxx"
+#include "core/search_scoring.hxx"
 #include "core/timeout_defaults.hxx"
 #include "core/vector_query_combination.hxx"
 
@@ -164,6 +165,8 @@ struct search_request {
   std::optional<bool> log_request{ false };
   std::optional<bool> log_response{ false };
 
+  couchbase::core::search_scoring_mode scoring{};
+
   [[nodiscard]] auto encode_to(encoded_request_type& encoded,
                                http_context& context) -> std::error_code;
 

data/ext/couchbase/core/operations/document_view.cxx

@@ -127,10 +127,10 @@ document_view_request::encode_to(document_view_request::encoded_request_type& en
   encoded.method = "POST";
   encoded.headers["content-type"] = "application/json";
   encoded.path = fmt::format("/{}/_design/{}{}/_view/{}?{}",
-                             bucket_name,
+                             utils::string_codec::v2::path_escape(bucket_name),
                              ns == design_document_namespace::development ? "dev_" : "",
-                             document_name,
-                             view_name,
+                             utils::string_codec::v2::path_escape(document_name),
+                             utils::string_codec::v2::path_escape(view_name),
                              utils::join_strings(query_string, "&"));
   encoded.body = utils::json::generate(body);
   if (row_callback) {