couchbase 4.2.9 → 4.2.11-rc.1

package/deps/couchbase-cxx-client/core/impl/diagnostics.cxx

@@ -0,0 +1,294 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-present 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.
+ */
+
+#include "diagnostics.hxx"
+
+#include "core/diagnostics.hxx"
+#include "core/service_type.hxx"
+
+#include <couchbase/codec/tao_json_serializer.hxx>
+#include <couchbase/diagnostics_result.hxx>
+#include <couchbase/endpoint_ping_report.hxx>
+#include <couchbase/ping_result.hxx>
+#include <couchbase/service_type.hxx>
+
+#include <cstdint>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace couchbase
+{
+namespace
+{
+std::string
+service_type_as_string(service_type service_type)
+{
+    switch (service_type) {
+        case service_type::key_value:
+            return "kv";
+        case service_type::query:
+            return "query";
+        case service_type::analytics:
+            return "analytics";
+        case service_type::search:
+            return "search";
+        case service_type::view:
+            return "views";
+        case service_type::management:
+            return "mgmt";
+        case service_type::eventing:
+            return "eventing";
+    }
+    return "";
+}
+
+std::string
+ping_state_as_string(ping_state state)
+{
+    switch (state) {
+        case ping_state::ok:
+            return "ok";
+        case ping_state::timeout:
+            return "timeout";
+        case ping_state::error:
+            return "error";
+    }
+    return "";
+}
+
+std::string
+endpoint_state_as_string(endpoint_state state)
+{
+    switch (state) {
+        case endpoint_state::connected:
+            return "connected";
+        case endpoint_state::connecting:
+            return "connecting";
+        case endpoint_state::disconnected:
+            return "disconnected";
+        case endpoint_state::disconnecting:
+            return "disconnecting";
+    }
+    return "";
+}
+
+codec::tao_json_serializer::document_type
+endpoint_ping_report_as_json(const endpoint_ping_report& report)
+{
+    codec::tao_json_serializer::document_type res{
+        { "id", report.id() },       { "latency_us", report.latency().count() },        { "remote", report.remote() },
+        { "local", report.local() }, { "state", ping_state_as_string(report.state()) },
+    };
+    if (report.error()) {
+        res["error"] = report.error().value();
+    }
+    if (report.endpoint_namespace()) {
+        res["namespace"] = report.endpoint_namespace().value();
+    }
+    return res;
+}
+
+codec::tao_json_serializer::document_type
+endpoint_diagnostics_as_json(const endpoint_diagnostics& report)
+{
+    codec::tao_json_serializer::document_type res{
+        { "id", report.id() },
+        { "local", report.local() },
+        { "remote", report.remote() },
+        { "state", endpoint_state_as_string(report.state()) },
+    };
+    if (report.last_activity()) {
+        res["last_activity_us"] = report.last_activity().value().count();
+    }
+    if (report.endpoint_namespace()) {
+        res["namespace"] = report.endpoint_namespace().value();
+    }
+    if (report.details()) {
+        res["details"] = report.details();
+    }
+    return res;
+}
+} // namespace
+
+auto
+ping_result::as_json() const -> codec::tao_json_serializer::document_type
+{
+    codec::tao_json_serializer::document_type endpoints{};
+    for (const auto& [service_type, reports] : endpoints_) {
+        std::vector<codec::tao_json_serializer::document_type> json_reports{};
+        for (const auto& report : reports) {
+            json_reports.emplace_back(endpoint_ping_report_as_json(report));
+        }
+        endpoints[service_type_as_string(service_type)] = json_reports;
+    }
+    return {
+        { "version", version_ },
+        { "id", id_ },
+        { "sdk", sdk_ },
+        { "services", endpoints },
+    };
+}
+
+auto
+diagnostics_result::as_json() const -> codec::tao_json_serializer::document_type
+{
+    codec::tao_json_serializer::document_type endpoints{};
+    for (const auto& [service_type, reports] : endpoints_) {
+        std::vector<codec::tao_json_serializer::document_type> json_reports{};
+        for (const auto& report : reports) {
+            json_reports.emplace_back(endpoint_diagnostics_as_json(report));
+        }
+        endpoints[service_type_as_string(service_type)] = json_reports;
+    }
+    return {
+        { "id", id_ },
+        { "sdk", sdk_ },
+        { "version", version_ },
+        { "services", endpoints },
+    };
+}
+} // namespace couchbase
+
+namespace couchbase::core::impl
+{
+namespace
+{
+couchbase::service_type
+to_public_service_type(core::service_type service_type)
+{
+    switch (service_type) {
+        case core::service_type::key_value:
+            return couchbase::service_type::key_value;
+        case core::service_type::query:
+            return couchbase::service_type::query;
+        case core::service_type::analytics:
+            return couchbase::service_type::analytics;
+        case core::service_type::search:
+            return couchbase::service_type::search;
+        case core::service_type::view:
+            return couchbase::service_type::view;
+        case core::service_type::management:
+            return couchbase::service_type::management;
+        case core::service_type::eventing:
+            return couchbase::service_type::eventing;
+    }
+    return {};
+}
+
+couchbase::ping_state
+to_public_ping_state(core::diag::ping_state ping_state)
+{
+    switch (ping_state) {
+        case core::diag::ping_state::timeout:
+            return couchbase::ping_state::timeout;
+        case core::diag::ping_state::error:
+            return couchbase::ping_state::error;
+        case core::diag::ping_state::ok:
+            return couchbase::ping_state::ok;
+    }
+    return {};
+}
+
+couchbase::endpoint_state
+to_public_endpoint_state(core::diag::endpoint_state endpoint_state)
+{
+    switch (endpoint_state) {
+        case core::diag::endpoint_state::connected:
+            return couchbase::endpoint_state::connected;
+        case diag::endpoint_state::disconnected:
+            return couchbase::endpoint_state::disconnected;
+        case diag::endpoint_state::connecting:
+            return couchbase::endpoint_state::connecting;
+        case diag::endpoint_state::disconnecting:
+            return couchbase::endpoint_state::disconnecting;
+    }
+    return {};
+}
+} // namespace
+
+std::set<core::service_type>
+to_core_service_types(const std::set<couchbase::service_type>& service_types)
+{
+    std::set<core::service_type> res{};
+    for (auto s : service_types) {
+        switch (s) {
+            case couchbase::service_type::key_value:
+                res.emplace(core::service_type::key_value);
+                break;
+            case couchbase::service_type::query:
+                res.emplace(core::service_type::query);
+                break;
+            case couchbase::service_type::analytics:
+                res.emplace(core::service_type::analytics);
+                break;
+            case couchbase::service_type::search:
+                res.emplace(core::service_type::search);
+                break;
+            case couchbase::service_type::view:
+                res.emplace(core::service_type::view);
+                break;
+            case couchbase::service_type::management:
+                res.emplace(core::service_type::management);
+                break;
+            case couchbase::service_type::eventing:
+                res.emplace(core::service_type::eventing);
+                break;
+        }
+    }
+    return res;
+}
+
+couchbase::ping_result
+build_result(const core::diag::ping_result& result)
+{
+    std::map<couchbase::service_type, std::vector<couchbase::endpoint_ping_report>> endpoints{};
+    for (const auto& [core_service_type, core_endpoints] : result.services) {
+        auto service_type = to_public_service_type(core_service_type);
+        endpoints[service_type] = std::vector<couchbase::endpoint_ping_report>{};
+        for (const auto& info : core_endpoints) {
+            endpoints[service_type].emplace_back(
+              service_type, info.id, info.local, info.remote, to_public_ping_state(info.state), info.error, info.bucket, info.latency);
+        }
+    }
+
+    return { result.id, static_cast<std::uint16_t>(result.version), result.sdk, endpoints };
+}
+
+couchbase::diagnostics_result
+build_result(const core::diag::diagnostics_result& result)
+{
+    std::map<couchbase::service_type, std::vector<couchbase::endpoint_diagnostics>> endpoints{};
+    for (const auto& [core_service_type, core_endpoints] : result.services) {
+        auto service_type = to_public_service_type(core_service_type);
+        endpoints[service_type] = std::vector<couchbase::endpoint_diagnostics>{};
+        for (const auto& info : core_endpoints) {
+            endpoints[service_type].emplace_back(service_type,
+                                                 info.id,
+                                                 info.last_activity,
+                                                 info.local,
+                                                 info.remote,
+                                                 info.bucket,
+                                                 to_public_endpoint_state(info.state),
+                                                 info.details);
+        }
+    }
+
+    return { result.id, static_cast<std::uint16_t>(result.version), result.sdk, endpoints };
+}
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/diagnostics.hxx

@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present 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 <couchbase/diagnostics_result.hxx>
+#include <couchbase/ping_result.hxx>
+#include <couchbase/service_type.hxx>
+
+#include "core/diagnostics.hxx"
+#include "core/service_type.hxx"
+
+#include <set>
+
+namespace couchbase::core::impl
+{
+std::set<core::service_type>
+to_core_service_types(const std::set<couchbase::service_type>& service_types);
+
+couchbase::ping_result
+build_result(const core::diag::ping_result& result);
+
+couchbase::diagnostics_result
+build_result(const core::diag::diagnostics_result& result);
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/query_index_manager.cxx

@@ -215,7 +215,7 @@ class query_index_manager_impl : public std::enable_shared_from_this<query_index
                       const std::string& scope_name,
                       const std::string& collection_name,
                       std::string index_name,
-                      std::vector<std::string> fields,
+                      std::vector<std::string> keys,
                       const create_query_index_options::built& options,
                       create_query_index_handler&& handler) const
     {
@@ -225,7 +225,7 @@ class query_index_manager_impl : public std::enable_shared_from_this<query_index
             scope_name,
             collection_name,
             std::move(index_name),
-            std::move(fields),
+            std::move(keys),
             {},
             false /* is_primary */,
             options.ignore_if_exists,
@@ -521,22 +521,22 @@ collection_query_index_manager::get_all_indexes(const get_all_query_indexes_opti
 
 void
 collection_query_index_manager::create_index(std::string index_name,
-                                             std::vector<std::string> fields,
+                                             std::vector<std::string> keys,
                                              const create_query_index_options& options,
                                              create_query_index_handler&& handler) const
 {
     return impl_->create_index(
-      bucket_name_, scope_name_, collection_name_, std::move(index_name), std::move(fields), options.build(), std::move(handler));
+      bucket_name_, scope_name_, collection_name_, std::move(index_name), std::move(keys), options.build(), std::move(handler));
 }
 
 auto
 collection_query_index_manager::create_index(std::string index_name,
-                                             std::vector<std::string> fields,
+                                             std::vector<std::string> keys,
                                              const create_query_index_options& options) const -> std::future<manager_error_context>
 {
     auto barrier = std::make_shared<std::promise<manager_error_context>>();
     auto future = barrier->get_future();
-    create_index(std::move(index_name), std::move(fields), options, [barrier](auto ctx) { barrier->set_value(std::move(ctx)); });
+    create_index(std::move(index_name), std::move(keys), options, [barrier](auto ctx) { barrier->set_value(std::move(ctx)); });
     return future;
 }
 

package/deps/couchbase-cxx-client/core/impl/scope.cxx

@@ -89,6 +89,15 @@ class scope_impl
                              });
     }
 
