couchbase 3.5.1 → 3.5.2

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

@@ -27,41 +27,44 @@
 namespace couchbase::core::operations::management
 {
 struct query_index_create_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_create_request {
-    using response_type = query_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 = query_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::query;
+  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;
-    std::string index_name{};
-    std::vector<std::string> keys;
-    query_context query_ctx;
-    bool is_primary{ false };
-    bool ignore_if_exists{ false };
-    std::optional<std::string> condition{};
-    std::optional<bool> deferred{};
-    std::optional<int> num_replicas{};
+  static constexpr auto namespace_id = "default";
+  std::string bucket_name;
+  std::string scope_name;
+  std::string collection_name;
+  std::string index_name{};
+  std::vector<std::string> keys;
+  query_context query_ctx;
+  bool is_primary{ false };
+  bool ignore_if_exists{ false };
+  std::optional<std::string> condition{};
+  std::optional<bool> deferred{};
+  std::optional<int> num_replicas{};
 
-    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_create_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] query_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/query_index_drop.cxx

@@ -29,111 +29,113 @@ namespace couchbase::core::operations::management
 std::error_code
 query_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
 {
-    if (!utils::check_query_management_request(*this)) {
-        return errc::common::invalid_argument;
-    }
-    encoded.headers["content-type"] = "application/json";
-    auto keyspace = utils::build_keyspace(*this);
-    std::string drop_index_stmt;
-    if (is_primary && index_name.empty()) {
-        drop_index_stmt = fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace);
-    } else if (bucket_name.empty() || (!collection_name.empty() && !scope_name.empty())) {
-        drop_index_stmt = fmt::format(R"(DROP INDEX `{}` ON {} USING GSI)", index_name, keyspace);
-    } else {
-        // this works on 6.6 and earlier
-        drop_index_stmt = fmt::format(R"(DROP INDEX `{}`.`{}` USING GSI)", bucket_name, index_name);
-    }
+  if (!utils::check_query_management_request(*this)) {
+    return errc::common::invalid_argument;
+  }
+  encoded.headers["content-type"] = "application/json";
+  auto keyspace = utils::build_keyspace(*this);
+  std::string drop_index_stmt;
+  if (is_primary && index_name.empty()) {
+    drop_index_stmt = fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace);
+  } else if (bucket_name.empty() || (!collection_name.empty() && !scope_name.empty())) {
+    drop_index_stmt = fmt::format(R"(DROP INDEX `{}` ON {} USING GSI)", index_name, keyspace);
+  } else {
+    // this works on 6.6 and earlier
+    drop_index_stmt = fmt::format(R"(DROP INDEX `{}`.`{}` USING GSI)", bucket_name, index_name);
+  }
 
