couchbase 1.3.15 → 3.0.0.alpha.5

data/ext/couchbase/mutation_token.hxx

@@ -0,0 +1,38 @@
+/* -*- 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
+
+namespace couchbase
+{
+struct mutation_token {
+    uint64_t partition_uuid{ 0 };
+    uint64_t sequence_number{ 0 };
+    uint16_t partition_id{ 0 };
+    std::string bucket_name{};
+};
+} // namespace couchbase
+
+template<>
+struct fmt::formatter<couchbase::mutation_token> : formatter<std::string> {
+    template<typename FormatContext>
+    auto format(const couchbase::mutation_token& token, FormatContext& ctx)
+    {
+        format_to(ctx.out(), "{}:{}:{}:{}", token.bucket_name, token.partition_id, token.partition_uuid, token.sequence_number);
+        return formatter<std::string>::format("", ctx);
+    }
+};

data/ext/couchbase/operations.hxx

@@ -0,0 +1,91 @@
+/* -*- 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 <document_id.hxx>
+#include <timeout_defaults.hxx>
+
+#include <operations/document_get.hxx>
+#include <operations/document_get_and_lock.hxx>
+#include <operations/document_get_and_touch.hxx>
+#include <operations/document_insert.hxx>
+#include <operations/document_upsert.hxx>
+#include <operations/document_replace.hxx>
+#include <operations/document_remove.hxx>
+#include <operations/document_lookup_in.hxx>
+#include <operations/document_mutate_in.hxx>
+#include <operations/document_touch.hxx>
+#include <operations/document_exists.hxx>
+#include <operations/document_unlock.hxx>
+#include <operations/document_increment.hxx>
+#include <operations/document_decrement.hxx>
+#include <operations/document_get_projected.hxx>
+
+#include <operations/document_query.hxx>
+#include <operations/document_search.hxx>
+#include <operations/document_analytics.hxx>
+#include <operations/document_view.hxx>
+
+#include <operations/bucket_get_all.hxx>
+#include <operations/bucket_get.hxx>
+#include <operations/bucket_drop.hxx>
+#include <operations/bucket_flush.hxx>
+#include <operations/bucket_create.hxx>
+#include <operations/bucket_update.hxx>
+
+#include <operations/scope_get_all.hxx>
+#include <operations/scope_create.hxx>
+#include <operations/scope_drop.hxx>
+#include <operations/collection_create.hxx>
+#include <operations/collection_drop.hxx>
+
+#include <operations/cluster_developer_preview_enable.hxx>
+
+#include <operations/query_index_get_all.hxx>
+#include <operations/query_index_drop.hxx>
+#include <operations/query_index_create.hxx>
+#include <operations/query_index_build_deferred.hxx>
+
+#include <operations/search_index_get_all.hxx>
+#include <operations/search_index_get.hxx>
+#include <operations/search_index_get_documents_count.hxx>
+#include <operations/search_index_upsert.hxx>
+#include <operations/search_index_drop.hxx>
+#include <operations/search_index_control_ingest.hxx>
+#include <operations/search_index_control_query.hxx>
+#include <operations/search_index_control_plan_freeze.hxx>
+#include <operations/search_index_analyze_document.hxx>
+
+#include <operations/analytics_get_pending_mutations.hxx>
+#include <operations/analytics_dataverse_create.hxx>
+#include <operations/analytics_dataverse_drop.hxx>
+#include <operations/analytics_dataset_create.hxx>
+#include <operations/analytics_dataset_drop.hxx>
+#include <operations/analytics_dataset_get_all.hxx>
+#include <operations/analytics_index_get_all.hxx>
+#include <operations/analytics_index_create.hxx>
+#include <operations/analytics_index_drop.hxx>
+#include <operations/analytics_link_connect.hxx>
+#include <operations/analytics_link_disconnect.hxx>
+
+#include <operations/view_index_get_all.hxx>
+#include <operations/view_index_get.hxx>
+#include <operations/view_index_drop.hxx>
+#include <operations/view_index_upsert.hxx>
+
+#include <operations/command.hxx>

data/ext/couchbase/operations/analytics_dataset_create.hxx

@@ -0,0 +1,117 @@
+/* -*- 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 analytics_dataset_create_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_dataset_create_request {
+    using response_type = analytics_dataset_create_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::analytics;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    std::string dataverse_name{ "Default" };
+    std::string dataset_name;
+    std::string bucket_name;
+
+    std::optional<std::string> condition{};
+
+    bool ignore_if_exists{ false };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        std::string where_clause = condition ? fmt::format("WHERE {}", *condition) : "";
+        std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
+
+        tao::json::value body{
+            { "statement",
+              fmt::format(
+                "CREATE DATASET `{}`.`{}` ON `{}` {} {}", dataverse_name, dataset_name, bucket_name, where_clause, if_not_exists_clause) },
+        };
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = "/analytics/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_dataset_create_response
+make_response(std::error_code ec,
+              analytics_dataset_create_request& request,
+              analytics_dataset_create_request::encoded_response_type encoded)
+{
+    analytics_dataset_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 dataset_exists = false;
+            bool link_not_found = false;
+
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_dataset_create_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24040: /* A dataset with name [string] already exists in dataverse [string] */
+                            dataset_exists = true;
+                            break;
+                        case 24006: /* Link [string] does not exist */
+                            link_not_found = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (dataset_exists) {
+                response.ec = std::make_error_code(error::analytics_errc::dataset_exists);
+            } else if (link_not_found) {
+                response.ec = std::make_error_code(error::analytics_errc::link_not_found);
+            } else {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/analytics_dataset_drop.hxx

@@ -0,0 +1,103 @@
+/* -*- 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 analytics_dataset_drop_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_dataset_drop_request {
+    using response_type = analytics_dataset_drop_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+
+    static const inline service_type type = service_type::analytics;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    std::string dataverse_name{ "Default" };
+    std::string dataset_name;
+
+    bool ignore_if_does_not_exist{ false };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
+
+        tao::json::value body{
+            { "statement", fmt::format("DROP DATASET `{}`.`{}` {}", dataverse_name, dataset_name, if_exists_clause) },
+        };
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = "/analytics/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_dataset_drop_response
+make_response(std::error_code ec, analytics_dataset_drop_request& request, analytics_dataset_drop_request::encoded_response_type encoded)
+{
+    analytics_dataset_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 dataset_does_not_exist = false;
+
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_dataset_drop_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
+                            dataset_does_not_exist = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (dataset_does_not_exist) {
+                response.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
+            } else {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            }
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/analytics_dataset_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 analytics_dataset_get_all_response {
+    struct dataset {
+        std::string name;
+        std::string dataverse_name;
+        std::string link_name;
+        std::string bucket_name;
+    };
+
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    std::string client_context_id;
+    std::error_code ec;
+    std::string status{};
+    std::vector<dataset> datasets{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_dataset_get_all_request {
+    using response_type = analytics_dataset_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::analytics;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        tao::json::value body{
+            { "statement", "SELECT d.* FROM Metadata.`Dataset` d WHERE d.DataverseName <> \"Metadata\"" },
+        };
+        encoded.headers["content-type"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = "/analytics/service";
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+analytics_dataset_get_all_response
+make_response(std::error_code ec,
+              analytics_dataset_get_all_request& request,
+              analytics_dataset_get_all_request::encoded_response_type encoded)
+{
+    analytics_dataset_get_all_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") {
+            auto* results = payload.find("results");
+            if (results != nullptr && results->is_array()) {
+                for (const auto& res : results->get_array()) {
+                    analytics_dataset_get_all_response::dataset ds;
+                    ds.name = res.at("DatasetName").get_string();
+                    ds.dataverse_name = res.at("DataverseName").get_string();
+                    ds.link_name = res.at("LinkName").get_string();
+                    ds.bucket_name = res.at("BucketName").get_string();
+                    response.datasets.emplace_back(ds);
+                }
+            }
+        } else {
+            auto* errors = payload.find("errors");
+            if (errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_dataset_get_all_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    response.errors.emplace_back(err);
+                }
+            }
+            response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations