couchbase 4.2.3 → 4.2.4

package/deps/couchbase-cxx-client/core/utils/connection_string.cxx

@@ -182,33 +182,39 @@ struct action<bucket_name> {
 } // namespace priv
 
 void
-parse_option(std::string& receiver, const std::string& /* name */, const std::string& value)
+parse_option(std::string& receiver, const std::string& /* name */, const std::string& value, std::vector<std::string>& /* warnings */)
 {
     receiver = string_codec::url_decode(value);
 }
 
 void
-parse_option(bool& receiver, const std::string& /* name */, const std::string& value)
+parse_option(bool& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     if (value == "true" || value == "yes" || value == "on") {
         receiver = true;
     } else if (value == "false" || value == "no" || value == "off") {
         receiver = false;
+    } else {
+        warnings.push_back(fmt::format(
+          R"(unable to parse "{}" parameter in connection string (value "{}" cannot be interpreted as a boolean))", name, value));
     }
 }
 
 void
-parse_option(tls_verify_mode& receiver, const std::string& /* name */, const std::string& value)
+parse_option(tls_verify_mode& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     if (value == "none") {
         receiver = tls_verify_mode::none;
     } else if (value == "peer") {
         receiver = tls_verify_mode::peer;
+    } else {
+        warnings.push_back(fmt::format(
+          R"(unable to parse "{}" parameter in connection string (value "{}" is not a valid TLS verification mode))", name, value));
     }
 }
 
 void
-parse_option(io::ip_protocol& receiver, const std::string& /* name */, const std::string& value)
+parse_option(io::ip_protocol& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     if (value == "any") {
         receiver = io::ip_protocol::any;
@@ -216,23 +222,28 @@ parse_option(io::ip_protocol& receiver, const std::string& /* name */, const std
         receiver = io::ip_protocol::force_ipv4;
     } else if (value == "force_ipv6") {
         receiver = io::ip_protocol::force_ipv6;
+    } else {
+        warnings.push_back(fmt::format(
+          R"(unable to parse "{}" parameter in connection string (value "{}" is not a valid IP protocol preference))", name, value));
     }
 }
 
 void
-parse_option(std::size_t& receiver, const std::string& name, const std::string& value)
+parse_option(std::size_t& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     try {
         receiver = std::stoull(value, nullptr, 10);
     } catch (const std::invalid_argument& ex1) {
-        CB_LOG_WARNING(R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})", name, value, ex1.what());
+        warnings.push_back(
+          fmt::format(R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})", name, value, ex1.what()));
     } catch (const std::out_of_range& ex2) {
-        CB_LOG_WARNING(R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})", name, value, ex2.what());
+        warnings.push_back(
+          fmt::format(R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})", name, value, ex2.what()));
     }
 }
 
 void
-parse_option(std::chrono::milliseconds& receiver, const std::string& name, const std::string& value)
+parse_option(std::chrono::milliseconds& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     try {
         receiver = std::chrono::duration_cast<std::chrono::milliseconds>(parse_duration(value));
@@ -240,11 +251,11 @@ parse_option(std::chrono::milliseconds& receiver, const std::string& name, const
         try {
             receiver = std::chrono::milliseconds(std::stoull(value, nullptr, 10));
         } catch (const std::invalid_argument& ex1) {
-            CB_LOG_WARNING(
-              R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})", name, value, ex1.what());
+            warnings.push_back(fmt::format(
+              R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})", name, value, ex1.what()));
         } catch (const std::out_of_range& ex2) {
-            CB_LOG_WARNING(
-              R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})", name, value, ex2.what());
+            warnings.push_back(fmt::format(
+              R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})", name, value, ex2.what()));
         }
     }
 }
@@ -262,68 +273,68 @@ extract_options(connection_string& connstr)
              * Number of seconds the client should wait while attempting to connect to a node’s KV service via a socket.  Initial
              * connection, reconnecting, node added, etc.
              */
