couchbase 3.5.1 → 3.5.2

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

@@ -29,64 +29,69 @@ template<typename Range>
 std::string
 quote_and_join_strings(const Range& values, const std::string& sep)
 {
-    std::stringstream stream;
-    auto sentinel = std::end(values);
-    if (auto it = std::begin(values); it != sentinel) {
-        stream << '`' << *it << '`';
-        ++it;
-        while (it != sentinel) {
-            stream << sep << '`' << *it << '`';
-            ++it;
-        }
+  std::stringstream stream;
+  auto sentinel = std::end(values);
+  if (auto it = std::begin(values); it != sentinel) {
+    stream << '`' << *it << '`';
+    ++it;
+    while (it != sentinel) {
+      stream << sep << '`' << *it << '`';
+      ++it;
     }
-    return stream.str();
+  }
+  return stream.str();
 }
 
 std::error_code
-query_index_build_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+query_index_build_request::encode_to(encoded_request_type& encoded,
+                                     http_context& /* context */) const
 {
-    if (!utils::check_query_management_request(*this)) {
-        return errc::common::invalid_argument;
-    }
-    auto keyspace = core::utils::build_keyspace(*this);
-    std::string statement = fmt::format(R"(BUILD INDEX ON {} ({}))", keyspace, quote_and_join_strings(index_names, ","));
-    encoded.headers["content-type"] = "application/json";
-    tao::json::value body{ { "statement", statement }, { "client_context_id", encoded.client_context_id } };
-    if (query_ctx.has_value()) {
-        body["query_context"] = query_ctx.value();
-    }
-    encoded.method = "POST";
-    encoded.path = "/query/service";
-    encoded.body = utils::json::generate(body);
-    return {};
+  if (!utils::check_query_management_request(*this)) {
+    return errc::common::invalid_argument;
+  }
+  auto keyspace = core::utils::build_keyspace(*this);
+  std::string statement =
+    fmt::format(R"(BUILD INDEX ON {} ({}))", keyspace, quote_and_join_strings(index_names, ","));
+  encoded.headers["content-type"] = "application/json";
+  tao::json::value body{ { "statement", statement },
+                         { "client_context_id", encoded.client_context_id } };
+  if (query_ctx.has_value()) {
+    body["query_context"] = query_ctx.value();
+  }
+  encoded.method = "POST";
+  encoded.path = "/query/service";
+  encoded.body = utils::json::generate(body);
+  return {};
 }
 
 query_index_build_response
-query_index_build_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+query_index_build_request::make_response(error_context::http&& ctx,
+                                         const encoded_response_type& encoded) const
 {
-    query_index_build_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.at("status").get_string();
-        if (response.status != "success") {
-            std::optional<std::error_code> common_ec{};
-            for (const auto& entry : payload.at("errors").get_array()) {
-                query_index_build_response::query_problem error;
-                error.code = entry.at("code").get_unsigned();
-                error.message = entry.at("msg").get_string();
-                response.errors.emplace_back(error);
-                common_ec = management::extract_common_query_error_code(error.code, error.message);
-            }
+  query_index_build_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.at("status").get_string();
+    if (response.status != "success") {
+      std::optional<std::error_code> common_ec{};
+      for (const auto& entry : payload.at("errors").get_array()) {
+        query_index_build_response::query_problem error;
+        error.code = entry.at("code").get_unsigned();
+        error.message = entry.at("msg").get_string();
+        response.errors.emplace_back(error);
+        common_ec = management::extract_common_query_error_code(error.code, error.message);
+      }
 
-            response.ctx.ec = common_ec.value_or(extract_common_error_code(encoded.status_code, encoded.body.data()));
-        }
+      response.ctx.ec =
+        common_ec.value_or(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/query_index_build.hxx

@@ -27,36 +27,39 @@
 namespace couchbase::core::operations::management
 {
 struct query_index_build_response {
-    struct query_problem {
-        std::uint64_t code;
-        std::string message;
-    };
-    error_context::http ctx;
-    std::string status{};
-    std::vector<query_problem> errors{};
+  struct query_problem {
+    std::uint64_t code;
+    std::string message;
+  };
+  error_context::http ctx;
+  std::string status{};
+  std::vector<query_problem> errors{};
 };
 
 struct query_index_build_request {
-    using response_type = query_index_build_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 = query_index_build_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::query;
-    static constexpr auto namespace_id = "default";
+  static const inline service_type type = service_type::query;
+  static constexpr auto namespace_id = "default";
 
-    std::string bucket_name;
-    std::string scope_name;
-    std::string collection_name;
-    query_context query_ctx;
-    std::vector<std::string> index_names;
+  std::string bucket_name;
+  std::string scope_name;
+  std::string collection_name;
+  query_context query_ctx;
+  std::vector<std::string> index_names;
 
-    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]] query_index_build_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] query_index_build_response make_response(
+    error_context::http&& ctx,
+    const encoded_response_type& encoded) const;
 };
 
 } // namespace couchbase::core::operations::management

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

@@ -29,88 +29,96 @@ namespace couchbase::core::operations
 namespace management
 {
 struct query_index_build_deferred_response {
-    struct query_problem {
-        std::uint64_t code{};
-        std::string message{};
-    };
-    error_context::http ctx;
-    std::string status{};
-    std::vector<query_problem> errors{};
+  struct query_problem {
+    std::uint64_t code{};
+    std::string message{};
+  };
+  error_context::http ctx;
+  std::string status{};
+  std::vector<query_problem> errors{};
 };
 
 struct query_index_build_deferred_request {
-    using response_type = query_index_build_deferred_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 = query_index_build_deferred_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    static constexpr auto namespace_id = "default";
+  static constexpr auto namespace_id = "default";
 
-    std::string bucket_name;
-    std::optional<std::string> scope_name;
-    std::optional<std::string> collection_name;
-    query_context query_ctx;
+  std::string bucket_name;
+  std::optional<std::string> scope_name;
+  std::optional<std::string> collection_name;
+  query_context query_ctx;
 
-    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]] response_type make_response(error_context::http&& ctx, const encoded_response_type& /* encoded */) const
-    {
-        return { std::move(ctx) };
-    }
+  [[nodiscard]] response_type make_response(error_context::http&& ctx,
+                                            const encoded_response_type& /* encoded */) const
+  {
+    return { std::move(ctx) };
+  }
 
-    static query_index_build_deferred_response convert_response(operations::management::query_index_get_all_deferred_response resp)
-    {
-        return { std::move(resp.ctx), resp.status };
-    }
+  static query_index_build_deferred_response convert_response(
+    operations::management::query_index_get_all_deferred_response resp)
+  {
+    return { std::move(resp.ctx), resp.status };
+  }
 
-    static query_index_build_deferred_response convert_response(operations::management::query_index_build_response resp)
-    {
-        query_index_build_deferred_response response{ std::move(resp.ctx), resp.status };
-        for (const auto& err : resp.errors) {
-            query_index_build_deferred_response::query_problem error;
-            error.code = err.code;
-            error.message = err.message;
-            response.errors.emplace_back(error);
-        }
-        return response;
+  static query_index_build_deferred_response convert_response(
+    operations::management::query_index_build_response resp)
+  {
+    query_index_build_deferred_response response{ std::move(resp.ctx), resp.status };
+    for (const auto& err : resp.errors) {
+      query_index_build_deferred_response::query_problem error;
+      error.code = err.code;
+      error.message = err.message;
+      response.errors.emplace_back(error);
     }
+    return response;
+  }
 
-    template<typename Core, typename Handler>
-    void execute(Core core, Handler handler)
-    {
-        core->execute(
-          query_index_get_all_deferred_request{
-            bucket_name, scope_name.value_or(""), collection_name.value_or(""), query_ctx, client_context_id, timeout },
-          [core,
-           handler = std::move(handler),
-           bucket_name = bucket_name,
-           scope_name = scope_name.value_or(""),
-           collection_name = collection_name.value_or(""),
-           query_ctx = query_ctx,
-           client_context_id = client_context_id,
-           timeout = timeout](query_index_get_all_deferred_response resp1) mutable {
-              auto list_resp = std::move(resp1);
-              if (list_resp.ctx.ec || list_resp.index_names.empty()) {
-                  return handler(convert_response(std::move(list_resp)));
-              }
-              core->execute(query_index_build_request{ std::move(bucket_name),
-                                                       scope_name,
-                                                       collection_name,
-                                                       query_ctx,
-                                                       std::move(list_resp.index_names),
-                                                       client_context_id,
-                                                       timeout },
-                            [handler = std::move(handler)](query_index_build_response build_resp) mutable {
-                                return handler(convert_response(std::move(build_resp)));
-                            });
-          });
-    }
+  template<typename Core, typename Handler>
+  void execute(Core core, Handler handler)
+  {
+    core->execute(query_index_get_all_deferred_request{ bucket_name,
+                                                        scope_name.value_or(""),
+                                                        collection_name.value_or(""),
+                                                        query_ctx,
+                                                        client_context_id,
+                                                        timeout },
+                  [core,
+                   handler = std::move(handler),
+                   bucket_name = bucket_name,
+                   scope_name = scope_name.value_or(""),
+                   collection_name = collection_name.value_or(""),
+                   query_ctx = query_ctx,
+                   client_context_id = client_context_id,
+                   timeout = timeout](query_index_get_all_deferred_response resp1) mutable {
+                    auto list_resp = std::move(resp1);
+                    if (list_resp.ctx.ec || list_resp.index_names.empty()) {
+                      return handler(convert_response(std::move(list_resp)));
+                    }
+                    core->execute(query_index_build_request{ std::move(bucket_name),
+                                                             scope_name,
+                                                             collection_name,
+                                                             query_ctx,
+                                                             std::move(list_resp.index_names),
+                                                             client_context_id,
+                                                             timeout },
+                                  [handler = std::move(handler)](
+                                    query_index_build_response build_resp) mutable {
+                                    return handler(convert_response(std::move(build_resp)));
+                                  });
+                  });
+  }
 };
 } // namespace management
 
 template<>
