couchbase 4.2.3 → 4.2.4

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

@@ -0,0 +1,51 @@
+/* -*- 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 <cinttypes>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * @since 1.0.0
+ * @committed
+ */
+class search_term_range
+{
+  public:
+    search_term_range(std::string name, std::uint64_t count)
+      : name_{ std::move(name) }
+      , count_{ count }
+    {
+    }
+
+    [[nodiscard]] auto name() const -> const std::string&
+    {
+        return name_;
+    }
+    [[nodiscard]] auto count() const -> std::uint64_t
+    {
+        return count_;
+    }
+
+  private:
+    std::string name_;
+    std::uint64_t count_;
+};
+} // namespace couchbase

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

@@ -49,6 +49,7 @@ class security_options
         bool enabled;
         tls_verify_mode tls_verify;
         std::optional<std::string> trust_certificate;
+        bool disable_mozilla_ca_certificates;
     };
 
     [[nodiscard]] auto build() const -> built
@@ -57,6 +58,7 @@ class security_options
             enabled_,
             tls_verify_,
             trust_certificate_,
+            disable_mozilla_ca_certificates_,
         };
     }
 
@@ -64,5 +66,6 @@ class security_options
     bool enabled_{ true };
     tls_verify_mode tls_verify_{ tls_verify_mode::peer };
     std::optional<std::string> trust_certificate_{};
+    bool disable_mozilla_ca_certificates_{ false };
 };
 } // namespace couchbase

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

@@ -62,7 +62,8 @@ class subdocument_error_context : public key_value_error_context
      * @since 1.0.0
      * @internal
      */
