couchbase 4.2.8 → 4.2.10

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

@@ -0,0 +1,187 @@
+/* -*- 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 "analytics.hxx"
+#include "core/cluster.hxx"
+#include "internal_search_error_context.hxx"
+#include "internal_search_meta_data.hxx"
+#include "internal_search_result.hxx"
+#include "internal_search_row.hxx"
+#include "internal_search_row_location.hxx"
+#include "internal_search_row_locations.hxx"
+#include "query.hxx"
+#include "search.hxx"
+
+#include <couchbase/bucket.hxx>
+#include <couchbase/collection.hxx>
+#include <couchbase/scope.hxx>
+
+#include <fmt/core.h>
+
+#include <memory>
+
+namespace couchbase
+{
+class scope_impl
+{
+  public:
+    scope_impl(core::cluster core, std::string_view bucket_name, std::string_view name)
+      : core_{ std::move(core) }
+      , bucket_name_{ bucket_name }
+      , name_{ name }
+      , query_context_{ fmt::format("default:`{}`.`{}`", bucket_name_, name_) }
+    {
+    }
+
+    [[nodiscard]] auto bucket_name() const -> const std::string&
+    {
+        return bucket_name_;
+    }
+
+    [[nodiscard]] auto name() const -> const std::string&
+    {
+        return name_;
+    }
+
+    [[nodiscard]] auto core() const -> const core::cluster&
+    {
+        return core_;
+    }
+
+    void query(std::string statement, query_options::built options, query_handler&& handler) const
+    {
+        return core_.execute(
+          core::impl::build_query_request(std::move(statement), query_context_, std::move(options)),
+          [handler = std::move(handler)](auto resp) { return handler(core::impl::build_context(resp), core::impl::build_result(resp)); });
+    }
+
+    void analytics_query(std::string statement, analytics_options::built options, analytics_handler&& handler) const
+    {
+        return core_.execute(core::impl::build_analytics_request(std::move(statement), std::move(options), bucket_name_, name_),
+                             [handler = std::move(handler)](auto resp) mutable {
+                                 return handler(core::impl::build_context(resp), core::impl::build_result(resp));
+                             });
+    }
+
+    void search_query(std::string index_name,
+                      const class search_query& query,
+                      search_options::built options,
+                      search_handler&& handler) const
+    {
+        return core_.execute(core::impl::build_search_request(std::move(index_name), query, 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 } });
+                             });
+    }
+
+    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_;
+    std::string name_;
+    std::string query_context_;
+};
+
+scope::scope(core::cluster core, std::string_view bucket_name, std::string_view name)
+  : impl_(std::make_shared<scope_impl>(std::move(core), bucket_name, name))
+{
+}
+
+auto
+scope::bucket_name() const -> const std::string&
+{
+    return impl_->bucket_name();
+}
+
+auto
+scope::name() const -> const std::string&
+{
+    return impl_->name();
+}
+
+auto
+scope::collection(std::string_view collection_name) const -> couchbase::collection
+{
+    return { impl_->core(), impl_->bucket_name(), impl_->name(), collection_name };
+}
+
+void
+scope::query(std::string statement, const query_options& options, query_handler&& handler) const
+{
+    return impl_->query(std::move(statement), options.build(), std::move(handler));
+}
+
+auto
+scope::query(std::string statement, const query_options& options) const -> std::future<std::pair<query_error_context, query_result>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<query_error_context, query_result>>>();
+    auto future = barrier->get_future();
+    query(std::move(statement), options, [barrier](auto ctx, auto result) { barrier->set_value({ std::move(ctx), std::move(result) }); });
+    return future;
+}
+
+void
+scope::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
+{
+    return impl_->analytics_query(std::move(statement), options.build(), std::move(handler));
+}
+
+auto
+scope::analytics_query(std::string statement, const analytics_options& options) const
+  -> std::future<std::pair<analytics_error_context, analytics_result>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
+    auto future = barrier->get_future();
+    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
+        barrier->set_value({ std::move(ctx), std::move(result) });
+    });
+    return future;
+}
+
+void
+scope::search(std::string index_name, search_request request, const search_options& options, search_handler&& handler) const
+{
+    return impl_->search(std::move(index_name), std::move(request), options.build(), std::move(handler));
+}
+
+auto
+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(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

@@ -15,10 +15,6 @@
  *   limitations under the License.
  */
 
