couchbase 4.2.8 → 4.2.10

package/deps/couchbase-cxx-client/couchbase/scope.hxx

@@ -20,20 +20,24 @@
 #include <couchbase/analytics_options.hxx>
 #include <couchbase/collection.hxx>
 #include <couchbase/query_options.hxx>
+#include <couchbase/scope_search_index_manager.hxx>
 #include <couchbase/search_options.hxx>
 #include <couchbase/search_query.hxx>
+#include <couchbase/search_request.hxx>
 
 #include <memory>
 
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
 namespace couchbase
 {
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
 class cluster;
-} // namespace couchbase
+} // namespace core
+class bucket;
+class scope_impl;
 #endif
 
-namespace couchbase
-{
 /**
  * The scope identifies a group of collections and allows high application density as a result.
  *
@@ -58,10 +62,7 @@ class scope
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto bucket_name() const -> const std::string&
-    {
-        return bucket_name_;
-    }
+    [[nodiscard]] auto bucket_name() const -> const std::string&;
 
     /**
      * Returns name of the scope.
@@ -71,10 +72,7 @@ class scope
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto name() const -> const std::string&
-    {
-        return name_;
-    }
+    [[nodiscard]] auto name() const -> const std::string&;
 
     /**
      * Opens a collection for this scope with an explicit name.
@@ -85,16 +83,11 @@ class scope
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto collection(std::string_view collection_name) const -> collection
-    {
-        return { core_, bucket_name_, name_, collection_name };
-    }
+    [[nodiscard]] auto collection(std::string_view collection_name) const -> collection;
 
     /**
      * Performs a query against the query (N1QL) services.
      *
-     * @tparam Handler callable type that implements @ref query_handler signature
-     *
      * @param statement the N1QL query statement.
      * @param options options to customize the query request.
      * @param handler the handler that implements @ref query_handler
@@ -105,15 +98,7 @@ class scope
      * @since 1.0.0
      * @committed
      */
-    template<typename Handler>
-    void query(std::string statement, const query_options& options, Handler&& handler) const
-    {
-        return core::impl::initiate_query_operation(core_,
-                                                    std::move(statement),
-                                                    fmt::format("default:`{}`.`{}`", bucket_name_, name_),
-                                                    options.build(),
-                                                    std::forward<Handler>(handler));
-    }
+    void query(std::string statement, const query_options& options, query_handler&& handler) const;
 
     /**
      * Performs a query against the query (N1QL) services.
@@ -126,21 +111,15 @@ class scope
      * @committed
      */
     [[nodiscard]] auto 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;
-    }
+      -> std::future<std::pair<query_error_context, query_result>>;
 
     /**
-     * Performs a query against the full text search services.
+     * Performs a request against the full text search services.
+     *
+     * This can be used to perform a traditional FTS query, and/or a vector search.
      *
      * @param index_name name of the search index
-     * @param query query object, see hierarchy of @ref search_query for more details.
+     * @param request request object, see @ref search_request for more details.
      * @param options options to customize the query request.
      * @param handler the handler that implements @ref search_handler
      *
@@ -150,15 +129,17 @@ class scope
      * @see https://docs.couchbase.com/server/current/fts/fts-introduction.html
      *
      * @since 1.0.0
-     * @committed
+     * @volatile
      */
-    void search_query(std::string index_name, const search_query& query, const search_options& options, search_handler&& handler) const;
+    void search(std::string index_name, search_request request, const search_options& options, search_handler&& handler) const;
 
     /**
-     * Performs a query against the full text search services.
+     * Performs a request against the full text search services.
+     *
+     * This can be used to perform a traditional FTS query, and/or a vector search.
      *
      * @param index_name name of the search index
-     * @param query query object, see hierarchy of @ref search_query for more details.
+     * @param request request object, see @ref search_request for more details.
      * @param options options to customize the query request.
      * @return future object that carries result of the operation
      *
@@ -168,9 +149,9 @@ class scope
      * @see https://docs.couchbase.com/server/current/fts/fts-introduction.html
      *
      * @since 1.0.0
-     * @committed
+     * @volatile
      */