+    void search(std::string index_name, couchbase::search_request request, search_options::built options, search_handler&& handler) const
+    {
+        return core_.execute(core::impl::build_search_request(std::move(index_name), std::move(request), options, bucket_name_, name_),
+                             [handler = std::move(handler)](auto&& resp) mutable {
+                                 return handler(search_error_context{ internal_search_error_context{ resp } },
+                                                search_result{ internal_search_result{ resp } });
+                             });
+    }
+
   private:
     core::cluster core_;
     std::string bucket_name_;
@@ -153,20 +162,26 @@ scope::analytics_query(std::string statement, const analytics_options& options)
 }
 
 void
-scope::search_query(std::string index_name, const class search_query& query, const search_options& options, search_handler&& handler) const
+scope::search(std::string index_name, search_request request, const search_options& options, search_handler&& handler) const
 {
-    return impl_->search_query(std::move(index_name), query, options.build(), std::move(handler));
+    return impl_->search(std::move(index_name), std::move(request), options.build(), std::move(handler));
 }
 
 auto
-scope::search_query(std::string index_name, const class search_query& query, const search_options& options) const
+scope::search(std::string index_name, search_request request, const search_options& options) const
   -> std::future<std::pair<search_error_context, search_result>>
 {
     auto barrier = std::make_shared<std::promise<std::pair<search_error_context, search_result>>>();
     auto future = barrier->get_future();
-    search_query(std::move(index_name), query, options, [barrier](auto ctx, auto result) {
+    search(std::move(index_name), std::move(request), options, [barrier](auto ctx, auto result) {
         barrier->set_value({ std::move(ctx), std::move(result) });
     });
     return future;
 }
+
+auto
+scope::search_indexes() const -> scope_search_index_manager
+{
+    return scope_search_index_manager{ impl_->core(), impl_->bucket_name(), impl_->name() };
+}
 } // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/search.cxx

@@ -26,6 +26,8 @@
 #include "internal_term_facet_result.hxx"
 
 #include <couchbase/cluster.hxx>
+#include <couchbase/match_none_query.hxx>
+#include <utility>
 
 #include <fmt/core.h>
 
@@ -102,14 +104,29 @@ map_raw(std::map<std::string, codec::binary, std::less<>>& raw)
     }
     return core_raw;
 }