-    subdocument_error_context(std::error_code ec,
+    subdocument_error_context(std::string operation_id,
+                              std::error_code ec,
                               std::optional<std::string> last_dispatched_to,
                               std::optional<std::string> last_dispatched_from,
                               std::size_t retry_attempts,
@@ -79,7 +80,8 @@ class subdocument_error_context : public key_value_error_context
                               std::optional<std::string> first_error_path,
                               std::optional<std::uint64_t> first_error_index,
                               bool deleted)
-      : key_value_error_context{ ec,
+      : key_value_error_context{ std::move(operation_id),
+                                 ec,
                                  std::move(last_dispatched_to),
                                  std::move(last_dispatched_from),
                                  retry_attempts,

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

@@ -0,0 +1,48 @@
+/* -*- 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_facet.hxx>
+
+namespace couchbase
+{
+/**
+ * A facet that gives the number of occurrences of the most recurring terms in all rows.
+ */
+class term_facet : public search_facet
+{
+  public:
+    explicit term_facet(std::string field)
+      : search_facet{ std::move(field) }
+    {
+    }
+
+    term_facet(std::string field, std::uint32_t size)
+      : search_facet{ std::move(field), size }
+    {
+    }
+
+    /**
+     * @return encoded representation of the search facet.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_facet override;
+};
+} // namespace couchbase

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

@@ -0,0 +1,55 @@
+/* -*- 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/search_facet_result.hxx>
+#include <couchbase/search_term_range.hxx>
+
+#include <string>
+#include <vector>
+
+namespace couchbase
+{
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+class internal_term_facet_result;
+#endif
+
+/**
+ * @since 1.0.0
+ * @committed
+ */
+class term_facet_result : public search_facet_result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    explicit term_facet_result(internal_term_facet_result internal);
+
+    [[nodiscard]] auto name() const -> const std::string& override;
+    [[nodiscard]] auto field() const -> const std::string& override;
+    [[nodiscard]] auto total() const -> std::uint64_t override;
+    [[nodiscard]] auto missing() const -> std::uint64_t override;
+    [[nodiscard]] auto other() const -> std::uint64_t override;
+    [[nodiscard]] auto terms() const -> const std::vector<search_term_range>&;
+
+  private:
+    std::unique_ptr<internal_term_facet_result> internal_;
+};
+} // namespace couchbase

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

@@ -0,0 +1,151 @@
+/* -*- 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/match_operator.hxx>
+#include <couchbase/search_query.hxx>
+
+#include <cstdint>
+#include <optional>
+#include <stdexcept>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * A query that looks for **exact** matches of the term in the index (no analyzer, no stemming). Useful to check what the actual content of
+ * the index is. It can also apply fuzziness on the term. Usual better alternative is @ref match_query.
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-term.html server documentation
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-fuzzy.html fuzzy search
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class term_query : public search_query
+{
+  public:
+    /**
+     * Create a new term query.
+     *
+     * The mandatory term is the exact string that will be searched into the index. Note that the index can (and usually will) contain terms
+     * that are derived from the text in documents, as analyzers can apply process like stemming. For example, indexing "programming" could
+     * store "program" in the index. As a term query doesn't apply the analyzers, one would need to look for "program" to have a match on
+     * that index entry.
+     *
+     * @param term the input string to be matched against
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    explicit term_query(std::string term)
+      : term_{ std::move(term) }
+    {
+    }
+
+    /**
+     * Require that the term also have the same prefix of the specified length (must be positive).
+     *
+     * The prefix length only makes sense when fuzziness is enabled. It allows to apply the fuzziness only on the part of the term that is
+     * after the `length` character mark.
+     *
+     * For example, with the term "something" and a prefix length of 4, only the "thing" part of the term will be fuzzy-searched, and hits
+     * must start with "some".
+     *
+     * @param length the length of the term prefix
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto prefix_length(std::uint32_t length) -> term_query&
+    {
+        if (length <= 0) {
+            throw std::invalid_argument("prefix_length must be positive");
+        }
+
+        prefix_length_ = length;
+        return *this;
+    }
+
+    /**
+     * 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) -> term_query&
+    {
+        field_ = std::move(field_name);
+        return *this;
+    }
+
+    /**
+     * Perform fuzzy matching. If the fuzziness parameter is set to a non-zero integer the analyzed text will be matched with the specified
+     * level of fuzziness.
+     *
+     * @param fuzziness level of fuzziness (the maximum supported fuzziness is 2).
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto fuzziness(std::uint32_t fuzziness) -> term_query&
+    {
+        fuzziness_ = fuzziness;
+        return *this;
+    }
+
+    /**
+     * Defines how the individual match terms should be logically concatenated
+     *
+     * @param concatenation_operator operator to be used
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto match_operator(couchbase::match_operator concatenation_operator) -> term_query&
+    {
+        operator_ = concatenation_operator;
+        return *this;
+    }
+
+    /**
+     * @return encoded representation of the query.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_query override;
+
+  private:
+    std::string term_;
+    std::optional<std::uint32_t> prefix_length_{};
+    std::optional<std::string> field_{};
+    std::optional<std::uint32_t> fuzziness_{};
+    std::optional<couchbase::match_operator> operator_{};
+};
+} // namespace couchbase

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

@@ -0,0 +1,142 @@
+/* -*- 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/match_operator.hxx>
+#include <couchbase/search_query.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * The term range query finds documents containing a string value in the specified field within the specified range. Either min or max can
+ * be omitted, but not both.
+ *
+ * Match documents where field `desc` contains terms in the range `("foo", "foof")`:
+ * @snippet test_unit_search.cxx search-term-range
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-term-range.html server documentation.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class term_range_query : public search_query
+{
+  public:
+    /**
+     * Set lower limit of the range. Whether to include limit into the range will be decided by server defaults.
+     *
+     * @param value  lower limit of the range.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto min(std::string value) -> term_range_query&
+    {
+        min_ = std::move(value);
+        return *this;
+    }
+
+    /**
+     * Set lower limit and specify whether to include it into the limit.
+     *
+     * @param value  lower limit of the range.
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto min(std::string value, bool inclusive) -> term_range_query&
+    {
+        min_ = std::move(value);
+        inclusive_min_ = inclusive;
+        return *this;
+    }
+
+    /**
+     * Set upper limit of the range. Whether to include limit into the range will be decided by server defaults.
+     *
+     * @param value  upper limit of the range
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto max(std::string value) -> term_range_query&
+    {
+        max_ = std::move(value);
+        return *this;
+    }
+
+    /**
+     * Set upper limit and specify whether to include it into the limit.
+     *
+     * @param value  upper limit of the range.
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto max(std::string value, bool inclusive) -> term_range_query&
+    {
+        max_ = std::move(value);
+        inclusive_max_ = inclusive;
+        return *this;
+    }
+
+    /**
+     * 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) -> term_range_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:
+    std::optional<std::string> min_{};
+    std::optional<std::string> max_{};
+    std::optional<bool> inclusive_min_{};
+    std::optional<bool> inclusive_max_{};
+    std::optional<std::string> field_{};
+};
+} // namespace couchbase

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

@@ -25,7 +25,7 @@
 namespace couchbase::transactions
 {
 /**
- * The transaction_options can be passed in to override some elements of the global @ref transaction_config.
+ * The transaction_options can be passed in to override some elements of the global @ref transactions_config.
  */
 class transaction_options
 {

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

@@ -29,7 +29,8 @@ class transaction_context;
 /**
  * The transaction_query_options are options specific to a query.
  *
- * Some of the options will override the corresponding elements in the @ref transaction_query_config section of the @ref transaction_config.
+ * Some of the options will override the corresponding elements in the @ref transactions_query_config section of the
+ * @ref transactions_config.
  */
 class transaction_query_options
 {

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

@@ -25,7 +25,7 @@ namespace couchbase::transactions
  * @volatile
  *
  * Contains internal information on a transaction,
- * returned by @ref core::transactions::run()
+ * returned by @ref couchbase::transactions::transactions::run()
  */
 struct transaction_result {
     std::string transaction_id;

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

@@ -46,7 +46,7 @@ class transactions
      * You can supply a lambda or function which uses a yielded {@link attempt_context} to perform a transaction, where each transaction
      * operation is blocking.  A simple usage would be to get a document and replace the contents:
      *
-     * @snippet test/test_transaction_examples.cxx simple-blocking-txn
+     * @snippet{trimleft} test/test_transaction_examples.cxx simple-blocking-txn
      *
      * @param logic a lambda or function which uses the yielded {@link attempt_context} to perform the desired transactional operations.
      * @param cfg if passed in, these options override the defaults, or those set in the {@link cluster_options}.
@@ -62,7 +62,7 @@ class transactions
      * below, we get the 3 documents in parallel, and update each when the get returns the document.   This can be significantly faster than
      * getting each document in serial, and updating it using the blocking api:
      *
-     * @snippet test/test_transaction_examples.cxx simple-async-txn
+     * @snippet{trimleft} test/test_transaction_examples.cxx simple-async-txn
      *
      * @param logic a lambda or function which uses the yielded {@link async_attempt_context} to perform the desired transactional
      * operations.
@@ -73,4 +73,4 @@ class transactions
                      async_txn_complete_logic&& complete_callback,
                      const transaction_options& cfg = transaction_options()) = 0;
 };
-} // namespace couchbase::transactions
+} // namespace couchbase::transactions

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

@@ -0,0 +1,83 @@
+/* -*- 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
+{
+/**
+ * A wildcard query is a query in which term the character `*` will match `0..n` occurrences of any characters and `?` will match `1`
+ * occurrence of any character.
+ *
+ * Match documents where field `reviews.content` contains words starting with `"inter"`:
+ * @snippet test_unit_search.cxx search-wildcard
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-wildcard.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class wildcard_query : public search_query
+{
+  public:
+    /**
+     * Create a new wildcard query.
+     *
+     * @param regexp the wildcard-containing term to be analyzed and searched
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    explicit wildcard_query(std::string regexp)
+      : wildcard_{ std::move(regexp) }
+    {
+    }
+
+    /**
+     * 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) -> wildcard_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:
+    std::string wildcard_;
+    std::optional<std::string> field_{};
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/docs/Doxyfile.in

@@ -1078,7 +1078,7 @@ EXCLUDE_SYMBOLS        =
 # that contain example code fragments that are included (see the \include
 # command).
 
-EXAMPLE_PATH           = ${PROJECT_SOURCE_DIR}/test/
+EXAMPLE_PATH           = ${PROJECT_SOURCE_DIR}/examples/ ${PROJECT_SOURCE_DIR}/test/
 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and

package/deps/couchbase-cxx-client/docs/cbc-analytics.md

@@ -1,4 +1,4 @@
-# cbc-analytics - run Analytics query {#cbc-analytics}
+# cbc-analytics - Run Analytics Query {#cbc-analytics}
 
 ### NAME
 
@@ -168,4 +168,4 @@ Execute one or more Analytics queries and print results to standard output.
 
 ### SEE ALSO
 
-[cbc](#cbc), [cbc-get](#cbc-get).
+[cbc](md_docs_2cbc), [cbc-get](md_docs_2cbc-get).

package/deps/couchbase-cxx-client/docs/cbc-get.md

@@ -1,4 +1,4 @@
-# cbc-get - get document {#cbc-get}
+# cbc-get - Retrieve Documents from the Server {#cbc-get}
 
 ### NAME
 
@@ -18,6 +18,7 @@ Retrieve one or more documents from the server and print them to standard output
 
 <dl>
 <dt>`-h|--help`</dt><dd>Show help message.</dd>
+<dt>`--verbose`</dt><dd>Include more context and information where it is applicable.</dd>
 <dt>`--bucket-name=STRING`</dt><dd>Name of the bucket. [default: `default`]</dd>
 <dt>`--scope-name=STRING`</dt><dd>Name of the scope. [default: `_default`]</dd>
 <dt>`--collection-name=STRING`</dt><dd>Name of the collection. [default: `_default`]</dd>
@@ -157,4 +158,4 @@ Retrieve one or more documents from the server and print them to standard output
 
 ### SEE ALSO
 
-[cbc](#cbc), [cbc-query](#cbc-query).
+[cbc](md_docs_2cbc), [cbc-query](md_docs_2cbc-query).