couchbase 3.4.2 → 3.4.4

data/ext/couchbase/couchbase/manager_error_context.hxx

@@ -17,14 +17,20 @@
 
 #pragma once
 
+#include "core/impl/internal_manager_error_context.hxx"
 #include <couchbase/error_context.hxx>
 
 #include <cstdint>
+#include <memory>
 #include <optional>
 #include <string>
 
 namespace couchbase
 {
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+class internal_manager_error_context;
+#endif
+
 /**
  * The error context returned with manager operations.
  *
@@ -40,40 +46,25 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @committed
      */
-    manager_error_context() = default;
+    manager_error_context();
+    explicit manager_error_context(internal_manager_error_context ctx);
+    manager_error_context(manager_error_context&& other);
+    manager_error_context& operator=(manager_error_context&& other);
+    manager_error_context(const manager_error_context& other) = delete;
+    manager_error_context& operator=(const manager_error_context& other) = delete;
+    ~manager_error_context() override;
 
-    /**
-     * Creates and initializes error context with given parameters.
-     *
-     * @param ec
-     * @param last_dispatched_to
-     * @param last_dispatched_from
-     * @param retry_attempts
-     * @param retry_reasons
-     * @param client_context_id
-     * @param http_status
-     * @param content
-     * @param path
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    manager_error_context(std::error_code ec,
-                          std::optional<std::string> last_dispatched_to,
-                          std::optional<std::string> last_dispatched_from,
-                          std::size_t retry_attempts,
-                          std::set<retry_reason> retry_reasons,
-                          std::string client_context_id,
-                          std::uint32_t http_status,
-                          std::string content,
-                          std::string path)
-      : error_context{ ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
-      , client_context_id_{ std::move(client_context_id) }
-      , http_status_{ http_status }
-      , content_{ std::move(content) }
-      , path_{ std::move(path) }
-    {
-    }
+    [[nodiscard]] auto ec() const -> std::error_code override;
+
+    [[nodiscard]] auto last_dispatched_to() const -> const std::optional<std::string>& override;
+
+    [[nodiscard]] auto last_dispatched_from() const -> const std::optional<std::string>& override;
+
+    [[nodiscard]] auto retry_attempts() const -> std::size_t override;
+
+    [[nodiscard]] auto retry_reasons() const -> const std::set<retry_reason>& override;
+
+    [[nodiscard]] auto retried_because_of(retry_reason reason) const -> bool override;
 
     /**
      * Returns request path.
@@ -83,10 +74,7 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @uncommitted
      */
-    [[nodiscard]] auto path() const -> const std::string&
-    {
-        return path_;
-    }
+    [[nodiscard]] auto path() const -> const std::string&;
 
     /**
      * Returns response body.
@@ -96,10 +84,7 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto content() const -> const std::string&
-    {
-        return content_;
-    }
+    [[nodiscard]] auto content() const -> const std::string&;
 
     /**
      * Returns the unique
@@ -109,10 +94,7 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @uncommitted
      */
-    [[nodiscard]] auto client_context_id() const -> const std::string&
-    {
-        return client_context_id_;
-    }
+    [[nodiscard]] auto client_context_id() const -> const std::string&;
 
     /**
      * Returns HTTP status of response
@@ -122,15 +104,9 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto http_status() const -> std::uint32_t
-    {
-        return http_status_;
-    }
+    [[nodiscard]] auto http_status() const -> std::uint32_t;
 
   private:
-    std::string client_context_id_{};
-    std::uint32_t http_status_{};
-    std::string content_{};
-    std::string path_{};
+    std::unique_ptr<internal_manager_error_context> internal_;
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/match_all_query.hxx

@@ -0,0 +1,43 @@
+/* -*- 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>
+
+namespace couchbase
+{
+/**
+ * A query that matches all indexed documents.
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match-all.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class match_all_query : public search_query
+{
+  public:
+    /**
+     * @return encoded representation of the query.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_query override;
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/match_none_query.hxx

@@ -0,0 +1,43 @@
+/* -*- 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>
+
+namespace couchbase
+{
+/**
+ * A query that matches nothing.
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match-none.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class match_none_query : public search_query
+{
+  public:
+    /**
+     * @return encoded representation of the query.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_query override;
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/match_operator.hxx

@@ -0,0 +1,45 @@
+/* -*- 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
+
+namespace couchbase
+{
+/**
+ * Defines how the individual match terms should be logically concatenated
+ *
+ * @since 1.0.0
+ * @committed
+ */
+enum class match_operator {
+    /**
+     * Individual match terms are concatenated with a logical OR - this is the default if not provided.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    logical_or,
+
+    /**
+     * Individual match terms are concatenated with a logical AND.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    logical_and,
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/match_phrase_query.hxx

@@ -0,0 +1,108 @@
+/* -*- 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
+{
+/**
+ * The input text is analyzed and a phrase query is built with the terms resulting from the analysis. This type of query searches for terms
+ * occurring in the specified positions and offsets. This depends on term vectors, which are consulted to determine phrase distance.
+ *
+ * For example, a match phrase query for `"location for functions"` is matched with `"locate the function"`, if the standard analyzer is
+ * used: this analyzer uses a **stemmer**, which tokenizes `"location"` and `"locate"` to `"locat"`, and reduces `"functions"` and
+ * `"function"` to `"function"`. Additionally, the analyzer employs stop removal, which removes small and less significant words from input
+ * and target text, so that matches are attempted on only the more significant elements of vocabulary: in this case `"for"` and `"the"` are
+ * removed. Following this processing, the tokens `"locat"` and `"function"` are recognized as common to both input and target; and also as
+ * being both in the same sequence as, and at the same distance from one another; and therefore a match is made.
+ * @snippet test_unit_search.cxx search-match-phrase
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match-phrase.html
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class match_phrase_query : public search_query
+{
+  public:
+    /**
+     * Create a new match phrase query.
+     *
+     * @param match_phrase the input string to be matched against
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    explicit match_phrase_query(std::string match_phrase)
+      : match_phrase_{ std::move(match_phrase) }
+    {
+    }
+
+    /**
+     * Analyzers are used to transform input text into a stream of tokens for indexing. The Server comes with built-in analyzers and the
+     * users can create their own.
+     *
+     * @param analyzer_name the name of the analyzer used
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto analyzer(std::string analyzer_name) -> match_phrase_query&
+    {
+        analyzer_ = std::move(analyzer_name);
+        return *this;
+    }
+
+    /**
+     * If a field is specified, only terms in that field will be matched.
+     *
+     * This can also affect the used analyzer if one isn't specified explicitly.
+     *
+     * @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) -> match_phrase_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 match_phrase_;
+    std::optional<std::string> analyzer_{};
+    std::optional<std::string> field_{};
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/match_query.hxx

@@ -0,0 +1,163 @@
+/* -*- 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 match query analyzes the input text and uses that analyzed text to query the index. An attempt is made to use the same analyzer that
+ * was used when the field was indexed.
+ *
+ * Match documents with both `"location"` and `"hostel"` terms in the field `reviews.content`, ensuring common prefix length `4`, maximum
+ * fuzziness and select standard analyzer.
+ * @snippet test_unit_search.cxx search-match
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class match_query : public search_query
+{
+  public:
+    /**
+     * Create a new match query.
+     *
+     * @param match the input string to be matched against
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    explicit match_query(std::string match)
+      : match_{ std::move(match) }
+    {
+    }
+
+    /**
+     * Require that the term also have the same prefix of the specified length (must be positive).
+     *
+     * @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) -> match_query&
+    {
+        if (length <= 0) {
+            throw std::invalid_argument("prefix_length must be positive");
+        }
+
+        prefix_length_ = length;
+        return *this;
+    }
+
+    /**
+     * Analyzers are used to transform input text into a stream of tokens for indexing. The Server comes with built-in analyzers and the
+     * users can create their own.
+     *
+     * @param analyzer_name the name of the analyzer used
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto analyzer(std::string analyzer_name) -> match_query&
+    {
+        analyzer_ = std::move(analyzer_name);
+        return *this;
+    }
+
+    /**
+     * If a field is specified, only terms in that field will be matched.
+     *
+     * This can also affect the used analyzer if one isn't specified explicitly.
+     *
+     * @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) -> match_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) -> match_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) -> match_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 match_;
+    std::optional<std::uint32_t> prefix_length_{};
+    std::optional<std::string> analyzer_{};
+    std::optional<std::string> field_{};
+    std::optional<std::uint32_t> fuzziness_{};
+    std::optional<couchbase::match_operator> operator_{};
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/mutate_in_options.hxx

@@ -225,8 +225,8 @@ initiate_mutate_in_operation(std::shared_ptr<couchbase::core::cluster> core,
                              std::string collection_name,
                              std::string document_key,
                              const std::vector<couchbase::core::impl::subdoc::command>& specs,
-                             mutate_in_options::built options,
-                             mutate_in_handler&& handler);
+                             couchbase::mutate_in_options::built options,
+                             couchbase::mutate_in_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/numeric_range.hxx

@@ -0,0 +1,58 @@
+/* -*- 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 <cstdint>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * Numeric range for @ref numeric_range_facet.
+ */
+class numeric_range
+{
+  public:
+    numeric_range(std::string name, double min, double max);
+    static numeric_range with_min(std::string name, double start);
+    static numeric_range with_max(std::string name, double end);
+
+    [[nodiscard]] auto name() const -> const std::string&
+    {
+        return name_;
+    }
+
+    [[nodiscard]] auto min() const -> const std::optional<double>&
+    {
+        return min_;
+    }
+
+    [[nodiscard]] auto max() const -> const std::optional<double>&
+    {
+        return max_;
+    }
+
+  private:
+    numeric_range(std::string name, std::optional<double> min, std::optional<double> max);
+
+    std::string name_;
+    std::optional<double> min_{};
+    std::optional<double> max_{};
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/numeric_range_facet.hxx

@@ -0,0 +1,56 @@
+/* -*- 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/numeric_range.hxx>
+#include <couchbase/search_facet.hxx>
+
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * A facet that categorizes rows into numerical ranges (or buckets) provided by the user.
+ */
+class numeric_range_facet : public search_facet
+{
+  public:
+    numeric_range_facet(std::string field, std::vector<numeric_range> ranges)
+      : search_facet{ std::move(field) }
+      , ranges_{ std::move(ranges) }
+    {
+    }
+
+    numeric_range_facet(std::string field, std::uint32_t size, std::vector<numeric_range> ranges)
+      : search_facet{ std::move(field), size }
+      , ranges_{ std::move(ranges) }
+    {
+    }
+
+    /**
+     * @return encoded representation of the search facet.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_facet override;
+
+  private:
+    std::vector<numeric_range> ranges_;
+};
+} // namespace couchbase