couchbase 3.4.2 → 3.4.4

data/ext/couchbase/couchbase/search_sort_score.hxx

@@ -0,0 +1,60 @@
+/* -*- 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_sort.hxx>
+
+namespace couchbase
+{
+/**
+ * Sorts by the hit score.
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-search-request.html#sorting-with-objects
+ *
+ * @since 1.0.0
+ */
+class search_sort_score : public search_sort
+{
+  public:
+    search_sort_score() = default;
+
+    explicit search_sort_score(bool descending)
+      : search_sort{ descending }
+    {
+    }
+
+    /**
+     * 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_score&;
+
+    /**
+     * @return encoded representation of the search facet.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_sort override;
+};
+} // namespace couchbase

data/ext/couchbase/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

data/ext/couchbase/couchbase/security_options.hxx

@@ -45,10 +45,20 @@ class security_options
         return *this;
     }
 
+    auto trust_certificate_value(std::string certificate_value) -> security_options&
+    {
+        trust_certificate_value_ = certificate_value;
+        return *this;
+    }
+
     struct built {
         bool enabled;
         tls_verify_mode tls_verify;
         std::optional<std::string> trust_certificate;
+        std::optional<std::string> trust_certificate_value;
+        bool disable_mozilla_ca_certificates;
+        bool disable_deprecated_protocols;
+        bool disable_tls_v1_2;
     };
 
     [[nodiscard]] auto build() const -> built
@@ -57,6 +67,10 @@ class security_options
             enabled_,
             tls_verify_,
             trust_certificate_,
+            trust_certificate_value_,
+            disable_mozilla_ca_certificates_,
+            disable_deprecated_protocols,
+            disable_tls_v1_2,
         };
     }
 
@@ -64,5 +78,9 @@ class security_options
     bool enabled_{ true };
     tls_verify_mode tls_verify_{ tls_verify_mode::peer };
     std::optional<std::string> trust_certificate_{};
+    std::optional<std::string> trust_certificate_value_{};
+    bool disable_mozilla_ca_certificates_{ false };
+    bool disable_deprecated_protocols{ true };
+    bool disable_tls_v1_2{ false };
 };
 } // namespace couchbase

data/ext/couchbase/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,

data/ext/couchbase/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

data/ext/couchbase/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

data/ext/couchbase/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

data/ext/couchbase/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

data/ext/couchbase/couchbase/touch_options.hxx

@@ -86,8 +86,8 @@ initiate_touch_operation(std::shared_ptr<couchbase::core::cluster> core,
                          std::string collection_name,
                          std::string document_key,
                          std::uint32_t expiry,
-                         touch_options::built options,
-                         touch_handler&& handler);
+                         couchbase::touch_options::built options,
+                         couchbase::touch_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/tracing/request_span.hxx

@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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
+
+#include <cinttypes>
+#include <memory>
+#include <string>
+
+namespace couchbase::tracing
+{
+class request_span
+{
+  public:
+    request_span() = default;
+    request_span(const request_span& other) = default;
+    request_span(request_span&& other) = default;
+    request_span& operator=(const request_span& other) = default;
+    request_span& operator=(request_span&& other) = default;
+    virtual ~request_span() = default;
+
+    explicit request_span(std::string name)
+      : name_(std::move(name))
+    {
+    }
+    request_span(std::string name, std::shared_ptr<request_span> parent)
+      : name_(std::move(name))
+      , parent_(std::move(parent))
+    {
+    }
+    virtual void add_tag(const std::string& name, std::uint64_t value) = 0;
+    virtual void add_tag(const std::string& name, const std::string& value) = 0;
+    virtual void end() = 0;
+
+    [[nodiscard]] const std::string& name() const
+    {
+        return name_;
+    }
+
+    [[nodiscard]] std::shared_ptr<request_span> parent() const
+    {
+        return parent_;
+    }
+
+  private:
+    std::string name_{};
+    std::shared_ptr<request_span> parent_{ nullptr };
+};
+} // namespace couchbase::tracing

data/ext/couchbase/couchbase/tracing/request_tracer.hxx

@@ -17,51 +17,13 @@
 
 #pragma once
 
+#include "request_span.hxx"
+
 #include <memory>
 #include <string>
 
 namespace couchbase::tracing
 {
-
-class request_span
-{
-  public:
-    request_span() = default;
-    request_span(const request_span& other) = default;
-    request_span(request_span&& other) = default;
-    request_span& operator=(const request_span& other) = default;
-    request_span& operator=(request_span&& other) = default;
-    virtual ~request_span() = default;
-
-    explicit request_span(std::string name)
-      : name_(std::move(name))
-      , parent_(nullptr)
-    {
-    }
-    request_span(std::string name, std::shared_ptr<request_span> parent)
-      : name_(std::move(name))
-      , parent_(std::move(parent))
-    {
-    }
-    virtual void add_tag(const std::string& name, std::uint64_t value) = 0;
-    virtual void add_tag(const std::string& name, const std::string& value) = 0;
-    virtual void end() = 0;
-
-    [[nodiscard]] const std::string& name() const
-    {
-        return name_;
-    }
-
-    [[nodiscard]] std::shared_ptr<request_span> parent() const
-    {
-        return parent_;
-    }
-
-  private:
-    std::string name_{};
-    std::shared_ptr<request_span> parent_{ nullptr };
-};
-
 class request_tracer
 {
   public: