couchbase 3.0.0.alpha.5-x86_64-linux → 3.5.0-x86_64-linux

data/ext/couchbase/operations/document_view.hxx

@@ -1,228 +0,0 @@
-/* -*- 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 <operations/design_document.hxx>
-#include <utils/url_codec.hxx>
-
-namespace couchbase::operations
-{
-struct document_view_response {
-    struct meta_data {
-        std::optional<std::uint64_t> total_rows{};
-        std::optional<std::string> debug_info{};
-    };
-
-    struct row {
-        std::optional<std::string> id;
-        std::string key;
-        std::string value;
-    };
-
-    struct problem {
-        std::string code;
-        std::string message;
-    };
-
-    std::string client_context_id;
-    std::error_code ec;
-    document_view_response::meta_data meta_data{};
-    std::vector<document_view_response::row> rows{};
-    std::optional<problem> error{};
-};
-
-struct document_view_request {
-    using response_type = document_view_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-
-    static const inline service_type type = service_type::views;
-
-    std::string client_context_id{ uuid::to_string(uuid::random()) };
-    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
-
-    std::string bucket_name;
-    std::string document_name;
-    std::string view_name;
-    design_document::name_space name_space;
-
-    std::optional<std::uint64_t> limit;
-    std::optional<std::uint64_t> skip;
-
-    enum class scan_consistency {
-        not_bounded,
-        update_after,
-        request_plus,
-    };
-    std::optional<scan_consistency> consistency;
-
-    std::vector<std::string> keys;
-
-    std::optional<std::string> key;
-    std::optional<std::string> start_key;
-    std::optional<std::string> end_key;
-    std::optional<std::string> start_key_doc_id;
-    std::optional<std::string> end_key_doc_id;
-    std::optional<bool> inclusive_end;
-
-    std::optional<bool> reduce;
-    std::optional<bool> group;
-    std::optional<std::uint32_t> group_level;
-    bool debug{ false };
-
-    enum class sort_order { ascending, descending };
-    std::optional<sort_order> order;
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        std::vector<std::string> query_string;
-
-        if (debug) {
-            query_string.emplace_back("debug=true");
-        }
-        if (limit) {
-            query_string.emplace_back(fmt::format("limit={}", *limit));
-        }
-        if (skip) {
-            query_string.emplace_back(fmt::format("skip={}", *skip));
-        }
-        if (consistency) {
-            switch (*consistency) {
-                case scan_consistency::not_bounded:
-                    query_string.emplace_back("stale=ok");
-                    break;
-                case scan_consistency::update_after:
-                    query_string.emplace_back("stale=update_after");
-                    break;
-                case scan_consistency::request_plus:
-                    query_string.emplace_back("stale=false");
-                    break;
-            }
-        }
-        if (key) {
-            query_string.emplace_back(fmt::format("key={}", utils::string_codec::form_encode(*key)));
-        }
-        if (start_key) {
-            query_string.emplace_back(fmt::format("start_key={}", utils::string_codec::form_encode(*start_key)));
-        }
-        if (end_key) {
-            query_string.emplace_back(fmt::format("end_key={}", utils::string_codec::form_encode(*end_key)));
-        }
-        if (start_key_doc_id) {
-            query_string.emplace_back(fmt::format("start_key_doc_id={}", utils::string_codec::form_encode(*start_key_doc_id)));
-        }
-        if (end_key_doc_id) {
-            query_string.emplace_back(fmt::format("end_key_doc_id={}", utils::string_codec::form_encode(*end_key_doc_id)));
-        }
-        if (inclusive_end) {
-            query_string.emplace_back(fmt::format("inclusive_end={}", inclusive_end.value() ? "true" : "false"));
-        }
-        if (reduce) {
-            query_string.emplace_back(fmt::format("reduce={}", reduce.value() ? "true" : "false"));
-        }
-        if (group) {
-            query_string.emplace_back(fmt::format("group={}", group.value() ? "true" : "false"));
-        }
-        if (group_level) {
-            query_string.emplace_back(fmt::format("group_level={}", *group_level));
-        }
-        if (order) {
-            switch (*order) {
-                case sort_order::descending:
-                    query_string.emplace_back("descending=true");
-                    break;
-                case sort_order::ascending:
-                    query_string.emplace_back("descending=false");
-                    break;
-            }
-        }
-
-        tao::json::value body = tao::json::empty_object;
-        if (!keys.empty()) {
-            tao::json::value keys_array = tao::json::empty_array;
-            for (const auto& entry : keys) {
-                keys_array.push_back(tao::json::from_string(entry));
-            }
-            body["keys"] = keys_array;
-        }
-
-        encoded.type = type;
-        encoded.method = "POST";
-        encoded.headers["content-type"] = "application/json";
-        encoded.path = fmt::format("/{}/_design/{}{}/_view/{}?{}",
-                                   bucket_name,
-                                   name_space == design_document::name_space::development ? "dev_" : "",
-                                   document_name,
-                                   view_name,
-                                   fmt::join(query_string, "&"));
-        encoded.body = tao::json::to_string(body);
-    }
-};
-
-document_view_response
-make_response(std::error_code ec, document_view_request& request, document_view_request::encoded_response_type encoded)
-{
-    document_view_response response{ request.client_context_id, ec };
-    if (!ec) {
-        if (encoded.status_code == 200) {
-            tao::json::value payload = tao::json::from_string(encoded.body);
-            const auto* total_rows = payload.find("total_rows");
-            if (total_rows != nullptr && total_rows->is_unsigned()) {
-                response.meta_data.total_rows = total_rows->get_unsigned();
-            }
-            const auto* debug_info = payload.find("debug_info");
-            if (debug_info != nullptr && debug_info->is_object()) {
-                response.meta_data.debug_info.emplace(tao::json::to_string(*debug_info));
-            }
-            const auto* rows = payload.find("rows");
-            if (rows != nullptr && rows->is_array()) {
-                for (const auto& entry : rows->get_array()) {
-                    document_view_response::row row{};
-                    const auto* id = entry.find("id");
-                    if (id != nullptr && id->is_string()) {
-                        row.id = id->get_string();
-                    }
-                    row.key = tao::json::to_string(entry.at("key"));
-                    row.value = tao::json::to_string(entry.at("value"));
-                    response.rows.emplace_back(row);
-                }
-            }
-        } else if (encoded.status_code == 400) {
-            tao::json::value payload = tao::json::from_string(encoded.body);
-            document_view_response::problem problem{};
-            const auto* error = payload.find("error");
-            if (error != nullptr && error->is_string()) {
-                problem.code = error->get_string();
-            }
-            const auto* reason = payload.find("reason");
-            if (reason != nullptr && reason->is_string()) {
-                problem.message = reason->get_string();
-            }
-            response.error.emplace(problem);
-            response.ec = std::make_error_code(error::common_errc::invalid_argument);
-        } else if (encoded.status_code == 404) {
-            response.ec = std::make_error_code(error::view_errc::design_document_not_found);
-        } else {
-            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
-        }
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/query_index_build_deferred.hxx

@@ -1,86 +0,0 @@
-/* -*- 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_build_deferred_response {
-    struct query_problem {
-        std::uint64_t code;
-        std::string message;
-    };
-    uuid::uuid_t client_context_id;
-    std::error_code ec;
-    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;
-
-    static const inline service_type type = service_type::query;
-
-    uuid::uuid_t client_context_id{ 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"(BUILD INDEX ON `{}` ((SELECT RAW name FROM system:indexes WHERE keyspace_id = "{}" AND state = "deferred")))",
-                          bucket_name,
-                          bucket_name) },
-            { "client_context_id", uuid::to_string(client_context_id) }
-        };
-        encoded.method = "POST";
-        encoded.path = "/query/service";
-        encoded.body = tao::json::to_string(body);
-    }
-};
-
-query_index_build_deferred_response
-make_response(std::error_code ec,
-              query_index_build_deferred_request& request,
-              query_index_build_deferred_request::encoded_response_type encoded)
-{
-    query_index_build_deferred_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") {
-            for (const auto& entry : payload.at("errors").get_array()) {
-                query_index_build_deferred_response::query_problem error;
-                error.code = entry.at("code").get_unsigned();
-                error.message = entry.at("msg").get_string();
-                response.errors.emplace_back(error);
-            }
-            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
-        }
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/query_index_create.hxx

@@ -1,135 +0,0 @@
-/* -*- 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;
-    };
-    uuid::uuid_t 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;
-
-    uuid::uuid_t client_context_id{ 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", uuid::to_string(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

@@ -1,109 +0,0 @@
-/* -*- 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;
-    };
-    uuid::uuid_t 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;
-
-    uuid::uuid_t client_context_id{ 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", uuid::to_string(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

@@ -1,107 +0,0 @@
-/* -*- 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{};
-    };
-    uuid::uuid_t 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;
-
-    uuid::uuid_t client_context_id{ 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", uuid::to_string(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