-            parse_option(connstr.options.connect_timeout, name, value);
+            parse_option(connstr.options.connect_timeout, name, value, connstr.warnings);
         } else if (name == "kv_timeout" || name == "key_value_timeout") {
             /**
              * Number of milliseconds to wait before timing out a KV operation by the client.
              */
-            parse_option(connstr.options.key_value_timeout, name, value);
+            parse_option(connstr.options.key_value_timeout, name, value, connstr.warnings);
         } else if (name == "kv_durable_timeout" || name == "key_value_durable_timeout") {
             /**
              * Number of milliseconds to wait before timing out a KV operation that is either using synchronous durability or
              * observe-based durability.
              */
-            parse_option(connstr.options.key_value_durable_timeout, name, value);
+            parse_option(connstr.options.key_value_durable_timeout, name, value, connstr.warnings);
         } else if (name == "view_timeout") {
             /**
              * Number of seconds to wait before timing out a View request  by the client..
              */
-            parse_option(connstr.options.view_timeout, name, value);
+            parse_option(connstr.options.view_timeout, name, value, connstr.warnings);
         } else if (name == "query_timeout") {
             /**
              * Number of seconds to wait before timing out a Query or N1QL request by the client.
              */
-            parse_option(connstr.options.query_timeout, name, value);
+            parse_option(connstr.options.query_timeout, name, value, connstr.warnings);
         } else if (name == "analytics_timeout") {
             /**
              * Number of seconds to wait before timing out an Analytics request by the client.
              */
-            parse_option(connstr.options.analytics_timeout, name, value);
+            parse_option(connstr.options.analytics_timeout, name, value, connstr.warnings);
         } else if (name == "search_timeout") {
             /**
              * Number of seconds to wait before timing out a Search request by the client.
              */
-            parse_option(connstr.options.search_timeout, name, value);
+            parse_option(connstr.options.search_timeout, name, value, connstr.warnings);
         } else if (name == "management_timeout") {
             /**
              * Number of seconds to wait before timing out a Management API request by the client.
              */
-            parse_option(connstr.options.management_timeout, name, value);
+            parse_option(connstr.options.management_timeout, name, value, connstr.warnings);
         } else if (name == "trust_certificate") {
-            parse_option(connstr.options.trust_certificate, name, value);
+            parse_option(connstr.options.trust_certificate, name, value, connstr.warnings);
         } else if (name == "enable_mutation_tokens") {
             /**
              * Request mutation tokens at connection negotiation time. Turning this off will save 16 bytes per operation response.
              */
-            parse_option(connstr.options.enable_mutation_tokens, name, value);
+            parse_option(connstr.options.enable_mutation_tokens, name, value, connstr.warnings);
         } else if (name == "enable_tcp_keep_alive") {
             /**
              * Gets or sets a value indicating whether enable TCP keep-alive.
              */
-            parse_option(connstr.options.enable_tcp_keep_alive, name, value);
+            parse_option(connstr.options.enable_tcp_keep_alive, name, value, connstr.warnings);
         } else if (name == "tcp_keep_alive_interval") {
             /**
              * Specifies the timeout, in milliseconds, with no activity until the first keep-alive packet is sent. This applies to all
              * services, but is advisory: if the underlying platform does not support this on all connections, it will be applied only
              * on those it can be.
              */
-            parse_option(connstr.options.tcp_keep_alive_interval, name, value);
+            parse_option(connstr.options.tcp_keep_alive_interval, name, value, connstr.warnings);
         } else if (name == "force_ipv4") {
             /**
              * Sets the SDK configuration to do IPv4 Name Resolution
              */
             bool force_ipv4 = false;
-            parse_option(force_ipv4, name, value);
+            parse_option(force_ipv4, name, value, connstr.warnings);
             if (force_ipv4) {
                 connstr.options.use_ip_protocol = io::ip_protocol::force_ipv4;
             }
@@ -331,40 +342,40 @@ extract_options(connection_string& connstr)
             /**
              * Controls preference of IP protocol for name resolution
              */
-            parse_option(connstr.options.use_ip_protocol, name, value);
+            parse_option(connstr.options.use_ip_protocol, name, value, connstr.warnings);
         } else if (name == "config_poll_interval") {
-            parse_option(connstr.options.config_poll_interval, name, value);
+            parse_option(connstr.options.config_poll_interval, name, value, connstr.warnings);
         } else if (name == "config_poll_floor") {
-            parse_option(connstr.options.config_poll_floor, name, value);
+            parse_option(connstr.options.config_poll_floor, name, value, connstr.warnings);
         } else if (name == "max_http_connections") {
             /**
              * The maximum number of HTTP connections allowed on a per-host and per-port basis.  0 indicates an unlimited number of
              * connections are permitted.
              */
-            parse_option(connstr.options.max_http_connections, name, value);
+            parse_option(connstr.options.max_http_connections, name, value, connstr.warnings);
         } else if (name == "idle_http_connection_timeout") {
             /**
              * The period of time an HTTP connection can be idle before it is forcefully disconnected.
              */
-            parse_option(connstr.options.idle_http_connection_timeout, name, value);
+            parse_option(connstr.options.idle_http_connection_timeout, name, value, connstr.warnings);
         } else if (name == "bootstrap_timeout") {
             /**
              * The period of time allocated to complete bootstrap
              */
-            parse_option(connstr.options.bootstrap_timeout, name, value);
+            parse_option(connstr.options.bootstrap_timeout, name, value, connstr.warnings);
         } else if (name == "resolve_timeout") {
             /**
              * The period of time to resolve DNS name of the node to IP address
              */
-            parse_option(connstr.options.resolve_timeout, name, value);
+            parse_option(connstr.options.resolve_timeout, name, value, connstr.warnings);
         } else if (name == "enable_dns_srv") {
             if (connstr.bootstrap_nodes.size() == 1) {
-                parse_option(connstr.options.enable_dns_srv, name, value);
+                parse_option(connstr.options.enable_dns_srv, name, value, connstr.warnings);
             } else {
-                CB_LOG_WARNING(
-                  R"(parameter "{}" require single entry in bootstrap nodes list of the connection string, ignoring (value "{}"))",
+                connstr.warnings.push_back(fmt::format(
+                  R"(parameter "{}" requires single entry in bootstrap nodes list of the connection string, ignoring (value "{}"))",
                   name,
-                  value);
+                  value));
             }
         } else if (name == "network") {
             connstr.options.network = value; /* current known values are "auto", "default" and "external" */
@@ -372,49 +383,51 @@ extract_options(connection_string& connstr)
             /**
              * Whether to display N1QL, Analytics, Search queries on info level (default false)
              */
-            parse_option(connstr.options.show_queries, name, value);
+            parse_option(connstr.options.show_queries, name, value, connstr.warnings);
         } else if (name == "enable_clustermap_notification") {
             /**
              * Allow the server to push configuration updates asynchronously.
              */
-            parse_option(connstr.options.enable_clustermap_notification, name, value);
+            parse_option(connstr.options.enable_clustermap_notification, name, value, connstr.warnings);
         } else if (name == "enable_unordered_execution") {
             /**
              * Allow the server to reorder commands
              */
-            parse_option(connstr.options.enable_unordered_execution, name, value);
+            parse_option(connstr.options.enable_unordered_execution, name, value, connstr.warnings);
         } else if (name == "enable_compression") {
             /**
              * Announce support of compression (snappy) to server
              */
-            parse_option(connstr.options.enable_compression, name, value);
+            parse_option(connstr.options.enable_compression, name, value, connstr.warnings);
         } else if (name == "enable_tracing") {
             /**
              * true - use threshold_logging_tracer
              * false - use noop_tracer
              */
-            parse_option(connstr.options.enable_tracing, name, value);
+            parse_option(connstr.options.enable_tracing, name, value, connstr.warnings);
         } else if (name == "enable_metrics") {
             /**
              * true - use logging_meter
              * false - use noop_meter
              */
-            parse_option(connstr.options.enable_metrics, name, value);
+            parse_option(connstr.options.enable_metrics, name, value, connstr.warnings);
         } else if (name == "tls_verify") {
-            parse_option(connstr.options.tls_verify, name, value);
+            parse_option(connstr.options.tls_verify, name, value, connstr.warnings);
+        } else if (name == "disable_mozilla_ca_certificates") {
+            parse_option(connstr.options.disable_mozilla_ca_certificates, name, value, connstr.warnings);
         } else if (name == "user_agent_extra") {
             /**
              * string, that will be appended to identification fields of the server protocols (key in HELO packet for MCBP, "user-agent"
              * header for HTTP)
              */
-            parse_option(connstr.options.user_agent_extra, name, value);
+            parse_option(connstr.options.user_agent_extra, name, value, connstr.warnings);
         } else if (name == "dump_configuration") {
             /**
              * Whether to dump every new configuration on TRACE level
              */
-            parse_option(connstr.options.dump_configuration, name, value);
+            parse_option(connstr.options.dump_configuration, name, value, connstr.warnings);
         } else {
-            CB_LOG_WARNING(R"(unknown parameter "{}" in connection string (value "{}"))", name, value);
+            connstr.warnings.push_back(fmt::format(R"(unknown parameter "{}" in connection string (value "{}"))", name, value));
         }
     }
 }

