couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/couchbase/operations/bucket_flush.hxx

@@ -38,7 +38,7 @@ struct bucket_flush_request {
     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)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}/controller/doFlush", name);

data/ext/couchbase/operations/bucket_get.hxx

@@ -42,7 +42,7 @@ struct bucket_get_request {
     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)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path = fmt::format("/pools/default/buckets/{}", name);

data/ext/couchbase/operations/bucket_get_all.hxx

@@ -40,7 +40,7 @@ struct bucket_get_all_request {
     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)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path = "/pools/default/buckets";

data/ext/couchbase/operations/bucket_settings.hxx

@@ -5,7 +5,42 @@ namespace couchbase::operations
 struct bucket_settings {
     enum class bucket_type { unknown, couchbase, memcached, ephemeral };
     enum class compression_mode { unknown, off, active, passive };
-    enum class ejection_policy { unknown, full, value_only };
+    enum class eviction_policy {
+        unknown,
+
+        /**
+         * During ejection, everything (including key, metadata, and value) will be ejected.
+         *
+         * Full Ejection reduces the memory overhead requirement, at the cost of performance.
+         *
+         * This value is only valid for buckets of type COUCHBASE.
+         */
+        full,
+
+        /**
+         * During ejection, only the value will be ejected (key and metadata will remain in memory).
+         *
+         * Value Ejection needs more system memory, but provides better performance than Full Ejection.
+         *
+         * This value is only valid for buckets of type COUCHBASE.
+         */
+        value_only,
+
+        /**
+         * Couchbase Server keeps all data until explicitly deleted, but will reject
+         * any new data if you reach the quota (dedicated memory) you set for your bucket.
+         *
+         * This value is only valid for buckets of type EPHEMERAL.
+         */
+        no_eviction,
+
+        /**
+         * When the memory quota is reached, Couchbase Server ejects data that has not been used recently.
+         *
+         * This value is only valid for buckets of type EPHEMERAL.
+         */
+        not_recently_used,
+    };
     enum class conflict_resolution_type { unknown, timestamp, sequence_number };
     struct node {
         std::string hostname;
@@ -24,7 +59,7 @@ struct bucket_settings {
     std::uint32_t num_replicas{ 1 };
     bool replica_indexes{ false };
     bool flush_enabled{ false };
-    ejection_policy ejection_policy{ ejection_policy::unknown };
+    eviction_policy eviction_policy{ eviction_policy::unknown };
     conflict_resolution_type conflict_resolution_type{ conflict_resolution_type::unknown };
     std::vector<std::string> capabilities{};
     std::vector<node> nodes{};
@@ -68,9 +103,13 @@ struct traits<couchbase::operations::bucket_settings> {
         {
             auto& str = v.at("evictionPolicy").get_string();
             if (str == "valueOnly") {
-                result.ejection_policy = couchbase::operations::bucket_settings::ejection_policy::value_only;
+                result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::value_only;
             } else if (str == "fullEviction") {
-                result.ejection_policy = couchbase::operations::bucket_settings::ejection_policy::full;
+                result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::full;
+            } else if (str == "noEviction") {
+                result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::no_eviction;
+            } else if (str == "nruEviction") {
+                result.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::not_recently_used;
             }
         }
         {

data/ext/couchbase/operations/bucket_update.hxx

@@ -44,7 +44,7 @@ struct bucket_update_request {
 
     bucket_settings bucket{};
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}", bucket.name);
@@ -55,14 +55,20 @@ struct bucket_update_request {
         encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
         encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes ? "1" : "0"));
         encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled ? "1" : "0"));
-        switch (bucket.ejection_policy) {
-            case bucket_settings::ejection_policy::full:
+        switch (bucket.eviction_policy) {
+            case bucket_settings::eviction_policy::full:
                 encoded.body.append("&evictionPolicy=fullEviction");
                 break;
-            case bucket_settings::ejection_policy::value_only:
+            case bucket_settings::eviction_policy::value_only:
                 encoded.body.append("&evictionPolicy=valueOnly");
                 break;
-            case bucket_settings::ejection_policy::unknown:
+            case bucket_settings::eviction_policy::no_eviction:
+                encoded.body.append("&evictionPolicy=noEviction");
+                break;
+            case bucket_settings::eviction_policy::not_recently_used:
+                encoded.body.append("&evictionPolicy=nruEviction");
+                break;
+            case bucket_settings::eviction_policy::unknown:
                 break;
         }
         switch (bucket.compression_mode) {

data/ext/couchbase/operations/cluster_developer_preview_enable.hxx

@@ -39,7 +39,7 @@ struct cluster_developer_preview_enable_request {
     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)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.headers["content-type"] = "application/x-www-form-urlencoded";

data/ext/couchbase/operations/collection_create.hxx

@@ -46,7 +46,7 @@ struct collection_create_request {
     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)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}/collections/{}", bucket_name, scope_name);
@@ -67,6 +67,8 @@ make_response(std::error_code ec, collection_create_request& request, collection
             case 400:
                 if (encoded.body.find("Collection with this name already exists") != std::string::npos) {
                     response.ec = std::make_error_code(error::management_errc::collection_exists);
+                } else if (encoded.body.find("Not allowed on this version of cluster") != std::string::npos) {
+                    response.ec = std::make_error_code(error::common_errc::feature_not_available);
                 } else {
                     response.ec = std::make_error_code(error::common_errc::invalid_argument);
                 }

data/ext/couchbase/operations/collection_drop.hxx

@@ -45,7 +45,7 @@ struct collection_drop_request {
     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)
+    void encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "DELETE";
         encoded.path = fmt::format("/pools/default/buckets/{}/collections/{}/{}", bucket_name, scope_name, collection_name);

data/ext/couchbase/operations/collections_manifest_get.hxx

@@ -0,0 +1,70 @@
+/* -*- 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 <document_id.hxx>
+#include <operations/bucket_settings.hxx>
+#include <protocol/cmd_get_collections_manifest.hxx>
+#include <collections_manifest.hxx>
+#include <io/retry_context.hxx>
+#include <protocol/client_request.hxx>
+#include <timeout_defaults.hxx>
+
+namespace couchbase::operations
+{
+
+struct collections_manifest_get_response {
+    document_id id;
+    std::uint32_t opaque;
+    std::error_code ec{};
+    collections_manifest manifest{};
+};
+
+struct collections_manifest_get_request {
+    using encoded_request_type = protocol::client_request<protocol::get_collections_manifest_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::get_collections_manifest_response_body>;
+
+    document_id id{ "", "", "", std::nullopt, false, true };
+    uint16_t partition{};
+    uint32_t opaque{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+    io::retry_context<io::retry_strategy::best_effort> retries{ true };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+    }
+};
+
+collections_manifest_get_response
+make_response(std::error_code ec,
+              collections_manifest_get_request& request,
+              collections_manifest_get_request::encoded_response_type encoded)
+{
+    collections_manifest_get_response response{ request.id, encoded.opaque(), ec };
+    if (ec && response.opaque == 0) {
+        response.opaque = request.opaque;
+    }
+    if (!ec) {
+        response.manifest = encoded.body().manifest();
+    }
+    return response;
+}
+} // namespace couchbase::operations

data/ext/couchbase/operations/document_analytics.hxx

@@ -166,7 +166,7 @@ struct analytics_request {
     std::vector<tao::json::value> positional_parameters{};
     std::map<std::string, tao::json::value> named_parameters{};
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context& context)
     {
         tao::json::value body{ { "statement", statement },
                                { "client_context_id", client_context_id },
@@ -207,6 +207,11 @@ struct analytics_request {
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
+        if (context.options.show_queries) {
+            spdlog::info("ANALYTICS: {}", tao::json::to_string(body["statement"]));
+        } else {
+            spdlog::debug("ANALYTICS: {}", tao::json::to_string(body["statement"]));
+        }
     }
 };
 

data/ext/couchbase/operations/document_get_projected.hxx

@@ -205,7 +205,7 @@ make_response(std::error_code ec, get_projected_request& request, get_projected_
     }
     if (!ec) {
         response.cas = encoded.cas();
-        if (request.with_expiry) {
+        if (request.with_expiry && !encoded.body().fields()[0].value.empty()) {
             response.expiry = gsl::narrow_cast<std::uint32_t>(std::stoul(encoded.body().fields()[0].value));
         }
         if (request.effective_projections.empty()) {

data/ext/couchbase/operations/document_query.hxx

@@ -31,6 +31,7 @@
 #include <platform/uuid.h>
 #include <timeout_defaults.hxx>
 #include <io/http_message.hxx>
+#include <io/http_context.hxx>
 
 namespace couchbase::operations
 {
@@ -63,6 +64,7 @@ struct query_response_payload {
     };
 
     query_meta_data meta_data{};
+    std::optional<std::string> prepared{};
     std::vector<std::string> rows{};
 };
 } // namespace couchbase::operations
@@ -76,13 +78,21 @@ struct traits<couchbase::operations::query_response_payload> {
     {
         couchbase::operations::query_response_payload result;
         result.meta_data.request_id = v.at("requestID").get_string();
-        result.meta_data.client_context_id = v.at("clientContextID").get_string();
+        const auto i = v.find("clientContextID");
+        if (i != nullptr) {
+            result.meta_data.client_context_id = i->get_string();
+        }
         result.meta_data.status = v.at("status").get_string();
         const auto s = v.find("signature");
         if (s != nullptr) {
             result.meta_data.signature = tao::json::to_string(*s);
         }
-
+        {
+            const auto c = v.find("prepared");
+            if (c != nullptr) {
+                result.prepared = c->get_string();
+            }
+        }
         const auto p = v.find("profile");
         if (p != nullptr) {
             result.meta_data.profile = tao::json::to_string(*p);
@@ -159,6 +169,7 @@ struct query_request {
     bool adhoc{ true };
     bool metrics{ false };
     bool readonly{ false };
+    bool flex_index{ false };
 
     std::optional<std::uint64_t> max_parallelism{};
     std::optional<std::uint64_t> scan_cap{};
@@ -182,12 +193,34 @@ struct query_request {
     std::map<std::string, tao::json::value> raw{};
     std::vector<tao::json::value> positional_parameters{};
     std::map<std::string, tao::json::value> named_parameters{};
+    std::optional<http_context> ctx_{};
+    bool extract_encoded_plan_{ false };
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context& context)
     {
-        tao::json::value body{ { "statement", statement },
-                               { "client_context_id", client_context_id },
-                               { "timeout", fmt::format("{}ms", timeout.count()) } };
+        ctx_.emplace(context);
+        tao::json::value body{};
+        if (adhoc) {
+            body["statement"] = statement;
+        } else {
+            auto entry = ctx_->cache.get(statement);
+            if (entry) {
+                body["prepared"] = entry->name;
+                if (entry->plan) {
+                    body["encoded_plan"] = entry->plan.value();
+                }
+            } else {
+                body["statement"] = "PREPARE " + statement;
+                if (context.config.supports_enhanced_prepared_statements()) {
+                    body["auto_execute"] = true;
+                } else {
+                    extract_encoded_plan_ = true;
+                }
+            }
+        }
+        body["client_context_id"] = client_context_id;
+        body["timeout"] = fmt::format(
+          "{}ms", ((timeout > std::chrono::milliseconds(5'000)) ? (timeout - std::chrono::milliseconds(500)) : timeout).count());
         if (positional_parameters.empty()) {
             for (auto& param : named_parameters) {
                 Expects(param.first.empty() == false);
@@ -228,6 +261,9 @@ struct query_request {
         if (readonly) {
             body["readonly"] = true;
         }
+        if (flex_index) {
+            body["use_fts"] = true;
+        }
         bool check_scan_wait = false;
         if (scan_consistency) {
             switch (scan_consistency.value()) {
@@ -269,10 +305,25 @@ struct query_request {
             body[param.first] = param.second;
         }
         encoded.type = type;
+        encoded.headers["connection"] = "keep-alive";
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
         encoded.path = "/query/service";
         encoded.body = tao::json::to_string(body);
+
+        tao::json::value stmt = body["statement"];
+        tao::json::value prep = body["prepared"];
+        if (!stmt.is_string()) {
+            stmt = statement;
+        }
+        if (!prep.is_string()) {
+            prep = false;
+        }
+        if (ctx_->options.show_queries) {
+            spdlog::info("QUERY: prep={}, {}", tao::json::to_string(prep), tao::json::to_string(stmt));
+        } else {
+            spdlog::debug("QUERY: prep={}, {}", tao::json::to_string(prep), tao::json::to_string(stmt));
+        }
     }
 };
 
@@ -282,18 +333,42 @@ make_response(std::error_code ec, query_request& request, query_request::encoded
     query_response response{ request.client_context_id, ec };
     if (!ec) {
         response.payload = tao::json::from_string(encoded.body).as<query_response_payload>();
-        Expects(response.payload.meta_data.client_context_id == request.client_context_id);
-        if (response.payload.meta_data.status != "success") {
+        Expects(response.payload.meta_data.client_context_id.empty() ||
+                response.payload.meta_data.client_context_id == request.client_context_id);
+        if (response.payload.meta_data.status == "success") {
+            if (response.payload.prepared) {
+                request.ctx_->cache.put(request.statement, response.payload.prepared.value());
+            } else if (request.extract_encoded_plan_) {
+                request.extract_encoded_plan_ = false;
+                if (response.payload.rows.size() == 1) {
+                    auto row = tao::json::from_string(response.payload.rows[0]);
+                    auto plan = row.find("encoded_plan");
+                    auto name = row.find("name");
+                    if (plan != nullptr && name != nullptr) {
+                        request.ctx_->cache.put(request.statement, name->get_string(), plan->get_string());
+                        throw couchbase::priv::retry_http_request{};
+                    } else {
+                        response.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+                    }
+                } else {
+                    response.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+                }
+            }
+        } else {
             bool prepared_statement_failure = false;
             bool index_not_found = false;
             bool index_failure = false;
             bool planning_failure = false;
             bool syntax_error = false;
             bool server_timeout = false;
+            bool invalid_argument = false;
 
             if (response.payload.meta_data.errors) {
                 for (const auto& error : *response.payload.meta_data.errors) {
                     switch (error.code) {
+                        case 1065: /* IKey: "service.io.request.unrecognized_parameter" */
+                            invalid_argument = true;
+                            break;
                         case 1080: /* IKey: "timeout" */
                             server_timeout = true;
                             break;
@@ -324,6 +399,8 @@ make_response(std::error_code ec, query_request& request, query_request::encoded
             }
             if (syntax_error) {
                 response.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } else if (invalid_argument) {
+                response.ec = std::make_error_code(error::common_errc::invalid_argument);
             } else if (server_timeout) {
                 response.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
             } else if (prepared_statement_failure) {

data/ext/couchbase/operations/document_search.hxx

@@ -111,6 +111,7 @@ struct search_request {
     std::optional<std::uint32_t> limit{};
     std::optional<std::uint32_t> skip{};
     bool explain{ false };
+    bool disable_scoring{ false };
 
     enum class highlight_style_type { html, ansi };
     std::optional<highlight_style_type> highlight_style{};
@@ -127,7 +128,7 @@ struct search_request {
 
     std::map<std::string, tao::json::value> raw{};
 
-    void encode_to(encoded_request_type& encoded)
+    void encode_to(encoded_request_type& encoded, http_context& context)
     {
         tao::json::value body{
             { "query", query },
@@ -140,6 +141,9 @@ struct search_request {
         if (skip) {
             body["from"] = *skip;
         }
+        if (disable_scoring) {
+            body["score"] = "none";
+        }
         if (highlight_style || !highlight_fields.empty()) {
             tao::json::value highlight;
             if (highlight_style) {
@@ -192,6 +196,11 @@ struct search_request {
         encoded.method = "POST";
         encoded.path = fmt::format("/api/index/{}/query", index_name);
         encoded.body = tao::json::to_string(body);
+        if (context.options.show_queries) {
+            spdlog::info("SEARCH: {}", tao::json::to_string(body["query"]));
+        } else {
+            spdlog::debug("SEARCH: {}", tao::json::to_string(body["query"]));
+        }
     }
 };
 
@@ -345,11 +354,12 @@ make_response(std::error_code ec, search_request& request, search_request::encod
             if (response.error.find("index not found") != std::string::npos) {
                 response.ec = std::make_error_code(error::common_errc::index_not_found);
                 return response;
-            }
-            if (response.error.find("no planPIndexes for indexName") != std::string::npos ||
-                response.error.find("pindex_consistency mismatched partition") != std::string::npos) {
+            } else if (response.error.find("no planPIndexes for indexName") != std::string::npos) {
                 response.ec = std::make_error_code(error::search_errc::index_not_ready);
                 return response;
+            } else if (response.error.find("pindex_consistency mismatched partition") != std::string::npos) {
+                response.ec = std::make_error_code(error::search_errc::consistency_mismatch);
+                return response;
             }
         }
         response.ec = std::make_error_code(error::common_errc::internal_server_failure);