-    tao::json::value body{ { "statement", drop_index_stmt }, { "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 {};
+  tao::json::value body{ { "statement", drop_index_stmt },
+                         { "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_drop_response
-query_index_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+query_index_drop_request::make_response(error_context::http&& ctx,
+                                        const encoded_response_type& encoded) const
 {
-    query_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.at("status").get_string();
-
-        if (response.status != "success") {
-            bool bucket_not_found = false;
-            bool index_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_drop_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 .*[nN]ot [fF]ound.*" })) {
-                            index_not_found = true;
-                        }
-                        break;
+  query_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.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 bucket_not_found = false;
+      bool index_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_drop_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 .*[nN]ot [fF]ound.*" })) {
+              index_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 12004: /* IKey: "datastore.couchbase.primary_idx_not_found" */
-                    case 12016: /* IKey: "datastore.couchbase.index_not_found" */
-                        index_not_found = true;
-                        break;
+          case 12021:
+            scope_not_found = true;
+            break;
 
-                    case 13014:
-                        if (error.message.find("User does not have credentials") != std::string::npos) {
-                            authentication_failure = true;
-                        }
-                        break;
+          case 12004: /* IKey: "datastore.couchbase.primary_idx_not_found" */
+          case 12016: /* IKey: "datastore.couchbase.index_not_found" */
+            index_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_not_found) {
-                if (!ignore_if_does_not_exist) {
-                    response.ctx.ec = errc::common::index_not_found;
-                }
-            } 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 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_not_found) {
+        if (!ignore_if_does_not_exist) {
+          response.ctx.ec = errc::common::index_not_found;
         }
+      } 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

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

@@ -27,37 +27,39 @@
 namespace couchbase::core::operations::management
 {
 struct query_index_drop_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_drop_request {
-    using response_type = query_index_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 = query_index_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::query;
+  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;
-    std::string index_name;
-    query_context query_ctx;
-    bool is_primary{ false };
-    bool ignore_if_does_not_exist{ false };
+  static constexpr auto namespace_id = "default";
+  std::string bucket_name;
+  std::string scope_name;
+  std::string collection_name;
+  std::string index_name;
+  query_context query_ctx;
+  bool is_primary{ false };
+  bool ignore_if_does_not_exist{ false };
 
-    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_drop_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] query_index_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/query_index_get_all.cxx

@@ -23,111 +23,115 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-query_index_get_all_request::encode_to(encoded_request_type& encoded, couchbase::core::http_context& /* context */) const
+query_index_get_all_request::encode_to(encoded_request_type& encoded,
+                                       couchbase::core::http_context& /* context */) const
 {
-    std::string bucket_cond = "bucket_id = $bucket_name";
-    std::string scope_cond = "(" + bucket_cond + " AND scope_id = $scope_name)";
-    std::string collection_cond = "(" + scope_cond + " AND keyspace_id = $collection_name)";
+  std::string bucket_cond = "bucket_id = $bucket_name";
+  std::string scope_cond = "(" + bucket_cond + " AND scope_id = $scope_name)";
+  std::string collection_cond = "(" + scope_cond + " AND keyspace_id = $collection_name)";
 
-    std::string where;
-    if (!collection_name.empty()) {
-        where = collection_cond;
-    } else if (!scope_name.empty()) {
-        where = scope_cond;
-    } else {
-        where = bucket_cond;
-    }
+  std::string where;
+  if (!collection_name.empty()) {
+    where = collection_cond;
+  } else if (!scope_name.empty()) {
+    where = scope_cond;
+  } else {
+    where = bucket_cond;
+  }
 
-    if (collection_name == "_default" || collection_name.empty()) {
-        std::string default_collection_cond = "(bucket_id IS MISSING AND keyspace_id = $bucket_name)";
-        where = "(" + where + " OR " + default_collection_cond + ")";
-    }
+  if (collection_name == "_default" || collection_name.empty()) {
+    std::string default_collection_cond = "(bucket_id IS MISSING AND keyspace_id = $bucket_name)";
+    where = "(" + where + " OR " + default_collection_cond + ")";
+  }
 
-    std::string statement = "SELECT `idx`.* FROM system:indexes AS idx"
-                            " WHERE " +
-                            where +
-                            " AND `using` = \"gsi\""
-                            " ORDER BY is_primary DESC, name ASC";
+  std::string statement = "SELECT `idx`.* FROM system:indexes AS idx"
+                          " WHERE " +
+                          where +
+                          " AND `using` = \"gsi\""
+                          " ORDER BY is_primary DESC, name ASC";
 
-    encoded.headers["content-type"] = "application/json";
-    tao::json::value body{ { "statement", statement },
-                           { "client_context_id", encoded.client_context_id },
-                           { "$bucket_name", query_ctx.has_value() ? query_ctx.bucket_name() : bucket_name },
-                           { "$scope_name", query_ctx.has_value() ? query_ctx.scope_name() : scope_name },
-                           { "$collection_name", collection_name } };
+  encoded.headers["content-type"] = "application/json";
+  tao::json::value body{
+    { "statement", statement },
+    { "client_context_id", encoded.client_context_id },
+    { "$bucket_name", query_ctx.has_value() ? query_ctx.bucket_name() : bucket_name },
+    { "$scope_name", query_ctx.has_value() ? query_ctx.scope_name() : scope_name },
+    { "$collection_name", collection_name }
+  };
 
-    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 (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_get_all_response
-query_index_get_all_request::make_response(couchbase::core::error_context::http&& ctx, const encoded_response_type& encoded) const
+query_index_get_all_request::make_response(couchbase::core::error_context::http&& ctx,
+                                           const encoded_response_type& encoded) const
 {
-    query_index_get_all_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        if (encoded.status_code != 200) {
-            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-            return response;
-        }
-        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") {
-            return response;
-        }
-        if (encoded.body.data().find("insufficient user permissions") != std::string::npos) {
-            response.ctx.ec = couchbase::errc::common::authentication_failure;
-            return response;
-        }
-        for (const auto& entry : payload.at("results").get_array()) {
-            couchbase::management::query_index index;
-            index.type = entry.at("using").get_string();
-            index.name = entry.at("name").get_string();
-            index.state = entry.at("state").get_string();
-            if (const auto* prop = entry.find("is_primary")) {
-                index.is_primary = prop->get_boolean();
-            }
-            if (const auto* prop = entry.find("condition")) {
-                index.condition = prop->get_string();
-            }
-            if (const auto* prop = entry.find("partition")) {
-                index.partition = prop->get_string();
-            }
-            for (const auto& key : entry.at("index_key").get_array()) {
-                index.index_key.emplace_back(key.get_string());
-            }
+  query_index_get_all_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    if (encoded.status_code != 200) {
+      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      return response;
+    }
+    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") {
+      return response;
+    }
+    if (encoded.body.data().find("insufficient user permissions") != std::string::npos) {
+      response.ctx.ec = couchbase::errc::common::authentication_failure;
+      return response;
+    }
+    for (const auto& entry : payload.at("results").get_array()) {
+      couchbase::management::query_index index;
+      index.type = entry.at("using").get_string();
+      index.name = entry.at("name").get_string();
+      index.state = entry.at("state").get_string();
+      if (const auto* prop = entry.find("is_primary")) {
+        index.is_primary = prop->get_boolean();
+      }
+      if (const auto* prop = entry.find("condition")) {
+        index.condition = prop->get_string();
+      }
+      if (const auto* prop = entry.find("partition")) {
+        index.partition = prop->get_string();
+      }
+      for (const auto& key : entry.at("index_key").get_array()) {
+        index.index_key.emplace_back(key.get_string());
+      }
 
-            std::string bucket_id, scope_id, keyspace_id;
-            if (const auto* prop = entry.find("bucket_id")) {
-                bucket_id = prop->get_string();
-            }
-            if (const auto* prop = entry.find("scope_id")) {
-                scope_id = prop->get_string();
-            }
-            if (const auto* prop = entry.find("keyspace_id")) {
-                keyspace_id = prop->get_string();
-            }
-            if (bucket_id.empty()) {
-                index.bucket_name = keyspace_id;
-            } else {
-                index.bucket_name = bucket_id;
-                index.scope_name = scope_id;
-                index.collection_name = keyspace_id;
-            }
+      std::string bucket_id, scope_id, keyspace_id;
+      if (const auto* prop = entry.find("bucket_id")) {
+        bucket_id = prop->get_string();
+      }
+      if (const auto* prop = entry.find("scope_id")) {
+        scope_id = prop->get_string();
+      }
+      if (const auto* prop = entry.find("keyspace_id")) {
+        keyspace_id = prop->get_string();
+      }
+      if (bucket_id.empty()) {
+        index.bucket_name = keyspace_id;
+      } else {
+        index.bucket_name = bucket_id;
+        index.scope_name = scope_id;
+        index.collection_name = keyspace_id;
+      }
 
-            response.indexes.emplace_back(index);
-        }
+      response.indexes.emplace_back(index);
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -28,29 +28,32 @@
 namespace couchbase::core::operations::management
 {
 struct query_index_get_all_response {
-    error_context::http ctx;
-    std::string status{};
-    std::vector<couchbase::management::query_index> indexes{};
+  error_context::http ctx;
+  std::string status{};
+  std::vector<couchbase::management::query_index> indexes{};
 };
 
 struct query_index_get_all_request {
-    using response_type = query_index_get_all_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";
-
-    std::string bucket_name;
-    std::string scope_name;
-    std::string collection_name;
-    query_context query_ctx;
-    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]] query_index_get_all_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  using response_type = query_index_get_all_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";
+
+  std::string bucket_name;
+  std::string scope_name;
+  std::string collection_name;
+  query_context query_ctx;
+  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]] query_index_get_all_response make_response(
+    error_context::http&& ctx,
+    const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management