couchbase 4.2.8-dev.1 → 4.2.9

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

@@ -0,0 +1,292 @@
+/* -*- 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>
+#include <memory>
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace couchbase
+{
+namespace core
+{
+class cluster;
+} // namespace core
+class search_index_manager_impl;
+} // namespace couchbase
+#endif
+
+namespace couchbase
+{
+class cluster;
+
+class search_index_manager
+{
+  public:
+    /**
+     * Fetches an 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
+     * @committed
+     */
+    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 indexes from the server
+     *
+     * @param options optional parameters
+     * @param handler  handler that implements @ref get_all_search_indexes_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    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 an 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
+     * @committed
+     */
+    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 an 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
+     * @committed
+     */
+    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 an 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
+     * @committed
+     */
+    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 an 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
+     * @committed
+     */
+    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 an 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
+     * @committed
+     */
+    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 an 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
+     * @committed
+     */
+    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 an 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
+     * @committed
+     */
+    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 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
+     * @committed
+     */
+    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 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
+     * @committed
+     */
+    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 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
+     * @committed
+     */
+    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 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
+     * @committed
+     */
+    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 cluster;
+
+    explicit search_index_manager(core::cluster core);
+
+    std::shared_ptr<search_index_manager_impl> impl_;
+};
+} // namespace couchbase

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

@@ -41,6 +41,16 @@ class search_row_location
      */
     explicit search_row_location(internal_search_row_location location);
 
+    search_row_location();
+
+    ~search_row_location();
+
+    search_row_location(const search_row_location&) = delete;
+    search_row_location& operator=(const search_row_location&) = delete;
+
+    search_row_location(search_row_location&&) noexcept;
+    search_row_location& operator=(search_row_location&&) noexcept;
+
     [[nodiscard]] auto field() const -> const std::string&;
     [[nodiscard]] auto term() const -> const std::string&;
     [[nodiscard]] auto position() const -> const std::uint64_t&;

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

@@ -0,0 +1,84 @@
+/* -*- 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/geo_point.hxx>
+#include <couchbase/search_geo_distance_units.hxx>
+#include <couchbase/search_sort.hxx>
+
+#include <string>
+
+namespace couchbase
+{
+/**
+ * Sorts by location in the hits
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-search-request.html#sorting-with-objects
+ *
+ * @since 1.0.0
+ */
+class search_sort_geo_distance : public search_sort
+{
+  public:
+    search_sort_geo_distance(geo_point location, std::string field)
+      : location_{ location }
+      , field_{ std::move(field) }
+    {
+    }
+
+    search_sort_geo_distance(double latitude, double longitude, std::string field)
+      : location_{ geo_point{ latitude, longitude } }
+      , field_{ std::move(field) }
+    {
+    }
+
+    /**
+     * Set the sorting direction.
+     *
+     * @param desc `true` for descending order, `false` for ascending
+     * @return pointer to this
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto descending(bool desc) -> search_sort_geo_distance&;
+
+    /**
+     * Specifies the unit used for sorting
+     *
+     * @param unit the unit used
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto unit(search_geo_distance_units unit) -> search_sort_geo_distance&;
+
+    /**
+     * @return encoded representation of the search facet.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_sort override;
+
+  private:
+    geo_point location_;
+    std::string field_;
+    std::optional<search_geo_distance_units> unit_;
+};
+} // namespace couchbase

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "tls_verify_mode.hxx"
+#include <couchbase/tls_verify_mode.hxx>
 
 #include <optional>
 #include <string>

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

@@ -67,28 +67,4 @@ struct touch_options : public common_options<touch_options> {
  * @uncommitted
  */
 using touch_handler = std::function<void(couchbase::key_value_error_context, result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_touch_operation(std::shared_ptr<couchbase::core::cluster> core,
-                         std::string bucket_name,
-                         std::string scope_name,
-                         std::string collection_name,
-                         std::string document_key,
-                         std::uint32_t expiry,
-                         couchbase::touch_options::built options,
-                         couchbase::touch_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/tracing/request_tracer.hxx

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "request_span.hxx"
+#include <couchbase/tracing/request_span.hxx>
 
 #include <memory>
 #include <string>

package/deps/couchbase-cxx-client/couchbase/transactions/async_attempt_context.hxx

@@ -15,12 +15,16 @@
  */
 #pragma once
 
-#include <couchbase/scope.hxx>
 #include <couchbase/transactions/transaction_get_result.hxx>
 #include <couchbase/transactions/transaction_query_options.hxx>
 #include <couchbase/transactions/transaction_query_result.hxx>
 
-namespace couchbase::transactions
+namespace couchbase
+{
+class collection;
+class scope;
+
+namespace transactions
 {
 using async_result_handler = std::function<void(transaction_op_error_context, transaction_get_result)>;
 using async_query_handler = std::function<void(transaction_op_error_context, transaction_query_result)>;
@@ -111,10 +115,8 @@ class async_attempt_context
      * @param opts Options for the query
      * @param handler Handler which implements @ref async_query_handler.
      */
-    void query(const scope& scope, std::string statement, transaction_query_options opts, async_query_handler&& handler)
-    {
-        return query(std::move(statement), std::move(opts), fmt::format("{}.{}", scope.bucket_name(), scope.name()), std::move(handler));
-    }
+    void query(const scope& scope, std::string statement, transaction_query_options opts, async_query_handler&& handler);
+
     /**
      * Perform a query.
      *
@@ -154,4 +156,5 @@ class async_attempt_context
                        std::optional<std::string> query_context,
                        async_query_handler&&) = 0;
 };
-} // namespace couchbase::transactions
+} // namespace transactions
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/transactions/attempt_context.hxx

@@ -19,7 +19,12 @@
 #include <couchbase/transactions/transaction_query_options.hxx>
 #include <couchbase/transactions/transaction_query_result.hxx>
 
-namespace couchbase::transactions
+namespace couchbase
+{
+class collection;
+class scope;
+
+namespace transactions
 {
 /**
  * The attempt_context is used for all synchronous transaction operations
@@ -108,10 +113,7 @@ class attempt_context
      * @return The result of the operation, with is an @ref transaction_op_error_context and a @ref transaction_query_result.
      */
     std::pair<transaction_op_error_context, transaction_query_result> query(const std::string& statement,
-                                                                            const transaction_query_options& options = {})
-    {
-        return do_public_query(statement, options, {});
-    }
+                                                                            const transaction_query_options& options = {});
 
     /**
      * Perform a scoped query.
@@ -123,10 +125,7 @@ class attempt_context
      */
     std::pair<transaction_op_error_context, transaction_query_result> query(const scope& scope,
                                                                             const std::string& statement,
-                                                                            const transaction_query_options& opts = {})
-    {
-        return do_public_query(statement, opts, fmt::format("{}.{}", scope.bucket_name(), scope.name()));
-    }
+                                                                            const transaction_query_options& opts = {});
 
     virtual ~attempt_context() = default;
 
@@ -143,4 +142,5 @@ class attempt_context
                                                                                               const transaction_query_options& options,
                                                                                               std::optional<std::string> query_context) = 0;
 };
-} // namespace couchbase::transactions
+} // namespace transactions
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/transactions/transaction_keyspace.hxx