package/deps/couchbase-cxx-client/core/utils/connection_string.hxx

@@ -68,6 +68,7 @@ struct connection_string {
     bootstrap_mode default_mode{ connection_string::bootstrap_mode::gcccp };
     std::uint16_t default_port{ 11210 };
 
+    std::vector<std::string> warnings{};
     std::optional<std::string> error{};
 };
 

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

@@ -57,7 +57,7 @@ class analytics_error_context : public error_context
                             std::string http_body,
                             std::string hostname,
                             std::uint16_t port)
-      : error_context{ ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
+      : error_context{ {}, ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
       , first_error_code_{ first_error_code }
       , first_error_message_{ std::move(first_error_message) }
       , client_context_id_{ std::move(client_context_id) }

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

@@ -0,0 +1,77 @@
+/* -*- 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/search_query.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * Allow to match `true`/`false` in a field mapped as boolean.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class boolean_field_query : public search_query
+{
+  public:
+    /**
+     * Create a new boolean field query.
+     *
+     * @param value the input string to be matched against
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    explicit boolean_field_query(bool value)
+      : bool_{ value }
+    {
+    }
+
+    /**
+     * If a field is specified, only terms in that field will be matched.
+     *
+     * @param field_name name of the field to be matched
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto field(std::string field_name) -> boolean_field_query&
+    {
+        field_ = std::move(field_name);
+        return *this;
+    }
+
+    /**
+     * @return encoded representation of the query.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_query override;
+
+  private:
+    bool bool_;
+    std::optional<std::string> field_{};
+};
+} // namespace couchbase

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

@@ -0,0 +1,223 @@
+/* -*- 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/conjunction_query.hxx>
+#include <couchbase/disjunction_query.hxx>
+#include <couchbase/match_all_query.hxx>
+#include <couchbase/match_none_query.hxx>
+#include <couchbase/search_query.hxx>
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * The boolean query is a useful combination of conjunction and disjunction queries. A boolean query takes three lists of queries:
+ *
+ * * **must** - result documents must satisfy all of these queries.
+ * * **should** - result documents should satisfy these queries.
+ * * **must not** - result documents must not satisfy any of these queries.
+ *
+ * At execution, a boolean query that has no child queries in any 3 categories is not allowed and will fail fast.
+ *
+ * The inner representation of child queries in the `must`/`must_not`/`should` sections are respectively a @ref conjunction_query and two
+ * @ref disjunction_query.
+ *
+ * In the example below the following rules enforced by the boolean query:
+ * * retrieved documents MUST match `"hostel room"` in their `reviews.content` field AND have `true` in `free_breakfast` field.
+ * * also the documents SHOULD have EITHER `reviews.ratings.Overall > 4` OR `reviews.ratings.Service > 5`.
+ * * and finally, exclude documents with `city` `"Padfield"` or `"Gilingham"`.
+ *
+ * @snippet test_unit_search.cxx search-boolean
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-boolean-field-query.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class boolean_query : public search_query
+{
+  public:
+    /**
+     * Set @ref conjunction_query that groups all queries the documents **must** satisfy.
+     *
+     * @param query must-query
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto must(conjunction_query query) -> boolean_query&
+    {
+        must_ = std::move(query);
+        return *this;
+    }
+
+    /**
+     * Create @ref conjunction_query with given queries and set it as **must** query.
+     *
+     * @tparam SearchQuery any subclass of @ref search_query
+     * @param queries
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename... SearchQuery>
+    auto must(SearchQuery... queries) -> boolean_query&
+    {
+        must_ = conjunction_query(queries...);
+        return *this;
+    }
+
+    /**
+     * Returns @ref conjunction_query that groups all queries the documents **must** satisfy. Use it to add more queries.
+     *
+     * @return must-query
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto must() -> conjunction_query&
+    {
+        if (!must_) {
+            must_ = conjunction_query();
+        }
+        return must_.value();
+    }
+
+    /**
+     * Set @ref disjunction_query that groups  queries the documents **should** satisfy.
+     *
+     * @param query should-query
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto should(disjunction_query query) -> boolean_query&
+    {
+        should_ = std::move(query);
+        return *this;
+    }
+
+    /**
+     * Create @ref disjunction_query with given queries and set it as **should** query.
+     *
+     * @tparam SearchQuery any subclass of @ref search_query
+     * @param queries
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename... SearchQuery>
+    auto should(SearchQuery... queries) -> boolean_query&
+    {
+        should_ = disjunction_query(queries...);
+        return *this;
+    }
+
+    /**
+     * Returns @ref disjunction_query that groups  queries the documents **should** satisfy. Use it to add more queries or change
+     * @ref disjunction_query#min.
+     *
+     * @return should-query
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto should() -> disjunction_query&
+    {
+        if (!should_) {
+            should_ = disjunction_query();
+        }
+        return should_.value();
+    }
+
+    /**
+     * Set @ref disjunction_query that groups queries the documents **must not** satisfy.
+     *
+     * @param query must_not-query
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto must_not(disjunction_query query) -> boolean_query&
+    {
+        must_not_ = std::move(query);
+        return *this;
+    }
+
+    /**
+     * Create @ref disjunction_query with given queries and set it as **must not** query.
+     *
+     * @tparam SearchQuery any subclass of @ref search_query
+     * @param queries
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename... SearchQuery>
+    auto must_not(SearchQuery... queries) -> boolean_query&
+    {
+        must_not_ = disjunction_query(queries...);
+        return *this;
+    }
+
+    /**
+     * Returns @ref disjunction_query that groups  queries the documents **should** satisfy. Use it to add more queries.
+     *
+     * @return must_not-query
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto must_not() -> disjunction_query&
+    {
+        if (!must_not_) {
+            must_not_ = disjunction_query();
+        }
+        return must_not_.value();
+    }
+
+    /**
+     * @return encoded representation of the query.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_query override;
+
+  private:
+    std::optional<conjunction_query> must_{};
+    std::optional<disjunction_query> should_{};
+    std::optional<disjunction_query> must_not_{};
+};
+} // namespace couchbase

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

@@ -22,6 +22,8 @@
 #include <couchbase/cluster_options.hxx>
 #include <couchbase/query_index_manager.hxx>
 #include <couchbase/query_options.hxx>
+#include <couchbase/search_options.hxx>
+#include <couchbase/search_query.hxx>
 #include <couchbase/transactions.hxx>
 
 #include <memory>
@@ -166,6 +168,43 @@ class cluster
         return future;
     }
 
+    /**
+     * Performs a query against the full text search services.
+     *
+     * @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.
+     * @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
+     * @committed
+     */
+    void search_query(std::string index_name, const search_query& query, const search_options& options, search_handler&& handler) const;
+
+    /**
+     * Performs a query against the full text search services.
+     *
+     * @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.
+     * @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
+     * @committed
+     */
+    [[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 query against the analytics services.
      *