-    [[nodiscard]] auto search_query(std::string index_name, const class search_query& query, const search_options& options = {}) const
+    [[nodiscard]] auto search(std::string index_name, search_request request, const search_options& = {}) const
       -> std::future<std::pair<search_error_context, search_result>>;
 
     /**
@@ -205,18 +186,21 @@ class scope
     [[nodiscard]] auto analytics_query(std::string statement, const analytics_options& options = {}) const
       -> std::future<std::pair<analytics_error_context, analytics_result>>;
 
+    /**
+     * Provides access to search index management services at the scope level
+     *
+     * @return a manager instance
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    [[nodiscard]] auto search_indexes() const -> scope_search_index_manager;
+
   private:
     friend class bucket;
 
-    scope(std::shared_ptr<couchbase::core::cluster> core, std::string_view bucket_name, std::string_view name)
-      : core_(std::move(core))
-      , bucket_name_(bucket_name)
-      , name_(name)
-    {
-    }
+    scope(core::cluster core, std::string_view bucket_name, std::string_view name);
 
-    std::shared_ptr<couchbase::core::cluster> core_;
-    std::string bucket_name_;
-    std::string name_;
+    std::shared_ptr<scope_impl> impl_;
 };
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/scope_search_index_manager.hxx

@@ -0,0 +1,291 @@
+/* -*- 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 <couchbase/allow_querying_search_index_options.hxx>
+#include <couchbase/analyze_document_options.hxx>
+#include <couchbase/disallow_querying_search_index_options.hxx>
+#include <couchbase/drop_search_index_options.hxx>
+#include <couchbase/freeze_plan_search_index_options.hxx>
+#include <couchbase/get_all_search_indexes_options.hxx>
+#include <couchbase/get_indexed_search_index_options.hxx>
+#include <couchbase/get_search_index_options.hxx>
+#include <couchbase/pause_ingest_search_index_options.hxx>
+#include <couchbase/resume_ingest_search_index_options.hxx>
+#include <couchbase/unfreeze_plan_search_index_options.hxx>
+#include <couchbase/upsert_search_index_options.hxx>
+
+#include <future>
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace couchbase
+{
+namespace core
+{
+class cluster;
+} // namespace core
+class search_index_manager_impl;
+} // namespace couchbase
+#endif
+
+namespace couchbase
+{
+class scope;
+
+class scope_search_index_manager
+{
+  public:
+    /**
+     * Fetches a scope-level index from the server if it exists
+     *
+     * @param index_name the name of the index
+     * @param options optional parameters
+     * @param handler  handler that implements @ref get_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void get_index(std::string index_name, const get_search_index_options& options, get_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto get_index(std::string index_name, const get_search_index_options& options = {}) const
+      -> std::future<std::pair<manager_error_context, management::search::index>>;
+
+    /**
+     * Fetches all scope-level indexes from the server
+     *
+     * @param options optional parameters
+     * @param handler  handler that implements @ref get_all_search_indexes_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void get_all_indexes(const get_all_search_indexes_options& options, get_all_search_indexes_handler&& handler) const;
+
+    [[nodiscard]] auto get_all_indexes(const get_all_search_indexes_options& options = {}) const
+      -> std::future<std::pair<manager_error_context, std::vector<management::search::index>>>;
+
+    /**
+     * Creates, or updates a scope-level index
+     *
+     * @param search_index the index definition including name and settings
+     * @param options optional parameters
+     * @param handler  handler that implements @ref upsert_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void upsert_index(const management::search::index& search_index,
+                      const upsert_search_index_options& options,
+                      upsert_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto upsert_index(const management::search::index& search_index, const upsert_search_index_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+    /**
+     * Drops a scope-level index
+     *
+     * @param index_name the name of the search index
+     * @param options optional parameters
+     * @param handler  handler that implements @ref drop_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void drop_index(std::string index_name, const drop_search_index_options& options, drop_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto drop_index(std::string index_name, const drop_search_index_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+    /**
+     * Retrieves the number of documents that have been indexed for a scope-level index
+     *
+     * @param index_name the name of the search index
+     * @param options optional parameters
+     * @param handler  handler that implements @ref get_indexed_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void get_indexed_documents_count(std::string index_name,
+                                     const get_indexed_search_index_options& options,
+                                     get_indexed_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto 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>>;
+
+    /**
+     * Pauses updates and maintenance for a scope-level index.
+     *
+     * @param index_name the name of the search index
+     * @param options optional parameters
+     * @param handler  handler that implements @ref pause_ingest_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void pause_ingest(std::string index_name,
+                      const pause_ingest_search_index_options& options,
+                      pause_ingest_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto pause_ingest(std::string index_name, const pause_ingest_search_index_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+    /**
+     * Resumes updates and maintenance for a scope-level index.
+     *
+     * @param index_name the name of the search index
+     * @param options optional parameters
+     * @param handler  handler that implements @ref resume_ingest_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void resume_ingest(std::string index_name,
+                       const resume_ingest_search_index_options& options,
+                       resume_ingest_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto resume_ingest(std::string index_name, const resume_ingest_search_index_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+    /**
+     * Allows querying against a scope-level index
+     *
+     * @param index_name the name of the search index
+     * @param options optional parameters
+     * @param handler  handler that implements @ref allow_querying_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void allow_querying(std::string index_name,
+                        const allow_querying_search_index_options& options,
+                        allow_querying_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto allow_querying(std::string index_name, const allow_querying_search_index_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+    /**
+     * Disallows querying against a scope-level index
+     *
+     * @param index_name the name of the search index
+     * @param options optional parameters
+     * @param handler  handler that implements @ref disallow_querying_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void disallow_querying(std::string index_name,
+                           const disallow_querying_search_index_options& options,
+                           disallow_querying_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto disallow_querying(std::string index_name, const disallow_querying_search_index_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+    /**
+     * Freeze the assignment of scope-level index partitions to nodes.
+     *
+     * @param index_name the name of the search index
+     * @param options optional parameters
+     * @param handler  handler that implements @ref  freeze_plan_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void freeze_plan(std::string index_name,
+                     const freeze_plan_search_index_options& options,
+                     freeze_plan_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto freeze_plan(std::string index_name, const freeze_plan_search_index_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+    /**
+     * Unfreeze the assignment of scope-level index partitions to nodes.
+     *
+     * @param index_name the name of the search index
+     * @param options optional parameters
+     * @param handler  handler that implements @ref  unfreeze_plan_search_index_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void unfreeze_plan(std::string index_name,
+                       const unfreeze_plan_search_index_options& options,
+                       unfreeze_plan_search_index_handler&& handler) const;
+
+    [[nodiscard]] auto unfreeze_plan(std::string index_name, const unfreeze_plan_search_index_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+    /**
+     * Allows to see how a document is analyzed against a specific scope-level index.
+     *
+     * @param index_name the name of the search index
+     * @param document the document to be analyzed
+     * @param options optional parameters
+     * @param handler  handler that implements @ref analyze_document_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    template<typename Document>
+    void analyze_document(std::string index_name,
+                          Document document,
+                          const analyze_document_options& options,
+                          analyze_document_handler&& handler) const
+    {
+        auto encoded = couchbase::codec::default_json_transcoder::encode(document); // Encode as JSON and convert to string
+        auto decoded = std::string{ reinterpret_cast<const char*>(encoded.data.data()), encoded.data.size() };
+        return analyze_document(std::move(index_name), decoded, options, std::move(handler));
+    }
+
+    template<typename Document>
+    [[nodiscard]] auto analyze_document(std::string index_name, Document document, const analyze_document_options& options = {}) const
+      -> std::future<std::pair<manager_error_context, std::vector<std::string>>>
+    {
+        auto encoded = couchbase::codec::default_json_transcoder::encode(document); // Encode as JSON and convert to string
+        auto decoded = std::string{ reinterpret_cast<const char*>(encoded.data.data()), encoded.data.size() };
+
+        return analyze_document(std::move(index_name), decoded, options);
+    }
+
+    /**
+     * Allows to see how a document is analyzed against a specific scope-level index.
+     *
+     * @param index_name the name of the search index
+     * @param document the document to be analyzed encoded in JSON
+     * @param options optional parameters
+     * @param handler  handler that implements @ref analyze_document_handler
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void analyze_document(std::string index_name,
+                          std::string document,
+                          const analyze_document_options& options,
+                          analyze_document_handler&& handler) const;
+
+    [[nodiscard]] auto analyze_document(std::string index_name, std::string document, const analyze_document_options& options) const
+      -> std::future<std::pair<manager_error_context, std::vector<std::string>>>;
+
+  private:
+    friend class scope;
+
+    explicit scope_search_index_manager(core::cluster core, std::string bucket_name, std::string scope_name);
+
+    std::shared_ptr<search_index_manager_impl> impl_;
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/search_facet_result.hxx

@@ -17,14 +17,8 @@
 
 #pragma once
 
-#include <couchbase/codec/tao_json_serializer.hxx>
-#include <couchbase/search_meta_data.hxx>
-
-#include "search_row.hxx"
-#include <chrono>
 #include <cinttypes>
-#include <optional>
-#include <vector>
+#include <string>
 
 namespace couchbase
 {

package/deps/couchbase-cxx-client/couchbase/search_geo_distance_units.hxx

@@ -0,0 +1,26 @@
+/* -*- 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
+
+namespace couchbase
+{
+/**
+ * Enumeration of units for geo_distance sorting
+ */
+enum class search_geo_distance_units { meters, miles, centimeters, millimeters, nautical_miles, kilometers, feet, yards, inch };
+} // namespace couchbase