couchbase 4.3.1 → 4.4.1-dev.1

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <couchbase/key_value_error_context.hxx>
+#include "core/error_context/key_value_error_context.hxx"
 
 #include "core/io/mcbp_context.hxx"
 #include "core/io/retry_context.hxx"
@@ -28,36 +28,41 @@
 namespace couchbase::core::impl
 {
 struct observe_seqno_response {
-    key_value_error_context ctx{};
-    bool active;
-    std::uint16_t partition{};
-    std::uint64_t partition_uuid{};
-    std::uint64_t last_persisted_sequence_number{};
-    std::uint64_t current_sequence_number{};
-    std::optional<std::uint64_t> old_partition_uuid{};
-    std::optional<std::uint64_t> last_received_sequence_number{};
-
-    [[nodiscard]] bool failed_over() const
-    {
-        return old_partition_uuid.has_value();
-    }
+  key_value_error_context ctx{};
+  bool active;
+  std::uint16_t partition{};
+  std::uint64_t partition_uuid{};
+  std::uint64_t last_persisted_sequence_number{};
+  std::uint64_t current_sequence_number{};
+  std::optional<std::uint64_t> old_partition_uuid{};
+  std::optional<std::uint64_t> last_received_sequence_number{};
+
+  [[nodiscard]] auto failed_over() const -> bool
+  {
+    return old_partition_uuid.has_value();
+  }
 };
 
 struct observe_seqno_request {
-    using response_type = observe_seqno_response;
-    using encoded_request_type = core::protocol::client_request<core::protocol::observe_seqno_request_body>;
-    using encoded_response_type = core::protocol::client_response<core::protocol::observe_seqno_response_body>;
+  using response_type = observe_seqno_response;
+  using encoded_request_type =
+    core::protocol::client_request<core::protocol::observe_seqno_request_body>;
+  using encoded_response_type =
+    core::protocol::client_response<core::protocol::observe_seqno_response_body>;
 
-    core::document_id id;
-    bool active;
-    std::uint64_t partition_uuid;
-    std::optional<std::chrono::milliseconds> timeout{};
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    io::retry_context<true> retries{};
+  core::document_id id;
+  bool active;
+  std::uint64_t partition_uuid;
+  std::optional<std::chrono::milliseconds> timeout{};
+  std::uint16_t partition{};
+  std::uint32_t opaque{};
+  io::retry_context<true> retries{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, core::mcbp_context&& context);
+  [[nodiscard]] auto encode_to(encoded_request_type& encoded,
+                               core::mcbp_context&& context) -> std::error_code;
 
-    [[nodiscard]] observe_seqno_response make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] auto make_response(key_value_error_context&& ctx,
+                                   const encoded_response_type& encoded) const
+    -> observe_seqno_response;
 };
 } // namespace couchbase::core::impl

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

@@ -26,17 +26,17 @@ namespace couchbase
 auto
 phrase_query::encode() const -> encoded_search_query
 {
-    encoded_search_query built;
-    built.query = tao::json::empty_object;
-    if (boost_) {
-        built.query["boost"] = boost_.value();
-    }
+  encoded_search_query built;
+  built.query = tao::json::empty_object;
+  if (boost_) {
+    built.query["boost"] = boost_.value();
+  }
 
-    built.query["terms"] = terms_;
-    if (field_) {
-        built.query["field"] = field_.value();
-    }
+  built.query["terms"] = terms_;
+  if (field_) {
+    built.query["field"] = field_.value();
+  }
 
-    return built;
+  return built;
 }
 } // namespace couchbase

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

@@ -24,17 +24,17 @@ namespace couchbase
 auto
 prefix_query::encode() const -> encoded_search_query
 {
-    encoded_search_query built;
-    built.query = tao::json::empty_object;
-    if (boost_) {
-        built.query["boost"] = boost_.value();
-    }
+  encoded_search_query built;
+  built.query = tao::json::empty_object;
+  if (boost_) {
+    built.query["boost"] = boost_.value();
+  }
 
-    built.query["prefix"] = prefix_;
-    if (field_) {
-        built.query["field"] = field_.value();
-    }
+  built.query["prefix"] = prefix_;
+  if (field_) {
+    built.query["field"] = field_.value();
+  }
 
-    return built;
+  return built;
 }
 } // namespace couchbase

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

@@ -20,6 +20,7 @@
 #include <couchbase/transactions/transaction_query_result.hxx>
 
 #include "core/cluster.hxx"
+#include "core/error_context/transaction_op_error_context.hxx"
 #include "core/operations/document_query.hxx"
 #include "core/utils/binary.hxx"
 