-#include <couchbase/cluster.hxx>
-#include <couchbase/error_codes.hxx>
-#include <couchbase/scope.hxx>
-
 #include "core/cluster.hxx"
 #include "core/operations/document_search.hxx"
 #include "core/utils/json.hxx"
@@ -27,17 +23,19 @@
 #include "encoded_search_sort.hxx"
 #include "internal_date_range_facet_result.hxx"
 #include "internal_numeric_range_facet_result.hxx"
-#include "internal_search_error_context.hxx"
-#include "internal_search_meta_data.hxx"
-#include "internal_search_result.hxx"
-#include "internal_search_row.hxx"
-#include "internal_search_row_location.hxx"
-#include "internal_search_row_locations.hxx"
 #include "internal_term_facet_result.hxx"
 
-namespace couchbase
+#include <couchbase/cluster.hxx>
+#include <couchbase/match_none_query.hxx>
+#include <utility>
+
+#include <fmt/core.h>
+
+namespace couchbase::core::impl
+{
+namespace
 {
-static std::optional<core::search_highlight_style>
+std::optional<core::search_highlight_style>
 map_highlight_style(const std::optional<couchbase::highlight_style>& style)
 {
     if (style) {
@@ -54,7 +52,7 @@ map_highlight_style(const std::optional<couchbase::highlight_style>& style)
 static std::optional<core::search_scan_consistency>
 map_scan_consistency(const std::optional<couchbase::search_scan_consistency>& scan_consistency)
 {
-    if (scan_consistency == search_scan_consistency::not_bounded) {
+    if (scan_consistency == couchbase::search_scan_consistency::not_bounded) {
         return core::search_scan_consistency::not_bounded;
     }
     return {};
@@ -107,12 +105,28 @@ map_raw(std::map<std::string, codec::binary, std::less<>>& raw)
     return core_raw;
 }
 
-static core::operations::search_request
+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) {
@@ -121,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,
@@ -142,50 +161,55 @@ build_search_request(std::string index_name,
     return request;
 }
 
-void
-cluster::search_query(std::string index_name,
-                      const class search_query& query,
-                      const search_options& options,
-                      search_handler&& handler) const
+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)
 {
-    auto request = build_search_request(std::move(index_name), query, options.build(), {}, {});
-
-    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::search_response resp) mutable {
-        handler(search_error_context{ internal_search_error_context{ resp } }, search_result{ internal_search_result{ resp } });
-    });
-}
+    if (!request.search_query().has_value()) {
+        request.search_query(couchbase::match_none_query{});
+    }
 
-auto
-cluster::search_query(std::string index_name, const class search_query& query, 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>>>();
-    search_query(std::move(index_name), query, options, [barrier](auto ctx, auto result) mutable {
-        barrier->set_value(std::make_pair(std::move(ctx), std::move(result)));
-    });
-    return barrier->get_future();
-}
+    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,
+    };
 
-void
-scope::search_query(std::string index_name, const class search_query& query, const search_options& options, search_handler&& handler) const
-{
-    auto request = build_search_request(std::move(index_name), query, options.build(), bucket_name_, name_);
+    if (!request.vector_search().has_value()) {
+        return core_request;
+    }
+    core_request.vector_search = core::utils::json::generate_binary(request.vector_search().value().query);
 
-    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::search_response resp) mutable {
-        return handler(search_error_context{ internal_search_error_context{ resp } }, search_result{ internal_search_result{ resp } });
-    });
-}
+    auto vector_search_options = request.vector_options();
+    if (!vector_search_options.has_value()) {
+        return core_request;
+    }
 
-auto
-scope::search_query(std::string index_name, const class search_query& query, 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) {
-        barrier->set_value({ std::move(ctx), std::move(result) });
-    });
-    return future;
+    core_request.vector_query_combination = map_vector_query_combination(vector_search_options.value().combination);
+    return core_request;
 }
-
-} // namespace couchbase
+} // namespace couchbase::core::impl

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

@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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 "core/operations/document_search.hxx"
+
+#include <couchbase/search_options.hxx>
+#include <couchbase/search_query.hxx>
+#include <couchbase/search_request.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase::core::impl
+{
+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);
+
+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