+
+static std::optional<core::vector_query_combination>
+map_vector_query_combination(const std::optional<couchbase::vector_query_combination>& combination)
+{
+    if (combination) {
+        switch (combination.value()) {
+            case couchbase::vector_query_combination::combination_and:
+                return core::vector_query_combination::combination_and;
+            case couchbase::vector_query_combination::combination_or:
+                return core::vector_query_combination::combination_or;
+        }
+    }
+    return {};
+}
+
 } // namespace
 
 core::operations::search_request
 build_search_request(std::string index_name,
                      const search_query& query,
                      search_options::built options,
-                     std::optional<std::string> /* bucket_name */,
-                     std::optional<std::string> /* scope_name */)
+                     std::optional<std::string> bucket_name,
+                     std::optional<std::string> scope_name)
 {
     auto encoded = query.encode();
     if (encoded.ec) {
@@ -118,6 +135,11 @@ build_search_request(std::string index_name,
     core::operations::search_request request{
         std::move(index_name),
         core::utils::json::generate_binary(encoded.query),
+        std::move(bucket_name),
+        std::move(scope_name),
+        {},
+        {},
+        {},
         options.limit,
         options.skip,
         options.explain,
@@ -139,4 +161,55 @@ build_search_request(std::string index_name,
     return request;
 }
 
+core::operations::search_request
+build_search_request(std::string index_name,
+                     couchbase::search_request request,
+                     search_options::built options,
+                     std::optional<std::string> bucket_name,
+                     std::optional<std::string> scope_name)
+{
+    if (!request.search_query().has_value()) {
+        request.search_query(couchbase::match_none_query{});
+    }
+
+    core::operations::search_request core_request{
+        std::move(index_name),
+        core::utils::json::generate_binary(request.search_query().value().query),
+        std::move(bucket_name),
+        std::move(scope_name),
+        false,
+        {},
+        {},
+        options.limit,
+        options.skip,
+        options.explain,
+        options.disable_scoring,
+        options.include_locations,
+        map_highlight_style(options.highlight_style),
+        options.highlight_fields,
+        options.fields,
+        options.collections,
+        map_scan_consistency(options.scan_consistency),
+        options.mutation_state,
+        map_sort(options.sort, options.sort_string),
+        map_facets(options.facets),
+        map_raw(options.raw),
+        {},
+        options.client_context_id,
+        options.timeout,
+    };
+
+    if (!request.vector_search().has_value()) {
+        return core_request;
+    }
+    core_request.vector_search = core::utils::json::generate_binary(request.vector_search().value().query);
+
+    auto vector_search_options = request.vector_options();
+    if (!vector_search_options.has_value()) {
+        return core_request;
+    }
+
+    core_request.vector_query_combination = map_vector_query_combination(vector_search_options.value().combination);
+    return core_request;
+}
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/search.hxx

@@ -21,6 +21,7 @@
 
 #include <couchbase/search_options.hxx>
 #include <couchbase/search_query.hxx>
+#include <couchbase/search_request.hxx>
 
 #include <optional>
 #include <string>
@@ -34,4 +35,11 @@ build_search_request(std::string index_name,
                      std::optional<std::string> bucket_name,
                      std::optional<std::string> scope_name);
 
+core::operations::search_request
+build_search_request(std::string index_name,
+                     search_request request,
+                     search_options::built options,
+                     std::optional<std::string> bucket_name,
+                     std::optional<std::string> scope_name);
+
 } // namespace couchbase::core::impl