-struct is_compound_operation<management::query_index_build_deferred_request> : public std::true_type {
+struct is_compound_operation<management::query_index_build_deferred_request>
+  : public std::true_type {
 };
 
 } // namespace couchbase::core::operations

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

@@ -27,142 +27,148 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-query_index_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+query_index_create_request::encode_to(encoded_request_type& encoded,
+                                      http_context& /* context */) const
 {
-    if (!core::utils::check_query_management_request(*this)) {
-        return errc::common::invalid_argument;
+  if (!core::utils::check_query_management_request(*this)) {
+    return errc::common::invalid_argument;
+  }
+  encoded.headers["content-type"] = "application/json";
+  tao::json::value with{};
+  if (deferred) {
+    with["defer_build"] = *deferred;
+  }
+  if (num_replicas) {
+    with["num_replica"] = *num_replicas; /* no 's' in key name */
+  }
+  std::string where_clause{};
+  if (condition) {
+    where_clause = fmt::format("WHERE {}", *condition);
+  }
+  std::string with_clause{};
+  if (with) {
+    with_clause = fmt::format("WITH {}", utils::json::generate(with));
+  }
+  std::string encoded_keys{};
+  for (std::size_t i = 0; i < keys.size(); i++) {
+    if (i != 0) {
+      encoded_keys += ", ";
     }
-    encoded.headers["content-type"] = "application/json";
-    tao::json::value with{};
-    if (deferred) {
-        with["defer_build"] = *deferred;
-    }
-    if (num_replicas) {
-        with["num_replica"] = *num_replicas; /* no 's' in key name */
-    }
-    std::string where_clause{};
-    if (condition) {
-        where_clause = fmt::format("WHERE {}", *condition);
-    }
-    std::string with_clause{};
-    if (with) {
-        with_clause = fmt::format("WITH {}", utils::json::generate(with));
-    }
-    std::string encoded_keys{};
-    for (std::size_t i = 0; i < keys.size(); i++) {
-        if (i != 0) {
-            encoded_keys += ", ";
-        }
-        auto key = keys.at(i);
+    auto key = keys.at(i);
 
-        // Add backticks around the key unless they are already present
-        if (key.at(0) == '`' && key.at(key.size() - 1) == '`') {
-            encoded_keys += key;
-        } else {
-            encoded_keys += fmt::format("`{}`", key);
-        }
+    // Add backticks around the key unless they are already present
+    if (key.at(0) == '`' && key.at(key.size() - 1) == '`') {
+      encoded_keys += key;
+    } else {
+      encoded_keys += fmt::format("`{}`", key);
     }
-    std::string keyspace = utils::build_keyspace(*this);
-    tao::json::value body{
-        { "statement",
-          is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON {} USING GSI {})",
-                                   index_name.empty() ? "" : fmt::format("`{}`", index_name),
-                                   keyspace,
-                                   with_clause)
-                     : fmt::format(
-                         R"(CREATE INDEX `{}` ON {}({}) {} USING GSI {})", index_name, keyspace, encoded_keys, where_clause, with_clause) },
-        { "client_context_id", encoded.client_context_id }
-    };
-    if (query_ctx.has_value()) {
-        body["query_context"] = query_ctx.value();
-    }
-    encoded.method = "POST";
-    encoded.path = "/query/service";
-    encoded.body = utils::json::generate(body);
-    return {};
+  }
+  std::string keyspace = utils::build_keyspace(*this);
+  tao::json::value body{
+    { "statement",
+      is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON {} USING GSI {})",
+                               index_name.empty() ? "" : fmt::format("`{}`", index_name),
+                               keyspace,
+                               with_clause)
+                 : fmt::format(R"(CREATE INDEX `{}` ON {}({}) {} USING GSI {})",
+                               index_name,
+                               keyspace,
+                               encoded_keys,
+                               where_clause,
+                               with_clause) },
+    { "client_context_id", encoded.client_context_id }
+  };
+  if (query_ctx.has_value()) {
+    body["query_context"] = query_ctx.value();
+  }
+  encoded.method = "POST";
+  encoded.path = "/query/service";
+  encoded.body = utils::json::generate(body);
+  return {};
 }
 
 query_index_create_response