@@ -15,12 +15,7 @@
  */
 #pragma once
 
-#include "couchbase/collection.hxx"
-#include "couchbase/scope.hxx"
-
-#include <fmt/format.h>
 #include <string>
-#include <utility>
 
 namespace couchbase::transactions
 {
@@ -28,44 +23,15 @@ namespace couchbase::transactions
  * @brief  Offline, serializable representation of a bucket, scope, and collection
  */
 struct transaction_keyspace {
+    transaction_keyspace(std::string bucket_name, std::string scope_name, std::string collection_name);
 
-    std::string bucket;
-    std::string scope{ couchbase::scope::default_name };
-    std::string collection{ couchbase::collection::default_name };
+    explicit transaction_keyspace(const std::string& bucket_name);
 
-    transaction_keyspace(const transaction_keyspace&) = default;
-    transaction_keyspace(transaction_keyspace&&) = default;
-    transaction_keyspace& operator=(const transaction_keyspace& keyspace)
-    {
-        if (this != &keyspace) {
-            bucket = keyspace.bucket;
-            scope = keyspace.scope;
-            collection = keyspace.collection;
-        }
-        return *this;
-    }
-    bool operator==(const transaction_keyspace& keyspace)
+    bool operator==(const transaction_keyspace& keyspace) const
     {
         return bucket == keyspace.bucket && scope == keyspace.scope && collection == keyspace.collection;
     }
 
-    transaction_keyspace(std::string bucket_name, std::string scope_name, std::string collection_name)
-      : bucket(std::move(bucket_name))
-      , scope(std::move(scope_name))
-      , collection(std::move(collection_name))
-    {
-        if (scope.empty()) {
-            scope = couchbase::scope::default_name;
-        }
-        if (collection.empty()) {
-            collection = couchbase::collection::default_name;
-        }
-    }
-
-    explicit transaction_keyspace(const std::string& bucket_name)
-      : transaction_keyspace{ bucket_name, couchbase::scope::default_name, couchbase::collection::default_name }
-    {
-    }
     /**
      * Check if a keyspace is valid.
      *
@@ -74,10 +40,7 @@ struct transaction_keyspace {
      *
      * @return true if valid.
      */
-    bool valid()
-    {
-        return !bucket.empty() && !scope.empty() && !collection.empty();
-    }
+    bool valid();
 
     /** @private */
     template<typename OStream>
@@ -90,22 +53,9 @@ struct transaction_keyspace {
         os << "}";
         return os;
     }
+
+    std::string bucket;
+    std::string scope;
+    std::string collection;
 };
 } // namespace couchbase::transactions
-
-/** @private */
-template<>
-struct fmt::formatter<couchbase::transactions::transaction_keyspace> {
-  public:
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
-
-    template<typename FormatContext>
-    auto format(const couchbase::transactions::transaction_keyspace& k, FormatContext& ctx) const
-    {
-        return format_to(ctx.out(), "transaction_keyspace:{{ bucket: {}, scope: {}, collection: {} }}", k.bucket, k.scope, k.collection);
-    }
-};