couchbase 4.2.9 → 4.2.11-rc.1

package/deps/couchbase-cxx-client/core/topology/configuration_fmt.hxx

@@ -160,7 +160,7 @@ struct fmt::formatter<couchbase::core::topology::configuration> {
                          config.vbmap.has_value() ? fmt::format(", partitions={}", config.vbmap->size()) : "",
                          config.nodes.size(),
                          couchbase::core::utils::join_strings_fmt(config.nodes, ", "),
-                         couchbase::core::utils::join_strings_fmt(config.bucket_capabilities, ", "),
-                         couchbase::core::utils::join_strings_fmt(config.cluster_capabilities, ", "));
+                         couchbase::core::utils::join_strings_fmt(config.capabilities.bucket, ", "),
+                         couchbase::core::utils::join_strings_fmt(config.capabilities.cluster, ", "));
     }
 };

package/deps/couchbase-cxx-client/core/topology/configuration_json.hxx

@@ -213,33 +213,47 @@ struct traits<couchbase::core::topology::configuration> {
             for (const auto& entry : m->get_array()) {
                 const auto& name = entry.get_string();
                 if (name == "couchapi") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::couchapi);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::couchapi);
                 } else if (name == "collections") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::collections);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::collections);
                 } else if (name == "durableWrite") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::durable_write);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::durable_write);
                 } else if (name == "tombstonedUserXAttrs") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::tombstoned_user_xattrs);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::tombstoned_user_xattrs);
                 } else if (name == "dcp") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::dcp);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::dcp);
                 } else if (name == "cbhello") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::cbhello);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::cbhello);
                 } else if (name == "touch") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::touch);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::touch);
                 } else if (name == "cccp") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::cccp);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::cccp);
                 } else if (name == "xdcrCheckpointing") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::xdcr_checkpointing);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::xdcr_checkpointing);
                 } else if (name == "nodesExt") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::nodes_ext);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::nodes_ext);
                 } else if (name == "xattr") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::xattr);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::xattr);
                 } else if (name == "rangeScan") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::range_scan);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::range_scan);
                 } else if (name == "subdoc.ReplicaRead") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::replica_read);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::subdoc_replica_read);
                 } else if (name == "nonDedupedHistory") {
-                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::non_deduped_history);
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::non_deduped_history);
+                } else if (name == "subdoc.ReplaceBodyWithXattr") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::subdoc_replace_body_with_xattr);
+                } else if (name == "subdoc.DocumentMacroSupport") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::subdoc_document_macro_support);
+                } else if (name == "subdoc.ReviveDocument") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::subdoc_revive_document);
+                } else if (name == "dcp.IgnorePurgedTombstones") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::dcp_ignore_purged_tombstones);
+                } else if (name == "preserve_expiry") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::preserve_expiry);
+                } else if (name == "querySystemCollection") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::query_system_collection);
+                } else if (name == "mobileSystemCollection") {
+                    result.capabilities.bucket.insert(couchbase::core::bucket_capability::mobile_system_collection);
                 }
             }
         }
@@ -247,17 +261,26 @@ struct traits<couchbase::core::topology::configuration> {
             if (const auto nc = m->find("n1ql"); nc != nullptr && nc->is_array()) {
                 for (const auto& entry : nc->get_array()) {
                     if (const auto& name = entry.get_string(); name == "costBasedOptimizer") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_cost_based_optimizer);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_cost_based_optimizer);
                     } else if (name == "indexAdvisor") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_index_advisor);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_index_advisor);
                     } else if (name == "javaScriptFunctions") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_javascript_functions);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_javascript_functions);
                     } else if (name == "inlineFunctions") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_inline_functions);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_inline_functions);
                     } else if (name == "enhancedPreparedStatements") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements);
                     } else if (name == "readFromReplica") {
-                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_read_from_replica);
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::n1ql_read_from_replica);
+                    }
+                }
+            }
+            if (const auto sc = m->find("search"); sc != nullptr && sc->is_array()) {
+                for (const auto& entry : sc->get_array()) {
+                    if (const auto& name = entry.get_string(); name == "vectorSearch") {
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::search_vector_search);
+                    } else if (name == "scopedSearchIndex") {
+                        result.capabilities.cluster.insert(couchbase::core::cluster_capability::search_scoped_search_index);
                     }
                 }
             }

