couchbase 4.2.9 → 4.2.10

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

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

@@ -29,6 +29,7 @@
 #include "core/utils/json.hxx"
 #include "internal_manager_error_context.hxx"
 
+#include <couchbase/scope_search_index_manager.hxx>
 #include <couchbase/search_index_manager.hxx>
 
 #include <memory>
@@ -145,19 +146,26 @@ class search_index_manager_impl
     {
     }
 
+    explicit search_index_manager_impl(core::cluster core, std::string bucket_name, std::string scope_name)
+      : core_{ std::move(core) }
+      , bucket_name_{ std::move(bucket_name) }
+      , scope_name_{ std::move(scope_name) }
+    {
+    }
+
     void get_index(std::string index_name,
                    const couchbase::get_search_index_options::built& options,
                    get_search_index_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_get_request{ std::move(index_name), {}, options.timeout },
+          core::operations::management::search_index_get_request{ std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), map_search_index(resp.index)); });
     }
 
     void get_all_indexes(const get_all_search_indexes_options::built& options, get_all_search_indexes_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_get_all_request{ {}, options.timeout },
+          core::operations::management::search_index_get_all_request{ bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), map_all_search_indexes(resp.indexes)); });
     }
 
@@ -165,30 +173,37 @@ class search_index_manager_impl
                       const upsert_search_index_options::built& options,
                       upsert_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_upsert_request{ map_search_index(search_index), {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_upsert_request{
+            map_search_index(search_index), bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void drop_index(std::string index_name, const drop_search_index_options::built& options, drop_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_drop_request{ std::move(index_name), {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_drop_request{ std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void get_indexed_documents_count(std::string index_name,
                                      const get_indexed_search_index_options::built& options,
                                      get_indexed_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_get_documents_count_request{ std::move(index_name), {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), resp.count); });
+        core_.execute(
+          core::operations::management::search_index_get_documents_count_request{
+            std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), resp.count); });
     }
 
     void pause_ingest(std::string index_name,
                       const pause_ingest_search_index_options::built& options,
                       pause_ingest_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_control_ingest_request{ std::move(index_name), true, {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_control_ingest_request{
+            std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void resume_ingest(std::string index_name,
@@ -196,7 +211,8 @@ class search_index_manager_impl
                        resume_ingest_search_index_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_control_ingest_request{ std::move(index_name), false, {}, options.timeout },
+          core::operations::management::search_index_control_ingest_request{
+            std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
@@ -204,16 +220,20 @@ class search_index_manager_impl
                         const allow_querying_search_index_options::built& options,
                         allow_querying_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_control_query_request{ std::move(index_name), true, {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_control_query_request{
+            std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void disallow_querying(std::string index_name,
                            const disallow_querying_search_index_options::built& options,
                            disallow_querying_search_index_handler&& handler) const
     {
-        core_.execute(core::operations::management::search_index_control_query_request{ std::move(index_name), false, {}, options.timeout },
-                      [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+        core_.execute(
+          core::operations::management::search_index_control_query_request{
+            std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
     void freeze_plan(std::string index_name,
@@ -221,7 +241,8 @@ class search_index_manager_impl
                      freeze_plan_search_index_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_control_plan_freeze_request{ std::move(index_name), true, {}, options.timeout },
+          core::operations::management::search_index_control_plan_freeze_request{
+            std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
@@ -230,7 +251,8 @@ class search_index_manager_impl
                        unfreeze_plan_search_index_handler&& handler) const
     {
         core_.execute(
-          core::operations::management::search_index_control_plan_freeze_request{ std::move(index_name), false, {}, options.timeout },
+          core::operations::management::search_index_control_plan_freeze_request{
+            std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
     }
 
@@ -241,12 +263,14 @@ class search_index_manager_impl
     {
         core_.execute(
           core::operations::management::search_index_analyze_document_request{
-            std::move(index_name), std::move(document), {}, options.timeout },
+            std::move(index_name), std::move(document), bucket_name_, scope_name_, {}, options.timeout },
           [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), convert_analysis(resp.analysis)); });
     }
 
   private:
     core::cluster core_;
+    std::optional<std::string> bucket_name_{};
+    std::optional<std::string> scope_name_{};
 };
 
 search_index_manager::search_index_manager(core::cluster core)
@@ -466,4 +490,223 @@ search_index_manager::analyze_document(std::string index_name,
     });
     return barrier->get_future();
 }
+
+scope_search_index_manager::scope_search_index_manager(core::cluster core, std::string bucket_name, std::string scope_name)
+  : impl_(std::make_shared<search_index_manager_impl>(std::move(core), std::move(bucket_name), std::move(scope_name)))
+{
+}
+
+void
+scope_search_index_manager::get_index(std::string index_name,
+                                      const couchbase::get_search_index_options& options,
+                                      couchbase::get_search_index_handler&& handler) const
+{
+    return impl_->get_index(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::get_index(std::string index_name, const couchbase::get_search_index_options& options) const
+  -> std::future<std::pair<manager_error_context, management::search::index>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, management::search::index>>>();
+    get_index(std::move(index_name), options, [barrier](auto ctx, auto result) mutable {
+        barrier->set_value(std::make_pair(std::move(ctx), std::move(result)));
+    });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::get_all_indexes(const couchbase::get_all_search_indexes_options& options,
+                                            get_all_search_indexes_handler&& handler) const
+{
+    return impl_->get_all_indexes(options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::get_all_indexes(const couchbase::get_all_search_indexes_options& options) const
+  -> std::future<std::pair<manager_error_context, std::vector<management::search::index>>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::vector<management::search::index>>>>();
+    get_all_indexes(options,
+                    [barrier](auto ctx, auto result) mutable { barrier->set_value(std::make_pair(std::move(ctx), std::move(result))); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::upsert_index(const management::search::index& search_index,
+                                         const couchbase::upsert_search_index_options& options,
+                                         couchbase::upsert_search_index_handler&& handler) const
+{
+    return impl_->upsert_index(search_index, options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::upsert_index(const management::search::index& search_index,
+                                         const couchbase::upsert_search_index_options& options) const -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    upsert_index(search_index, options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::drop_index(std::string index_name,
+                                       const couchbase::drop_search_index_options& options,
+                                       couchbase::drop_search_index_handler&& handler) const
+{
+    return impl_->drop_index(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::drop_index(std::string index_name, const couchbase::drop_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    drop_index(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::get_indexed_documents_count(std::string index_name,
+                                                        const couchbase::get_indexed_search_index_options& options,
+                                                        couchbase::get_indexed_search_index_handler&& handler) const
+{
+    return impl_->get_indexed_documents_count(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::get_indexed_documents_count(std::string index_name, const get_indexed_search_index_options& options) const
+  -> std::future<std::pair<manager_error_context, std::uint64_t>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::uint64_t>>>();
+    get_indexed_documents_count(std::move(index_name), options, [barrier](auto ctx, auto result) mutable {
+        barrier->set_value(std::make_pair(std::move(ctx), std::move(result)));
+    });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::pause_ingest(std::string index_name,
+                                         const couchbase::pause_ingest_search_index_options& options,
+                                         couchbase::pause_ingest_search_index_handler&& handler) const
+{
+    return impl_->pause_ingest(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::pause_ingest(std::string index_name, const couchbase::pause_ingest_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    pause_ingest(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::resume_ingest(std::string index_name,
+                                          const couchbase::resume_ingest_search_index_options& options,
+                                          couchbase::resume_ingest_search_index_handler&& handler) const
+{
+    return impl_->resume_ingest(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::resume_ingest(std::string index_name, const couchbase::resume_ingest_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    resume_ingest(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::allow_querying(std::string index_name,
+                                           const couchbase::allow_querying_search_index_options& options,
+                                           couchbase::allow_querying_search_index_handler&& handler) const
+{
+    return impl_->allow_querying(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::allow_querying(std::string index_name, const couchbase::allow_querying_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    allow_querying(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::disallow_querying(std::string index_name,
+                                              const couchbase::disallow_querying_search_index_options& options,
+                                              couchbase::disallow_querying_search_index_handler&& handler) const
+{
+    return impl_->disallow_querying(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::disallow_querying(std::string index_name,
+                                              const couchbase::disallow_querying_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    disallow_querying(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::freeze_plan(std::string index_name,
+                                        const couchbase::freeze_plan_search_index_options& options,
+                                        couchbase::freeze_plan_search_index_handler&& handler) const
+{
+    return impl_->freeze_plan(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::freeze_plan(std::string index_name, const couchbase::freeze_plan_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    freeze_plan(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::unfreeze_plan(std::string index_name,
+                                          const couchbase::unfreeze_plan_search_index_options& options,
+                                          couchbase::unfreeze_plan_search_index_handler&& handler) const
+{
+    return impl_->unfreeze_plan(std::move(index_name), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::unfreeze_plan(std::string index_name, const couchbase::unfreeze_plan_search_index_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    unfreeze_plan(std::move(index_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+scope_search_index_manager::analyze_document(std::string index_name,
+                                             std::string document,
+                                             const couchbase::analyze_document_options& options,
+                                             couchbase::analyze_document_handler&& handler) const
+{
+    return impl_->analyze_document(std::move(index_name), std::move(document), options.build(), std::move(handler));
+}
+
+auto
+scope_search_index_manager::analyze_document(std::string index_name,
+                                             std::string document,
+                                             const couchbase::analyze_document_options& options) const
+  -> std::future<std::pair<manager_error_context, std::vector<std::string>>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::vector<std::string>>>>();
+    analyze_document(std::move(index_name), std::move(document), options, [barrier](auto ctx, auto result) mutable {
+        barrier->set_value(std::make_pair(std::move(ctx), std::move(result)));
+    });
+    return barrier->get_future();
+}
 } // namespace couchbase