@@ -27,197 +28,205 @@ namespace couchbase::core::impl
 {
 namespace
 {
-query_status
-map_status(std::string status)
+auto
+map_status(std::string status) -> query_status
 {
-    std::transform(status.cbegin(), status.cend(), status.begin(), [](unsigned char c) { return std::tolower(c); });
-    if (status == "running") {
-        return query_status::running;
-    } else if (status == "success") {
-        return query_status::success;
-    } else if (status == "errors") {
-        return query_status::errors;
-    } else if (status == "completed") {
-        return query_status::completed;
-    } else if (status == "stopped") {
-        return query_status::stopped;
-    } else if (status == "timeout") {
-        return query_status::timeout;
-    } else if (status == "closed") {
-        return query_status::closed;
-    } else if (status == "fatal") {
-        return query_status::fatal;
-    } else if (status == "aborted") {
-        return query_status::aborted;
-    }
-    return query_status::unknown;
+  std::transform(status.cbegin(), status.cend(), status.begin(), [](unsigned char c) {
+    return std::tolower(c);
+  });
+  if (status == "running") {
+    return query_status::running;
+  } else if (status == "success") {
+    return query_status::success;
+  } else if (status == "errors") {
+    return query_status::errors;
+  } else if (status == "completed") {
+    return query_status::completed;
+  } else if (status == "stopped") {
+    return query_status::stopped;
+  } else if (status == "timeout") {
+    return query_status::timeout;
+  } else if (status == "closed") {
+    return query_status::closed;
+  } else if (status == "fatal") {
+    return query_status::fatal;
+  } else if (status == "aborted") {
+    return query_status::aborted;
+  }
+  return query_status::unknown;
 }
 
-std::vector<codec::binary>
-map_rows(operations::query_response& resp)
+auto
+map_rows(operations::query_response& resp) -> std::vector<codec::binary>
 {
-    std::vector<codec::binary> rows;
-    rows.reserve(resp.rows.size());
-    for (const auto& row : resp.rows) {
-        rows.emplace_back(utils::to_binary(row));
-    }
-    return rows;
+  std::vector<codec::binary> rows;
+  rows.reserve(resp.rows.size());
+  for (const auto& row : resp.rows) {
+    rows.emplace_back(utils::to_binary(row));
+  }
+  return rows;
 }
 
-std::vector<query_warning>
-map_warnings(operations::query_response& resp)
+auto
+map_warnings(operations::query_response& resp) -> std::vector<query_warning>
 {
-    std::vector<query_warning> warnings;
-    if (resp.meta.warnings) {
-        warnings.reserve(resp.meta.warnings->size());
-        for (auto& warning : resp.meta.warnings.value()) {
-            warnings.emplace_back(query_warning{
-              warning.code,
-              std::move(warning.message),
-              std::move(warning.reason),
-              std::move(warning.retry),
-            });
-        }
+  std::vector<query_warning> warnings;
+  if (resp.meta.warnings) {
+    warnings.reserve(resp.meta.warnings->size());
+    for (auto& warning : resp.meta.warnings.value()) {
+      warnings.emplace_back(query_warning{
+        warning.code,
+        std::move(warning.message),
+        std::move(warning.reason),
+        std::move(warning.retry),
+      });
     }
-    return warnings;
+  }
+  return warnings;
 }
 
-std::optional<query_metrics>
-map_metrics(operations::query_response& resp)
+auto
+map_metrics(operations::query_response& resp) -> std::optional<query_metrics>
 {
-    if (!resp.meta.metrics) {
-        return {};
-    }
+  if (!resp.meta.metrics) {
+    return {};
+  }
 
-    return query_metrics{
-        resp.meta.metrics->elapsed_time, resp.meta.metrics->execution_time, resp.meta.metrics->result_count,
-        resp.meta.metrics->result_size,  resp.meta.metrics->sort_count,     resp.meta.metrics->mutation_count,
-        resp.meta.metrics->error_count,  resp.meta.metrics->warning_count,
-    };
+  return query_metrics{
+    resp.meta.metrics->elapsed_time, resp.meta.metrics->execution_time,
+    resp.meta.metrics->result_count, resp.meta.metrics->result_size,
+    resp.meta.metrics->sort_count,   resp.meta.metrics->mutation_count,
+    resp.meta.metrics->error_count,  resp.meta.metrics->warning_count,
+  };
 }
 
-std::optional<std::vector<std::byte>>
-map_signature(operations::query_response& resp)
+auto
+map_signature(operations::query_response& resp) -> std::optional<std::vector<std::byte>>
 {
-    if (!resp.meta.signature) {
-        return {};
-    }
-    return utils::to_binary(resp.meta.signature.value());
+  if (!resp.meta.signature) {
+    return {};
+  }
+  return utils::to_binary(resp.meta.signature.value());
 }
 
-std::optional<std::vector<std::byte>>
-map_profile(operations::query_response& resp)
+auto
+map_profile(operations::query_response& resp) -> std::optional<std::vector<std::byte>>
 {
-    if (!resp.meta.profile) {
-        return {};
-    }
-    return utils::to_binary(resp.meta.profile.value());
+  if (!resp.meta.profile) {
+    return {};
+  }
+  return utils::to_binary(resp.meta.profile.value());
 }
 } // namespace
 
-query_error_context
-build_context(operations::query_response& resp)
+auto
+build_context(operations::query_response& resp) -> query_error_context
 {
-    return {
-        resp.ctx.ec,
-        resp.ctx.last_dispatched_to,
-        resp.ctx.last_dispatched_from,
-        resp.ctx.retry_attempts,
-        std::move(resp.ctx.retry_reasons),
-        resp.ctx.first_error_code,
-        std::move(resp.ctx.first_error_message),
-        std::move(resp.ctx.client_context_id),
-        std::move(resp.ctx.statement),
-        std::move(resp.ctx.parameters),
-        std::move(resp.ctx.method),
-        std::move(resp.ctx.path),
-        resp.ctx.http_status,
-        std::move(resp.ctx.http_body),
-        std::move(resp.ctx.hostname),
-        resp.ctx.port,
-    };
+  return {
+    resp.ctx.ec,
+    resp.ctx.last_dispatched_to,
+    resp.ctx.last_dispatched_from,
+    resp.ctx.retry_attempts,
+    std::move(resp.ctx.retry_reasons),
+    resp.ctx.first_error_code,
+    std::move(resp.ctx.first_error_message),
+    std::move(resp.ctx.client_context_id),
+    std::move(resp.ctx.statement),
+    std::move(resp.ctx.parameters),
+    std::move(resp.ctx.method),
+    std::move(resp.ctx.path),
+    resp.ctx.http_status,
+    std::move(resp.ctx.http_body),
+    std::move(resp.ctx.hostname),
+    resp.ctx.port,
+  };
 }
 
-query_result
-build_result(operations::query_response& resp)
+auto
+build_result(operations::query_response& resp) -> query_result
 {
-    return {
-        query_meta_data{
-          std::move(resp.meta.request_id),
-          std::move(resp.meta.client_context_id),
-          map_status(resp.meta.status),
-          map_warnings(resp),
-          map_metrics(resp),
-          map_signature(resp),
-          map_profile(resp),
-        },
-        map_rows(resp),
-    };
+  return {
+    query_meta_data{
+      std::move(resp.meta.request_id),
+      std::move(resp.meta.client_context_id),
+      map_status(resp.meta.status),
+      map_warnings(resp),
+      map_metrics(resp),
+      map_signature(resp),
+      map_profile(resp),
+    },
+    map_rows(resp),
+  };
 }
 
-core::operations::query_request
-build_query_request(std::string statement, std::optional<std::string> query_context, query_options::built options)
+auto
+build_query_request(std::string statement,
+                    std::optional<std::string> query_context,
+                    query_options::built options) -> core::operations::query_request
 {
-    operations::query_request request{
-        std::move(statement),     options.adhoc,
-        options.metrics,          options.readonly,
-        options.flex_index,       options.preserve_expiry,
-        options.use_replica,      options.max_parallelism,
-        options.scan_cap,         options.scan_wait,
-        options.pipeline_batch,   options.pipeline_cap,
-        options.scan_consistency, std::move(options.mutation_state),
-        std::move(query_context), std::move(options.client_context_id),
-        options.timeout,          options.profile,
-    };
-    if (!options.raw.empty()) {
-        for (auto& [name, value] : options.raw) {
-            request.raw[name] = std::move(value);
-        }
+  operations::query_request request{
+    std::move(statement),     options.adhoc,
+    options.metrics,          options.readonly,
+    options.flex_index,       options.preserve_expiry,
+    options.use_replica,      options.max_parallelism,
+    options.scan_cap,         options.scan_wait,
+    options.pipeline_batch,   options.pipeline_cap,
+    options.scan_consistency, std::move(options.mutation_state),
+    std::move(query_context), std::move(options.client_context_id),
+    options.timeout,          options.profile,
+  };
+  if (!options.raw.empty()) {
+    for (auto& [name, value] : options.raw) {
+      request.raw[name] = std::move(value);
     }
-    if (!options.positional_parameters.empty()) {
-        for (auto& value : options.positional_parameters) {
-            request.positional_parameters.emplace_back(std::move(value));
-        }
+  }
+  if (!options.positional_parameters.empty()) {
+    for (auto& value : options.positional_parameters) {
+      request.positional_parameters.emplace_back(std::move(value));
     }
-    if (!options.named_parameters.empty()) {
-        for (auto& [name, value] : options.named_parameters) {
-            request.named_parameters[name] = std::move(value);
-        }
+  }
+  if (!options.named_parameters.empty()) {
+    for (auto& [name, value] : options.named_parameters) {
+      request.named_parameters[name] = std::move(value);
     }
-    return request;
+  }
+  return request;
 }
 
-std::pair<couchbase::transaction_op_error_context, couchbase::transactions::transaction_query_result>
-build_transaction_query_result(operations::query_response resp, std::error_code txn_ec /*defaults to 0*/)
+auto
+build_transaction_query_result(operations::query_response resp,
+                               std::error_code txn_ec /*defaults to 0*/)
+  -> std::pair<couchbase::core::transaction_op_error_context,
+               couchbase::transactions::transaction_query_result>
 {
-    if (resp.ctx.ec) {
-        if (resp.ctx.ec == errc::common::parsing_failure) {
-            txn_ec = errc::transaction_op::parsing_failure;
-        }
-        if (!txn_ec) {
-            // TODO: review what our default should be...
-            // no override error code was passed in, so default to not_set
-            txn_ec = errc::transaction_op::not_set;
-        }
+  if (resp.ctx.ec) {
+    if (resp.ctx.ec == errc::common::parsing_failure) {
+      txn_ec = errc::transaction_op::parsing_failure;
+    }
+    if (!txn_ec) {
+      // TODO: review what our default should be...
+      // no override error code was passed in, so default to not_set
+      txn_ec = errc::transaction_op::generic;
     }
-    return {
-        { txn_ec, build_context(resp) },
-        { query_meta_data{
-            std::move(resp.meta.request_id),
-            std::move(resp.meta.client_context_id),
-            map_status(resp.meta.status),
-            map_warnings(resp),
-            map_metrics(resp),
-            map_signature(resp),
-            map_profile(resp),
-          },
-          map_rows(resp) },
-    };
+  }
+  return {
+    { txn_ec, build_context(resp) },
+    { query_meta_data{
+        std::move(resp.meta.request_id),
+        std::move(resp.meta.client_context_id),
+        map_status(resp.meta.status),
+        map_warnings(resp),
+        map_metrics(resp),
+        map_signature(resp),
+        map_profile(resp),
+      },
+      map_rows(resp) },
+  };
 }
 
-core::operations::query_request
-build_transaction_query_request(query_options::built opts)
+auto
+build_transaction_query_request(query_options::built opts) -> core::operations::query_request
 {
-    return core::impl::build_query_request("", {}, opts);
+  return core::impl::build_query_request("", {}, opts);
 }
 } // namespace couchbase::core::impl

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

@@ -23,12 +23,11 @@
 
 namespace couchbase::core::impl
 {
-core::operations::query_request
-build_query_request(std::string statement, std::optional<std::string> query_context, query_options::built options);
+auto
+build_query_request(std::string statement,
+                    std::optional<std::string> query_context,
+                    query_options::built options) -> core::operations::query_request;
 
-query_result
-build_result(operations::query_response& resp);
-
-query_error_context
-build_context(operations::query_response& resp);
+auto
+build_result(operations::query_response& resp) -> query_result;
 } // namespace couchbase::core::impl

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

@@ -23,33 +23,34 @@ namespace couchbase::core::impl
 {
 
 struct query_error_category : std::error_category {
-    [[nodiscard]] const char* name() const noexcept override
-    {
-        return "couchbase.query";
-    }
-
-    [[nodiscard]] std::string message(int ev) const noexcept override
-    {
-        switch (static_cast<errc::query>(ev)) {
-            case errc::query::planning_failure:
-                return "planning_failure (201)";
-            case errc::query::index_failure:
-                return "index_failure (202)";
-            case errc::query::prepared_statement_failure:
-                return "prepared_statement_failure (203)";
-            case errc::query::dml_failure:
-                return "dml_failure (204)";
-        }
-        return "FIXME: unknown error code (recompile with newer library): couchbase.query." + std::to_string(ev);
+  [[nodiscard]] auto name() const noexcept -> const char* override
+  {
+    return "couchbase.query";
+  }
+
+  [[nodiscard]] auto message(int ev) const noexcept -> std::string override
+  {
+    switch (static_cast<errc::query>(ev)) {
+      case errc::query::planning_failure:
+        return "planning_failure (201)";
+      case errc::query::index_failure:
+        return "index_failure (202)";
+      case errc::query::prepared_statement_failure:
+        return "prepared_statement_failure (203)";
+      case errc::query::dml_failure:
+        return "dml_failure (204)";
     }
+    return "FIXME: unknown error code (recompile with newer library): couchbase.query." +
+           std::to_string(ev);
+  }
 };
 
 const inline static query_error_category query_category_instance;
 
-const std::error_category&
-query_category() noexcept
+auto
+query_category() noexcept -> const std::error_category&
 {
-    return query_category_instance;
+  return query_category_instance;
 }
 
 } // namespace couchbase::core::impl