package/deps/couchbase-cxx-client/core/transactions/internal/exceptions_internal.hxx

@@ -230,6 +230,11 @@ class transaction_operation_failed : public std::runtime_error
         return cause_;
     }
 
+    final_error to_raise() const
+    {
+        return to_raise_;
+    }
+
     void do_throw(const transaction_context& context) const
     {
         if (to_raise_ == FAILED_POST_COMMIT) {

package/deps/couchbase-cxx-client/core/transactions/internal/utils.hxx

@@ -242,6 +242,7 @@ struct exp_delay {
     std::chrono::nanoseconds timeout;
     mutable std::uint32_t retries;
     mutable std::optional<std::chrono::time_point<std::chrono::steady_clock>> end_time;
+    std::size_t max_retries{ 100 };
 
     template<typename R1, typename P1, typename R2, typename P2, typename R3, typename P3>
     exp_delay(std::chrono::duration<R1, P1> initial, std::chrono::duration<R2, P2> max, std::chrono::duration<R3, P3> limit)
@@ -255,6 +256,9 @@ struct exp_delay {
     void operator()() const
     {
         auto now = std::chrono::steady_clock::now();
+        if (retries >= max_retries) {
+            throw retry_operation_retries_exhausted("retries exhausted");
+        }
         if (!end_time) {
             end_time = std::chrono::steady_clock::now() + timeout;
             return;

package/deps/couchbase-cxx-client/core/vector_query_combination.hxx

@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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::core
+{
+enum class vector_query_combination { combination_and, combination_or };
+} // namespace couchbase::core

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/collection.hxx>
 #include <couchbase/collection_manager.hxx>
+#include <couchbase/ping_options.hxx>
 #include <couchbase/scope.hxx>
 
 #include <memory>
@@ -74,6 +75,34 @@ class bucket
      */
     [[nodiscard]] auto scope(std::string_view scope_name) const -> scope;
 
+    /**
+     * Performs application-level ping requests against services in the Couchbase cluster.
+     *
+     * @note This operation performs active I/O against services and endpoints to assess their health. If you do not
+     * wish to performs I/O, consider using @ref diagnostics() instead.
+     *
+     * @param options custom options to change the default behavior.
+     * @param handler the handler that implements @ref ping_handler.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void ping(const ping_options& options, ping_handler&& handler) const;
+
+    /**
+     * Performs application-level ping requests against services in the Couchbase cluster.
+     *
+     * @note This operation performs active I/O against services and endpoints to assess their health. If you do not
+     * wish to performs I/O, consider using @ref diagnostics() instead.
+     *
+     * @param options custom options to change the default behavior.
+     * @return future object that carries result of the operation.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto ping(const ping_options& options = {}) const -> std::future<ping_result>;
+
     /**
      * Provides access to the collection management services.
      *

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

@@ -22,11 +22,14 @@
 #include <couchbase/bucket.hxx>
 #include <couchbase/bucket_manager.hxx>
 #include <couchbase/cluster_options.hxx>
+#include <couchbase/diagnostics_options.hxx>
+#include <couchbase/ping_options.hxx>
 #include <couchbase/query_index_manager.hxx>
 #include <couchbase/query_options.hxx>
 #include <couchbase/search_index_manager.hxx>
 #include <couchbase/search_options.hxx>
 #include <couchbase/search_query.hxx>
+#include <couchbase/search_request.hxx>
 #include <couchbase/transactions.hxx>
 
 #include <memory>
@@ -141,6 +144,9 @@ class cluster
     /**
      * Performs a query against the full text search services.
      *
+     * Consider using the newer @ref cluster::search() interface instead, which can be used
+     * for both traditional FTS queries, and to perform a @ref vector_search
+     *
      * @param index_name name of the search index
      * @param query query object, see hierarchy of @ref search_query for more details.
      * @param options options to customize the query request.
@@ -159,6 +165,9 @@ class cluster
     /**
      * Performs a query against the full text search services.
      *
+     * Consider using the newer @ref cluster::search() interface instead, which can be used
+     * for both traditional FTS queries, and to perform 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 options options to customize the query request.
@@ -175,6 +184,47 @@ class cluster
     [[nodiscard]] auto 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>>;
 
+    /**
+     * 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 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
+     *
+     * @exception errc::common::ambiguous_timeout
+     * @exception errc::common::unambiguous_timeout
+     *
+     * @see https://docs.couchbase.com/server/current/fts/fts-introduction.html
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void search(std::string index_name, search_request request, const search_options& options, search_handler&& handler) const;
+
+    /**
+     * 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 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
+     *
+     * @exception errc::common::ambiguous_timeout
+     * @exception errc::common::unambiguous_timeout
+     *
+     * @see https://docs.couchbase.com/server/current/fts/fts-introduction.html
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    [[nodiscard]] auto search(std::string index_name, search_request request, const search_options& = {}) const
+      -> std::future<std::pair<search_error_context, search_result>>;
+
     /**
      * Performs a query against the analytics services.
      *
@@ -207,6 +257,66 @@ class cluster
     [[nodiscard]] auto analytics_query(std::string statement, const analytics_options& options = {}) const
       -> std::future<std::pair<analytics_error_context, analytics_result>>;
 
+    /**
+     * Performs application-level ping requests against services in the Couchbase cluster.
+     *
+     * @note This operation performs active I/O against services and endpoints to assess their health. If you do not
+     * wish to performs I/O, consider using @ref diagnostics() instead.
+     *
+     * @param options custom options to change the default behavior.
+     * @param handler the handler that implements @ref ping_handler.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void ping(const ping_options& options, ping_handler&& handler) const;
+
+    /**
+     * Performs application-level ping requests against services in the Couchbase cluster.
+     *
+     * @note This operation performs active I/O against services and endpoints to assess their health. If you do not
+     * wish to performs I/O, consider using @ref diagnostics() instead.
+     *
+     * @param options custom options to change the default behavior.
+     * @return future object that carries result of the operation.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto ping(const ping_options& options = {}) const -> std::future<ping_result>;
+
+    /**
+     * Assembles a diagnostics report on the current state of the cluster from the SDK's point of view.
+     *
+     * @note This operation does not perform any I/O to produce the report. It will only use the current known state of
+     * the cluster to assemble the report So, if for example, no SQL++ queries have been run, the Query service's socket
+     * pool might be empty and as a result not show up in the report. If you wish to actively assess the health of the
+     * cluster by performing I/O, consider using @ref ping() instead.
+     *
+     * @param options custom options to change the default behavior.
+     * @param handler the handler that implements @ref diagnostics_handler.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void diagnostics(const diagnostics_options& options, diagnostics_handler&& handler) const;
+
+    /**
+     * Assembles a diagnostics report on the current state of the cluster from the SDK's point of view.
+     *
+     * @note This operation does not perform any I/O to produce the report. It will only use the current known state of
+     * the cluster to assemble the report So, if for example, no SQL++ queries have been run, the Query service's socket
+     * pool might be empty and as a result not show up in the report. If you wish to actively assess the health of the
+     * cluster by performing I/O, consider using @ref ping() instead.
+     *
+     * @param options custom options to change the default behavior.
+     * @return future object that carries result of the operation.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto diagnostics(const diagnostics_options& options = {}) const -> std::future<diagnostics_result>;
+
     /**
      * Provides access to the N1QL index management services.
      *

package/deps/couchbase-cxx-client/couchbase/codec/json_transcoder.hxx

@@ -40,7 +40,7 @@ class json_transcoder
     {
         if (encoded.flags != 0 && !codec_flags::has_common_flags(encoded.flags, codec_flags::json_common_flags)) {
             throw std::system_error(errc::common::decoding_failure,
-                                    "json_transcoder excepts document to have JSON common flags, flags=" + std::to_string(encoded.flags));
+                                    "json_transcoder expects document to have JSON common flags, flags=" + std::to_string(encoded.flags));
         }
 
         return Serializer::template deserialize<Document>(encoded.data);

package/deps/couchbase-cxx-client/couchbase/codec/raw_binary_transcoder.hxx

@@ -21,6 +21,7 @@
 #include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/codec/transcoder_traits.hxx>
 #include <couchbase/error_codes.hxx>
+
 #include <type_traits>
 
 namespace couchbase::codec
@@ -40,7 +41,7 @@ class raw_binary_transcoder
     {
         if (!codec_flags::has_common_flags(encoded.flags, codec_flags::binary_common_flags)) {
             throw std::system_error(errc::common::decoding_failure,
-                                    "raw_binary_transcoder excepts document to have BINARY common flags, flags=" +
+                                    "raw_binary_transcoder expects document to have BINARY common flags, flags=" +
                                       std::to_string(encoded.flags));
         }
 

package/deps/couchbase-cxx-client/couchbase/codec/raw_json_transcoder.hxx

@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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/codec/codec_flags.hxx>
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/codec/transcoder_traits.hxx>
+#include <couchbase/error_codes.hxx>
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+namespace couchbase
+{
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core::utils
+{
+std::vector<std::byte>
+to_binary(std::string_view value) noexcept;
+} // namespace core::utils
+#endif
+
+namespace codec
+{
+class raw_json_transcoder
+{
+  public:
+    template<typename Document, std::enable_if_t<std::is_same_v<Document, std::string> || std::is_same_v<Document, binary>, bool> = true>
+    static auto encode(const Document& document) -> encoded_value
+    {
+        if constexpr (std::is_same_v<Document, std::string>) {
+            return { core::utils::to_binary(document), codec_flags::json_common_flags };
+        } else {
+            return { std::move(document), codec_flags::json_common_flags };
+        }
+    }
+
+    template<typename Document, std::enable_if_t<std::is_same_v<Document, std::string> || std::is_same_v<Document, binary>, bool> = true>
+    static auto decode(const encoded_value& encoded) -> Document
+    {
+        if (!codec_flags::has_common_flags(encoded.flags, codec_flags::json_common_flags)) {
+            throw std::system_error(errc::common::decoding_failure,
+                                    "raw_json_transcoder expects document to have JSON common flags, flags=" +
+                                      std::to_string(encoded.flags));
+        }
+        if constexpr (std::is_same_v<Document, std::string>) {
+            return std::string{ reinterpret_cast<const char*>(encoded.data.data()), encoded.data.size() };
+        } else {
+            return encoded.data;
+        }
+    }
+};
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+template<>
+struct is_transcoder<raw_json_transcoder> : public std::true_type {
+};
+#endif
+} // namespace codec
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/codec/raw_string_transcoder.hxx

@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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/codec/codec_flags.hxx>
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/codec/transcoder_traits.hxx>
+#include <couchbase/error_codes.hxx>
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+namespace couchbase
+{
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core::utils
+{
+std::vector<std::byte>
+to_binary(std::string_view value) noexcept;
+} // namespace core::utils
+#endif
+
+namespace codec
+{
+class raw_string_transcoder
+{
+  public:
+    using document_type = std::string;
+
+    static auto encode(document_type document) -> encoded_value
+    {
+        return { core::utils::to_binary(document), codec_flags::string_common_flags };
+    }
+
+    template<typename Document = document_type, std::enable_if_t<std::is_same_v<Document, document_type>, bool> = true>
+    static auto decode(const encoded_value& encoded) -> Document
+    {
+        if (!codec_flags::has_common_flags(encoded.flags, codec_flags::string_common_flags)) {
+            throw std::system_error(errc::common::decoding_failure,
+                                    "raw_string_transcoder expects document to have STRING common flags, flags=" +
+                                      std::to_string(encoded.flags));
+        }
+
+        return std::string{ reinterpret_cast<const char*>(encoded.data.data()), encoded.data.size() };
+    }
+};
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+template<>
+struct is_transcoder<raw_string_transcoder> : public std::true_type {
+};
+#endif
+} // namespace codec
+} // namespace couchbase