-query_index_create_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+query_index_create_request::make_response(error_context::http&& ctx,
+                                          const encoded_response_type& encoded) const
 {
-    query_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.at("status").get_string();
-
-        if (response.status != "success") {
-            bool index_already_exists = false;
-            bool bucket_not_found = false;
-            bool collection_not_found = false;
-            bool scope_not_found = false;
-            bool authentication_failure = false;
-            std::optional<std::error_code> common_ec{};
-            for (const auto& entry : payload.at("errors").get_array()) {
-                query_index_create_response::query_problem error;
-                error.code = entry.at("code").get_unsigned();
-                error.message = entry.at("msg").get_string();
-                switch (error.code) {
-                    case 5000: /* IKey: "Internal Error" */
-                        if (std::regex_search(error.message, std::regex{ ".*[iI]ndex .*already exist.*" })) {
-                            index_already_exists = true;
-                        }
-                        if (error.message.find("Bucket Not Found") != std::string::npos) {
-                            bucket_not_found = true;
-                        }
-                        break;
+  query_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.at("status").get_string();
 
-                    case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
-                        if (error.message.find("missing_collection") != std::string::npos) {
-                            collection_not_found = true;
-                        } else {
-                            bucket_not_found = true;
-                        }
-                        break;
+    if (response.status != "success") {
+      bool index_already_exists = false;
+      bool bucket_not_found = false;
+      bool collection_not_found = false;
+      bool scope_not_found = false;
+      bool authentication_failure = false;
+      std::optional<std::error_code> common_ec{};
+      for (const auto& entry : payload.at("errors").get_array()) {
+        query_index_create_response::query_problem error;
+        error.code = entry.at("code").get_unsigned();
+        error.message = entry.at("msg").get_string();
+        switch (error.code) {
+          case 5000: /* IKey: "Internal Error" */
+            if (std::regex_search(error.message, std::regex{ ".*[iI]ndex .*already exist.*" })) {
+              index_already_exists = true;
+            }
+            if (error.message.find("Bucket Not Found") != std::string::npos) {
+              bucket_not_found = true;
+            }
+            break;
 
-                    case 12021:
-                        scope_not_found = true;
-                        break;
+          case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
+            if (error.message.find("missing_collection") != std::string::npos) {
+              collection_not_found = true;
+            } else {
+              bucket_not_found = true;
+            }
+            break;
 
-                    case 4300: /* IKey: "plan.new_index_already_exists" */
-                        index_already_exists = true;
-                        break;
-                    case 13014:
-                        if (error.message.find("User does not have credentials") != std::string::npos) {
-                            authentication_failure = true;
-                        }
-                        break;
+          case 12021:
+            scope_not_found = true;
+            break;
 
-                    default:
-                        common_ec = management::extract_common_query_error_code(error.code, error.message);
-                        break;
-                }
-                response.errors.emplace_back(error);
-            }
-            if (index_already_exists) {
-                if (!ignore_if_exists) {
-                    response.ctx.ec = errc::common::index_exists;
-                }
-            } else if (bucket_not_found) {
-                response.ctx.ec = errc::common::bucket_not_found;
-            } else if (collection_not_found) {
-                response.ctx.ec = errc::common::collection_not_found;
-            } else if (scope_not_found) {
-                response.ctx.ec = errc::common::scope_not_found;
-            } else if (authentication_failure) {
-                response.ctx.ec = errc::common::authentication_failure;
-            } else if (common_ec) {
-                response.ctx.ec = common_ec.value();
-            } else if (!response.errors.empty()) {
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+          case 4300: /* IKey: "plan.new_index_already_exists" */
+            index_already_exists = true;
+            break;
+          case 13014:
+            if (error.message.find("User does not have credentials") != std::string::npos) {
+              authentication_failure = true;
             }
+            break;
+
+          default:
+            common_ec = management::extract_common_query_error_code(error.code, error.message);
+            break;
+        }
+        response.errors.emplace_back(error);
+      }
+      if (index_already_exists) {
+        if (!ignore_if_exists) {
+          response.ctx.ec = errc::common::index_exists;
         }
+      } else if (bucket_not_found) {
+        response.ctx.ec = errc::common::bucket_not_found;
+      } else if (collection_not_found) {
+        response.ctx.ec = errc::common::collection_not_found;
+      } else if (scope_not_found) {
+        response.ctx.ec = errc::common::scope_not_found;
+      } else if (authentication_failure) {
+        response.ctx.ec = errc::common::authentication_failure;
+      } else if (common_ec) {
+        response.ctx.ec = common_ec.value();
+      } else if (!response.errors.empty()) {
+        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      }
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management