couchbase 3.0.0.alpha.2-universal-darwin-19 → 3.0.0-universal-darwin-19

data/ext/couchbase/operations/document_view.hxx

@@ -0,0 +1,228 @@
+/* -*- 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

@@ -28,7 +28,7 @@ struct query_index_build_deferred_response {
         std::uint64_t code;
         std::string message;
     };
-    uuid::uuid_t client_context_id;
+    std::string client_context_id;
     std::error_code ec;
     std::string status{};
     std::vector<query_problem> errors{};
@@ -41,8 +41,9 @@ struct query_index_build_deferred_request {
 
     static const inline service_type type = service_type::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    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)
     {
@@ -52,7 +53,7 @@ struct query_index_build_deferred_request {
               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) }
+            { "client_context_id", client_context_id }
         };
         encoded.method = "POST";
         encoded.path = "/query/service";

data/ext/couchbase/operations/query_index_create.hxx

@@ -28,7 +28,7 @@ struct query_index_create_response {
         std::uint64_t code;
         std::string message;
     };
-    uuid::uuid_t client_context_id;
+    std::string client_context_id;
     std::error_code ec;
     std::string status{};
     std::vector<query_problem> errors{};
@@ -41,8 +41,11 @@ struct query_index_create_request {
 
     static const inline service_type type = service_type::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    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> fields;
     bool is_primary{ false };
@@ -50,6 +53,7 @@ struct query_index_create_request {
     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)
     {
@@ -69,18 +73,25 @@ struct query_index_create_request {
         if (with) {
             with_clause = fmt::format("WITH {}", tao::json::to_string(with));
         }
+        std::string keyspace = fmt::format("{}:`{}`", namespace_id, bucket_name);
+        if (!scope_name.empty()) {
+            keyspace += ".`" + scope_name + "`";
+        }
+        if (!collection_name.empty()) {
+            keyspace += ".`" + collection_name + "`";
+        }
         tao::json::value body{ { "statement",
-                                 is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON `{}` USING GSI {})",
+                                 is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON {} USING GSI {})",
                                                           index_name.empty() ? "" : fmt::format("`{}`", index_name),
-                                                          bucket_name,
+                                                          keyspace,
                                                           with_clause)
-                                            : fmt::format(R"(CREATE INDEX `{}` ON `{}`({}) {} USING GSI {})",
+                                            : fmt::format(R"(CREATE INDEX `{}` ON {}({}) {} USING GSI {})",
                                                           index_name,
-                                                          bucket_name,
+                                                          keyspace,
                                                           fmt::join(fields, ", "),
                                                           where_clause,
                                                           with_clause) },
-                               { "client_context_id", uuid::to_string(client_context_id) } };
+                               { "client_context_id", client_context_id } };
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);

data/ext/couchbase/operations/query_index_drop.hxx

@@ -28,7 +28,7 @@ struct query_index_drop_response {
         std::uint64_t code;
         std::string message;
     };
-    uuid::uuid_t client_context_id;
+    std::string client_context_id;
     std::error_code ec;
     std::string status{};
     std::vector<query_problem> errors{};
@@ -41,19 +41,30 @@ struct query_index_drop_request {
 
     static const inline service_type type = service_type::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    static constexpr auto namespace_id = "default";
     std::string bucket_name;
+    std::string scope_name;
+    std::string collection_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";
+        std::string keyspace = fmt::format("`{}`", bucket_name);
+        if (!scope_name.empty()) {
+            keyspace += ".`" + scope_name + "`";
+        }
+        if (!collection_name.empty()) {
+            keyspace += ".`" + collection_name + "`";
+        }
         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) } };
+                                 is_primary ? fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace)
+                                            : fmt::format(R"(DROP INDEX {}.`{}` USING GSI)", keyspace, index_name) },
+                               { "client_context_id", client_context_id } };
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);

data/ext/couchbase/operations/query_index_get_all.hxx

@@ -32,11 +32,14 @@ struct query_index_get_all_response {
         std::string datastore_id;
         std::string keyspace_id;
         std::string namespace_id;
+        std::string collection_name;
         std::string type;
         std::vector<std::string> index_key{};
         std::optional<std::string> condition{};
+        std::optional<std::string> bucket_id{};
+        std::optional<std::string> scope_id{};
     };
-    uuid::uuid_t client_context_id;
+    std::string client_context_id;
     std::error_code ec;
     std::string status{};
     std::vector<query_index> indexes{};
@@ -49,8 +52,9 @@ struct query_index_get_all_request {
 
     static const inline service_type type = service_type::query;
 
-    uuid::uuid_t client_context_id{ uuid::random() };
+    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)
     {
@@ -58,9 +62,9 @@ struct query_index_get_all_request {
         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) }
+                R"(SELECT idx.* FROM system:indexes AS idx WHERE ((keyspace_id = "{}" AND bucket_id IS MISSING) OR (bucket_id = "{}")) AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
+                bucket_name, bucket_name) },
+            { "client_context_id", client_context_id }
         };
         encoded.method = "POST";
         encoded.path = "/query/service";
@@ -86,6 +90,12 @@ make_response(std::error_code ec, query_index_get_all_request& request, query_in
                     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("bucket_id")) {
+                        index.bucket_id = prop->get_string();
+                    }
+                    if (const auto* prop = entry.find("scope_id")) {
+                        index.scope_id = prop->get_string();
+                    }
                     if (const auto* prop = entry.find("is_primary")) {
                         index.is_primary = prop->get_boolean();
                     }

data/ext/couchbase/operations/scope_create.hxx

@@ -27,6 +27,7 @@ namespace couchbase::operations
 {
 
 struct scope_create_response {
+    std::string client_context_id;
     std::error_code ec;
     std::uint64_t uid{ 0 };
 };
@@ -40,6 +41,8 @@ struct scope_create_request {
 
     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)
     {
@@ -51,9 +54,9 @@ struct scope_create_request {
 };
 
 scope_create_response
-make_response(std::error_code ec, scope_create_request&, scope_create_request::encoded_response_type encoded)
+make_response(std::error_code ec, scope_create_request& request, scope_create_request::encoded_response_type encoded)
 {
-    scope_create_response response{ ec };
+    scope_create_response response{ request.client_context_id, ec };
     if (!ec) {
         switch (encoded.status_code) {
             case 400:

data/ext/couchbase/operations/scope_drop.hxx

@@ -27,6 +27,7 @@ namespace couchbase::operations
 {
 
 struct scope_drop_response {
+    std::string client_context_id;
     std::error_code ec;
     std::uint64_t uid{ 0 };
 };
@@ -40,6 +41,8 @@ struct scope_drop_request {
 
     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)
     {
@@ -49,9 +52,9 @@ struct scope_drop_request {
 };
 
 scope_drop_response
-make_response(std::error_code ec, scope_drop_request&, scope_drop_request::encoded_response_type encoded)
+make_response(std::error_code ec, scope_drop_request& request, scope_drop_request::encoded_response_type encoded)
 {
-    scope_drop_response response{ ec };
+    scope_drop_response response{ request.client_context_id, ec };
     if (!ec) {
         switch (encoded.status_code) {
             case 400: