couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/ext/couchbase/operations/query_index_create.hxx

@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <tao/json.hpp>
+
+#include <version.hxx>
+
+namespace couchbase::operations
+{
+struct query_index_create_response {
+    struct query_problem {
+        std::uint64_t code;
+        std::string message;
+    };
+    std::string client_context_id;
+    std::error_code ec;
+    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;
+
+    static const inline service_type type = service_type::query;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::string bucket_name;
+    std::string index_name{};
+    std::vector<std::string> fields;
+    bool is_primary{ false };
+    bool ignore_if_exists{ false };
+    std::optional<std::string> condition{};
+    std::optional<bool> deferred{};
+    std::optional<int> num_replicas{};
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        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 {}", tao::json::to_string(with));
+        }
+        tao::json::value body{ { "statement",
+                                 is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON `{}` USING GSI {})",
+                                                          index_name.empty() ? "" : fmt::format("`{}`", index_name),
+                                                          bucket_name,
+                                                          with_clause)
+                                            : fmt::format(R"(CREATE INDEX `{}` ON `{}`({}) {} USING GSI {})",
+                                                          index_name,
+                                                          bucket_name,
+                                                          fmt::join(fields, ", "),
+                                                          where_clause,
+                                                          with_clause) },
+                               { "client_context_id", client_context_id } };
+        encoded.method = "POST";
+        encoded.path = "/query/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+query_index_create_response
+make_response(std::error_code ec, query_index_create_request& request, query_index_create_request::encoded_response_type encoded)
+{
+    query_index_create_response response{ request.client_context_id, ec };
+    if (!ec) {
+        auto payload = tao::json::from_string(encoded.body);
+        response.status = payload.at("status").get_string();
+
+        if (response.status != "success") {
+            bool index_already_exists = false;
+            bool bucket_not_found = false;
+            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 (error.message.find(" already exists") != std::string::npos) {
+                            index_already_exists = true;
+                        }
+                        break;
+                    case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
+                        bucket_not_found = true;
+                        break;
+                    case 4300: /* IKey: "plan.new_index_already_exists" */
+                        index_already_exists = true;
+                        break;
+                }
+                response.errors.emplace_back(error);
+            }
+            if (index_already_exists) {
+                if (!request.ignore_if_exists) {
+                    response.ec = std::make_error_code(error::common_errc::index_exists);
+                }
+            } else if (bucket_not_found) {
+                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+            } else if (!response.errors.empty()) {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/query_index_drop.hxx

@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <tao/json.hpp>
+
+#include <version.hxx>
+
+namespace couchbase::operations
+{
+struct query_index_drop_response {
+    struct query_problem {
+        std::uint64_t code;
+        std::string message;
+    };
+    std::string client_context_id;
+    std::error_code ec;
+    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;
+
+    static const inline service_type type = service_type::query;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::string bucket_name;
+    std::string index_name;
+    bool is_primary{ false };
+    bool ignore_if_does_not_exist{ false };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.headers["content-type"] = "application/json";
+        tao::json::value body{ { "statement",
+                                 is_primary ? fmt::format(R"(DROP PRIMARY INDEX ON `{}` USING GSI)", bucket_name)
+                                            : fmt::format(R"(DROP INDEX `{}`.`{}` USING GSI)", bucket_name, index_name) },
+                               { "client_context_id", client_context_id } };
+        encoded.method = "POST";
+        encoded.path = "/query/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+query_index_drop_response
+make_response(std::error_code ec, query_index_drop_request& request, query_index_drop_request::encoded_response_type encoded)
+{
+    query_index_drop_response response{ request.client_context_id, ec };
+    if (!ec) {
+        auto payload = tao::json::from_string(encoded.body);
+        response.status = payload.at("status").get_string();
+
+        if (response.status != "success") {
+            bool bucket_not_found = false;
+            bool index_not_found = false;
+            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 (error.message.find("not found.") != std::string::npos) {
+                            index_not_found = true;
+                        }
+                        break;
+                    case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
+                        bucket_not_found = true;
+                        break;
+                    case 12004: /* IKey: "datastore.couchbase.primary_idx_not_found" */
+                    case 12006: /* IKey: "datastore.couchbase.keyspace_count_error" */
+                        index_not_found = true;
+                        break;
+                }
+                response.errors.emplace_back(error);
+            }
+            if (index_not_found) {
+                if (!request.ignore_if_does_not_exist) {
+                    response.ec = std::make_error_code(error::common_errc::index_not_found);
+                }
+            } else if (bucket_not_found) {
+                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+            } else if (!response.errors.empty()) {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/query_index_get_all.hxx

@@ -0,0 +1,107 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <tao/json.hpp>
+
+#include <version.hxx>
+
+namespace couchbase::operations
+{
+struct query_index_get_all_response {
+    struct query_index {
+        bool is_primary{ false };
+        std::string id;
+        std::string name;
+        std::string state;
+        std::string datastore_id;
+        std::string keyspace_id;
+        std::string namespace_id;
+        std::string type;
+        std::vector<std::string> index_key{};
+        std::optional<std::string> condition{};
+    };
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<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;
+
+    static const inline service_type type = service_type::query;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::string bucket_name;
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.headers["content-type"] = "application/json";
+        tao::json::value body{
+            { "statement",
+              fmt::format(
+                R"(SELECT idx.* FROM system:indexes AS idx WHERE keyspace_id = "{}" AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
+                bucket_name) },
+            { "client_context_id", client_context_id }
+        };
+        encoded.method = "POST";
+        encoded.path = "/query/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+query_index_get_all_response
+make_response(std::error_code ec, query_index_get_all_request& request, query_index_get_all_request::encoded_response_type encoded)
+{
+    query_index_get_all_response response{ request.client_context_id, ec };
+    if (!ec) {
+        if (encoded.status_code == 200) {
+            auto payload = tao::json::from_string(encoded.body);
+            response.status = payload.at("status").get_string();
+            if (response.status == "success") {
+                for (const auto& entry : payload.at("results").get_array()) {
+                    query_index_get_all_response::query_index index;
+                    index.id = entry.at("id").get_string();
+                    index.datastore_id = entry.at("datastore_id").get_string();
+                    index.namespace_id = entry.at("namespace_id").get_string();
+                    index.keyspace_id = entry.at("keyspace_id").get_string();
+                    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();
+                    }
+                    for (const auto& key : entry.at("index_key").get_array()) {
+                        index.index_key.emplace_back(key.get_string());
+                    }
+                    response.indexes.emplace_back(index);
+                }
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/scope_create.hxx

@@ -0,0 +1,84 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <tao/json.hpp>
+
+#include <version.hxx>
+#include <operations/bucket_settings.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations
+{
+
+struct scope_create_response {
+    std::string client_context_id;
+    std::error_code ec;
+    std::uint64_t uid{ 0 };
+};
+
+struct scope_create_request {
+    using response_type = scope_create_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    std::string bucket_name;
+    std::string scope_name;
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "POST";
+        encoded.path = fmt::format("/pools/default/buckets/{}/collections", bucket_name);
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        encoded.body = fmt::format("name={}", utils::string_codec::form_encode(scope_name));
+    }
+};
+
+scope_create_response
+make_response(std::error_code ec, scope_create_request& request, scope_create_request::encoded_response_type encoded)
+{
+    scope_create_response response{ request.client_context_id, ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 400:
+                if (encoded.body.find("Not allowed on this version") != std::string::npos) {
+                    response.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                } else {
+                    response.ec = std::make_error_code(error::management_errc::scope_exists);
+                }
+                break;
+            case 404:
+                response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                break;
+            case 200: {
+                tao::json::value payload = tao::json::from_string(encoded.body);
+                response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
+            } break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/scope_drop.hxx

@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <tao/json.hpp>
+
+#include <version.hxx>
+#include <operations/bucket_settings.hxx>
+#include <utils/url_codec.hxx>
+
+namespace couchbase::operations
+{
+
+struct scope_drop_response {
+    std::string client_context_id;
+    std::error_code ec;
+    std::uint64_t uid{ 0 };
+};
+
+struct scope_drop_request {
+    using response_type = scope_drop_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::management;
+
+    std::string bucket_name;
+    std::string scope_name;
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.method = "DELETE";
+        encoded.path = fmt::format("/pools/default/buckets/{}/collections/{}", bucket_name, scope_name);
+    }
+};
+
+scope_drop_response
+make_response(std::error_code ec, scope_drop_request& request, scope_drop_request::encoded_response_type encoded)
+{
+    scope_drop_response response{ request.client_context_id, ec };
+    if (!ec) {
+        switch (encoded.status_code) {
+            case 400:
+                response.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                break;
+            case 404:
+                if (encoded.body.find("Scope with this name is not found") != std::string::npos) {
+                    response.ec = std::make_error_code(error::common_errc::scope_not_found);
+                } else {
+                    response.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                }
+                break;
+            case 200: {
+                tao::json::value payload = tao::json::from_string(encoded.body);
+                response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
+            } break;
+            default:
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                break;
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations