couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/operations/management/analytics_dataverse_drop.cxx

@@ -26,58 +26,63 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-analytics_dataverse_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+analytics_dataverse_drop_request::encode_to(encoded_request_type& encoded,
+                                            http_context& /* context */) const
 {
-    std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
+  std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 
-    tao::json::value body{
-        { "statement", fmt::format("DROP DATAVERSE {} {}", utils::analytics::uncompound_name(dataverse_name), if_exists_clause) },
-    };
-    encoded.headers["content-type"] = "application/json";
-    encoded.method = "POST";
-    encoded.path = "/analytics/service";
-    encoded.body = utils::json::generate(body);
-    return {};
+  tao::json::value body{
+    { "statement",
+      fmt::format("DROP DATAVERSE {} {}",
+                  utils::analytics::uncompound_name(dataverse_name),
+                  if_exists_clause) },
+  };
+  encoded.headers["content-type"] = "application/json";
+  encoded.method = "POST";
+  encoded.path = "/analytics/service";
+  encoded.body = utils::json::generate(body);
+  return {};
 }
 
 analytics_dataverse_drop_response
-analytics_dataverse_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+analytics_dataverse_drop_request::make_response(error_context::http&& ctx,
+                                                const encoded_response_type& encoded) const
 {
-    analytics_dataverse_drop_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        tao::json::value payload{};
-        try {
-            payload = utils::json::parse(encoded.body.data());
-        } catch (const tao::pegtl::parse_error&) {
-            response.ctx.ec = errc::common::parsing_failure;
-            return response;
-        }
-        response.status = payload.optional<std::string>("status").value_or("unknown");
+  analytics_dataverse_drop_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    tao::json::value payload{};
+    try {
+      payload = utils::json::parse(encoded.body.data());
+    } catch (const tao::pegtl::parse_error&) {
+      response.ctx.ec = errc::common::parsing_failure;
+      return response;
+    }
+    response.status = payload.optional<std::string>("status").value_or("unknown");
 
-        if (response.status != "success") {
-            bool dataverse_does_not_exist = false;
+    if (response.status != "success") {
+      bool dataverse_does_not_exist = false;
 
-            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
-                for (const auto& error : errors->get_array()) {
-                    analytics_problem err{
-                        error.at("code").as<std::uint32_t>(),
-                        error.at("msg").get_string(),
-                    };
-                    switch (err.code) {
-                        case 24034: /* Cannot find dataverse with name [string] */
-                            dataverse_does_not_exist = true;
-                            break;
-                    }
-                    response.errors.emplace_back(err);
-                }
-            }
-            if (dataverse_does_not_exist) {
-                response.ctx.ec = errc::analytics::dataverse_not_found;
-            } else {
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-            }
+      if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+        for (const auto& error : errors->get_array()) {
+          analytics_problem err{
+            error.at("code").as<std::uint32_t>(),
+            error.at("msg").get_string(),
+          };
+          switch (err.code) {
+            case 24034: /* Cannot find dataverse with name [string] */
+              dataverse_does_not_exist = true;
+              break;
+          }
+          response.errors.emplace_back(err);
         }
+      }
+      if (dataverse_does_not_exist) {
+        response.ctx.ec = errc::analytics::dataverse_not_found;
+      } else {
+        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      }
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/analytics_dataverse_drop.hxx

@@ -27,27 +27,30 @@
 namespace couchbase::core::operations::management
 {
 struct analytics_dataverse_drop_response {
-    error_context::http ctx;
-    std::string status{};
-    std::vector<analytics_problem> errors{};
+  error_context::http ctx;
+  std::string status{};
+  std::vector<analytics_problem> errors{};
 };
 
 struct analytics_dataverse_drop_request {
-    using response_type = analytics_dataverse_drop_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-    using error_context_type = error_context::http;
+  using response_type = analytics_dataverse_drop_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::analytics;
+  static const inline service_type type = service_type::analytics;
 
-    std::string dataverse_name;
+  std::string dataverse_name;
 
-    bool ignore_if_does_not_exist{ false };
-    std::optional<std::string> client_context_id{};
-    std::optional<std::chrono::milliseconds> timeout{};
+  bool ignore_if_does_not_exist{ false };
+  std::optional<std::string> client_context_id{};
+  std::optional<std::chrono::milliseconds> timeout{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& context) const;
 
-    [[nodiscard]] analytics_dataverse_drop_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] analytics_dataverse_drop_response make_response(
+    error_context::http&& ctx,
+    const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/analytics_get_pending_mutations.cxx

@@ -25,47 +25,50 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-analytics_get_pending_mutations_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+analytics_get_pending_mutations_request::encode_to(encoded_request_type& encoded,
+                                                   http_context& /* context */) const
 {
-    encoded.method = "GET";
-    encoded.path = "/analytics/node/agg/stats/remaining";
-    return {};
+  encoded.method = "GET";
+  encoded.path = "/analytics/node/agg/stats/remaining";
+  return {};
 }
 
 analytics_get_pending_mutations_response
-analytics_get_pending_mutations_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+analytics_get_pending_mutations_request::make_response(error_context::http&& ctx,
+                                                       const encoded_response_type& encoded) const
 {
-    analytics_get_pending_mutations_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        tao::json::value payload{};
-        try {
-            payload = utils::json::parse(encoded.body.data());
-        } catch (const tao::pegtl::parse_error&) {
-            response.ctx.ec = errc::common::parsing_failure;
-            return response;
-        }
-        if (encoded.status_code == 200) {
-            if (payload.is_object()) {
-                for (const auto& [dataverse, entry] : payload.get_object()) {
-                    for (const auto& [dataset, counter] : entry.get_object()) {
-                        response.stats.try_emplace(fmt::format("{}.{}", dataverse, dataset), counter.as<std::int64_t>());
-                    }
-                }
-            }
-            return response;
-        }
-        response.status = payload.optional<std::string>("status").value_or("unknown");
-        if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
-            for (const auto& error : errors->get_array()) {
-                analytics_problem err{
-                    error.at("code").as<std::uint32_t>(),
-                    error.at("msg").get_string(),
-                };
-                response.errors.emplace_back(err);
-            }
+  analytics_get_pending_mutations_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    tao::json::value payload{};
+    try {
+      payload = utils::json::parse(encoded.body.data());
+    } catch (const tao::pegtl::parse_error&) {
+      response.ctx.ec = errc::common::parsing_failure;
+      return response;
+    }
+    if (encoded.status_code == 200) {
+      if (payload.is_object()) {
+        for (const auto& [dataverse, entry] : payload.get_object()) {
+          for (const auto& [dataset, counter] : entry.get_object()) {
+            response.stats.try_emplace(fmt::format("{}.{}", dataverse, dataset),
+                                       counter.as<std::int64_t>());
+          }
         }
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      }
+      return response;
+    }
+    response.status = payload.optional<std::string>("status").value_or("unknown");
+    if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+      for (const auto& error : errors->get_array()) {
+        analytics_problem err{
+          error.at("code").as<std::uint32_t>(),
+          error.at("msg").get_string(),
+        };
+        response.errors.emplace_back(err);
+      }
     }
-    return response;
+    response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/analytics_get_pending_mutations.hxx

@@ -27,26 +27,28 @@
 namespace couchbase::core::operations::management
 {
 struct analytics_get_pending_mutations_response {
-    error_context::http ctx;
-    std::string status{};
-    std::vector<analytics_problem> errors{};
-    std::map<std::string, std::int64_t> stats{};
+  error_context::http ctx;
+  std::string status{};
+  std::vector<analytics_problem> errors{};
+  std::map<std::string, std::int64_t> stats{};
 };
 
 struct analytics_get_pending_mutations_request {
-    using response_type = analytics_get_pending_mutations_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-    using error_context_type = error_context::http;
+  using response_type = analytics_get_pending_mutations_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::analytics;
+  static const inline service_type type = service_type::analytics;
 
-    std::optional<std::string> client_context_id{};
-    std::optional<std::chrono::milliseconds> timeout{};
+  std::optional<std::string> client_context_id{};
+  std::optional<std::chrono::milliseconds> timeout{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& context) const;
 
-    [[nodiscard]] analytics_get_pending_mutations_response make_response(error_context::http&& ctx,
-                                                                         const encoded_response_type& encoded) const;
+  [[nodiscard]] analytics_get_pending_mutations_response make_response(
+    error_context::http&& ctx,
+    const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/analytics_index_create.cxx

@@ -25,81 +25,83 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-analytics_index_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+analytics_index_create_request::encode_to(encoded_request_type& encoded,
+                                          http_context& /* context */) const
 {
-    std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
-    std::vector<std::string> field_specs;
-    field_specs.reserve(fields.size());
-    for (const auto& [field_name, field_type] : fields) {
-        field_specs.emplace_back(fmt::format("{}:{}", field_name, field_type));
-    }
+  std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
+  std::vector<std::string> field_specs;
+  field_specs.reserve(fields.size());
+  for (const auto& [field_name, field_type] : fields) {
+    field_specs.emplace_back(fmt::format("{}:{}", field_name, field_type));
+  }
 
-    tao::json::value body{
-        { "statement",
-          fmt::format("CREATE INDEX `{}` {} ON {}.`{}` ({})",
-                      index_name,
-                      if_not_exists_clause,
-                      utils::analytics::uncompound_name(dataverse_name),
-                      dataset_name,
-                      utils::join_strings(field_specs, ",")) },
-    };
-    encoded.headers["content-type"] = "application/json";
-    encoded.method = "POST";
-    encoded.path = "/analytics/service";
-    encoded.body = utils::json::generate(body);
-    return {};
+  tao::json::value body{
+    { "statement",
+      fmt::format("CREATE INDEX `{}` {} ON {}.`{}` ({})",
+                  index_name,
+                  if_not_exists_clause,
+                  utils::analytics::uncompound_name(dataverse_name),
+                  dataset_name,
+                  utils::join_strings(field_specs, ",")) },
+  };
+  encoded.headers["content-type"] = "application/json";
+  encoded.method = "POST";
+  encoded.path = "/analytics/service";
+  encoded.body = utils::json::generate(body);
+  return {};
 }
 
 analytics_index_create_response
-analytics_index_create_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+analytics_index_create_request::make_response(error_context::http&& ctx,
+                                              const encoded_response_type& encoded) const
 {
-    analytics_index_create_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        tao::json::value payload{};
-        try {
-            payload = utils::json::parse(encoded.body.data());
-        } catch (const tao::pegtl::parse_error&) {
-            response.ctx.ec = errc::common::parsing_failure;
-            return response;
-        }
-        response.status = payload.optional<std::string>("status").value_or("unknown");
+  analytics_index_create_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    tao::json::value payload{};
+    try {
+      payload = utils::json::parse(encoded.body.data());
+    } catch (const tao::pegtl::parse_error&) {
+      response.ctx.ec = errc::common::parsing_failure;
+      return response;
+    }
+    response.status = payload.optional<std::string>("status").value_or("unknown");
 
-        if (response.status != "success") {
-            bool index_exists = false;
-            bool dataset_not_found = false;
-            bool link_not_found = false;
+    if (response.status != "success") {
+      bool index_exists = false;
+      bool dataset_not_found = false;
+      bool link_not_found = false;
 
-            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
-                for (const auto& error : errors->get_array()) {
-                    analytics_problem err{
-                        error.at("code").as<std::uint32_t>(),
-                        error.at("msg").get_string(),
-                    };
-                    switch (err.code) {
-                        case 24048: /* An index with this name [string] already exists */
-                            index_exists = true;
-                            break;
-                        case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
-                            dataset_not_found = true;
-                            break;
-                        case 24006: /* Link [string] does not exist */
-                            link_not_found = true;
-                            break;
-                    }
-                    response.errors.emplace_back(err);
-                }
-            }
-            if (index_exists) {
-                response.ctx.ec = errc::common::index_exists;
-            } else if (dataset_not_found) {
-                response.ctx.ec = errc::analytics::dataset_not_found;
-            } else if (link_not_found) {
-                response.ctx.ec = errc::analytics::link_not_found;
-            } else {
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-            }
+      if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+        for (const auto& error : errors->get_array()) {
+          analytics_problem err{
+            error.at("code").as<std::uint32_t>(),
+            error.at("msg").get_string(),
+          };
+          switch (err.code) {
+            case 24048: /* An index with this name [string] already exists */
+              index_exists = true;
+              break;
+            case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
+              dataset_not_found = true;
+              break;
+            case 24006: /* Link [string] does not exist */
+              link_not_found = true;
+              break;
+          }
+          response.errors.emplace_back(err);
         }
+      }
+      if (index_exists) {
+        response.ctx.ec = errc::common::index_exists;
+      } else if (dataset_not_found) {
+        response.ctx.ec = errc::analytics::dataset_not_found;
+      } else if (link_not_found) {
+        response.ctx.ec = errc::analytics::link_not_found;
+      } else {
+        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      }
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/analytics_index_create.hxx

@@ -27,30 +27,33 @@
 namespace couchbase::core::operations::management
 {
 struct analytics_index_create_response {
-    error_context::http ctx;
-    std::string status{};
-    std::vector<analytics_problem> errors{};
+  error_context::http ctx;
+  std::string status{};
+  std::vector<analytics_problem> errors{};
 };
 
 struct analytics_index_create_request {
-    using response_type = analytics_index_create_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-    using error_context_type = error_context::http;
+  using response_type = analytics_index_create_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::analytics;
+  static const inline service_type type = service_type::analytics;
 
-    std::string dataverse_name{ "Default" };
-    std::string dataset_name;
-    std::string index_name;
-    std::map<std::string, std::string> fields;
+  std::string dataverse_name{ "Default" };
+  std::string dataset_name;
+  std::string index_name;
+  std::map<std::string, std::string> fields;
 
-    bool ignore_if_exists{ false };
-    std::optional<std::string> client_context_id{};
-    std::optional<std::chrono::milliseconds> timeout{};
+  bool ignore_if_exists{ false };
+  std::optional<std::string> client_context_id{};
+  std::optional<std::chrono::milliseconds> timeout{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& context) const;
 
-    [[nodiscard]] analytics_index_create_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] analytics_index_create_response make_response(
+    error_context::http&& ctx,
+    const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/analytics_index_drop.cxx

@@ -26,66 +26,71 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-analytics_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+analytics_index_drop_request::encode_to(encoded_request_type& encoded,
+                                        http_context& /* context */) const
 {
-    std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
+  std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 
-    tao::json::value body{
-        { "statement",
-          fmt::format(
-            "DROP INDEX {}.`{}`.`{}` {}", utils::analytics::uncompound_name(dataverse_name), dataset_name, index_name, if_exists_clause) },
-    };
-    encoded.headers["content-type"] = "application/json";
-    encoded.method = "POST";
-    encoded.path = "/analytics/service";
-    encoded.body = utils::json::generate(body);
-    return {};
+  tao::json::value body{
+    { "statement",
+      fmt::format("DROP INDEX {}.`{}`.`{}` {}",
+                  utils::analytics::uncompound_name(dataverse_name),
+                  dataset_name,
+                  index_name,
+                  if_exists_clause) },
+  };
+  encoded.headers["content-type"] = "application/json";
+  encoded.method = "POST";
+  encoded.path = "/analytics/service";
+  encoded.body = utils::json::generate(body);
+  return {};
 }
 
 analytics_index_drop_response
-analytics_index_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+analytics_index_drop_request::make_response(error_context::http&& ctx,
+                                            const encoded_response_type& encoded) const
 {
-    analytics_index_drop_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        tao::json::value payload{};
-        try {
-            payload = utils::json::parse(encoded.body.data());
-        } catch (const tao::pegtl::parse_error&) {
-            response.ctx.ec = errc::common::parsing_failure;
-            return response;
-        }
-        response.status = payload.optional<std::string>("status").value_or("unknown");
+  analytics_index_drop_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    tao::json::value payload{};
+    try {
+      payload = utils::json::parse(encoded.body.data());
+    } catch (const tao::pegtl::parse_error&) {
+      response.ctx.ec = errc::common::parsing_failure;
+      return response;
+    }
+    response.status = payload.optional<std::string>("status").value_or("unknown");
 
-        if (response.status != "success") {
-            bool index_does_not_exist = false;
-            bool dataset_not_found = false;
+    if (response.status != "success") {
+      bool index_does_not_exist = false;
+      bool dataset_not_found = false;
 
-            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
-                for (const auto& error : errors->get_array()) {
-                    analytics_problem err{
-                        error.at("code").as<std::uint32_t>(),
-                        error.at("msg").get_string(),
-                    };
-                    switch (err.code) {
-                        case 24047: /* Cannot find index with name [string] */
-                            index_does_not_exist = true;
-                            break;
-                        case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
-                            dataset_not_found = true;
-                            break;
-                    }
-                    response.errors.emplace_back(err);
-                }
-            }
-            if (index_does_not_exist) {
-                response.ctx.ec = errc::common::index_not_found;
-            } else if (dataset_not_found) {
-                response.ctx.ec = errc::analytics::dataset_not_found;
-            } else {
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-            }
+      if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+        for (const auto& error : errors->get_array()) {
+          analytics_problem err{
+            error.at("code").as<std::uint32_t>(),
+            error.at("msg").get_string(),
+          };
+          switch (err.code) {
+            case 24047: /* Cannot find index with name [string] */
+              index_does_not_exist = true;
+              break;
+            case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
+              dataset_not_found = true;
+              break;
+          }
+          response.errors.emplace_back(err);
         }
+      }
+      if (index_does_not_exist) {
+        response.ctx.ec = errc::common::index_not_found;
+      } else if (dataset_not_found) {
+        response.ctx.ec = errc::analytics::dataset_not_found;
+      } else {
+        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      }
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management