couchbase 4.2.0 → 4.2.1

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

@@ -22,11 +22,23 @@
 namespace couchbase
 {
 class cluster_options;
-
+/**
+ * Base class for all defined configuration profiles
+ *
+ * Just implement the apply function, and register it.  See @ref configuration_profiles_registry#register()
+ */
 class configuration_profile
 {
   public:
     virtual ~configuration_profile() = default;
+
+    /**
+     * Implement this in derived class, modifying the @ref cluster_options passed in.
+     *
+     * @param options The options class which will be modified.
+     * @since 1.0.0
+     * @volatile
+     */
     virtual void apply(cluster_options& options) = 0;
 };
 } // namespace couchbase

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

@@ -26,10 +26,33 @@ namespace couchbase
 {
 class cluster_options;
 
+/**
+ *  Registry for defining configuration profiles.
+ */
+
 class configuration_profiles_registry
 {
   public:
+    /**
+     * Register a @ref configuration_profile, and associate it with a name.
+     *
+     * @param name  The name to use to refer to the profile.
+     * @param profile Instance of class derived from @ref configuration_profile, which is being registered.
+     *
+     * @since 1.0.0
+     * @volatile
+     */
     static void register_profile(const std::string& name, std::shared_ptr<configuration_profile> profile);
+
+    /**
+     * Apply a profile to an instance of @ref cluster_options.
+     *
+     * @param name
+     * @param options
+     *
+     * @since 1.0.0
+     * @internal
+     */
     static void apply_profile(const std::string& name, couchbase::cluster_options& options);
 };
 } // namespace couchbase

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

@@ -60,7 +60,8 @@ struct decrement_options : public common_durability_options<decrement_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        return { build_common_durability_options(), expiry_, delta_, initial_value_ };
+        auto base = build_common_durability_options();
+        return { base, expiry_, delta_, initial_value_ };
     }
 
     /**

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

@@ -598,6 +598,10 @@ enum class key_value {
      */
     // KV Code: 0xd6
     cannot_revive_living_document = 131,
+
+    range_scan_cancelled = 132,
+    range_scan_vb_uuid_not_equal = 133,
+    range_scan_completed = 134,
 };
 
 /**
@@ -965,6 +969,48 @@ enum class network {
      * @uncommitted
      */
     cluster_closed = 1006,
+
+    /**
+     * @since 1.0.0
+     * @uncommitted
+     */
+    end_of_stream = 1007,
+
+    /**
+     * @since 1.0.0
+     * @uncommitted
+     */
+    need_more_data = 1008,
+
+    /**
+     * @since 1.0.0
+     * @uncommitted
+     */
+    operation_queue_closed = 1009,
+
+    /**
+     * @since 1.0.0
+     * @uncommitted
+     */
+    operation_queue_full = 1010,
+
+    /**
+     * @since 1.0.0
+     * @uncommitted
+     */
+    request_already_queued = 1011,
+
+    /**
+     * @since 1.0.0
+     * @uncommitted
+     */
+    request_cancelled = 1012,
+
+    /**
+     * @since 1.0.0
+     * @uncommitted
+     */
+    bucket_closed = 1013,
 };
 
 /**

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

@@ -59,7 +59,7 @@ class error_context
     error_context(std::error_code ec,
                   std::optional<std::string> last_dispatched_to,
                   std::optional<std::string> last_dispatched_from,
-                  int retry_attempts,
+                  std::size_t retry_attempts,
                   std::set<retry_reason> retry_reasons)
       : ec_{ ec }
       , last_dispatched_to_{ std::move(last_dispatched_to) }
@@ -131,7 +131,7 @@ class error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto retry_attempts() const -> int
+    [[nodiscard]] auto retry_attempts() const -> std::size_t
     {
         return retry_attempts_;
     }
@@ -167,7 +167,7 @@ class error_context
     std::error_code ec_{};
     std::optional<std::string> last_dispatched_to_{};
     std::optional<std::string> last_dispatched_from_{};
-    int retry_attempts_{ 0 };
+    std::size_t retry_attempts_{ 0 };
     std::set<retry_reason> retry_reasons_{};
 };
 } // namespace couchbase

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

@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2022-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/retry_strategy.hxx>
+
+#include <memory>
+
+namespace couchbase
+{
+class fail_fast_retry_strategy : public retry_strategy
+{
+  public:
+    auto retry_after(const retry_request& request, retry_reason reason) -> retry_action override;
+    [[nodiscard]] virtual auto to_string() const -> std::string override;
+
+    ~fail_fast_retry_strategy() override = default;
+};
+
+[[nodiscard]] auto
+make_fail_fast_retry_strategy() -> std::shared_ptr<fail_fast_retry_strategy>;
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/fmt/key_value_status_code.hxx

@@ -236,6 +236,22 @@ struct fmt::formatter<couchbase::key_value_status_code> {
             case key_value_status_code::subdoc_deleted_document_cannot_have_value:
                 name = "subdoc_deleted_document_cannot_have_value (0xd7)";
                 break;
+            case key_value_status_code::range_scan_cancelled:
+                name = "range_scan_cancelled (0xa5)";
+                break;
+            case key_value_status_code::range_scan_more:
+                name = "range_scan_more (0xa6)";
+                break;
+            case key_value_status_code::range_scan_complete:
+                name = "range_scan_complete (0xa7)";
+                break;
+            case key_value_status_code::range_scan_vb_uuid_not_equal:
+                name = "range_scan_vb_uuid_not_equal (0xa8)";
+                break;
+
+            case key_value_status_code::unknown:
+                name = "unknown (0xffff)";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }

package/deps/couchbase-cxx-client/couchbase/fmt/retry_reason.hxx

@@ -49,25 +49,25 @@ struct fmt::formatter<couchbase::retry_reason> {
             case couchbase::retry_reason::node_not_available:
                 name = "node_not_available";
                 break;
-            case couchbase::retry_reason::kv_not_my_vbucket:
+            case couchbase::retry_reason::key_value_not_my_vbucket:
                 name = "kv_not_my_vbucket";
                 break;
-            case couchbase::retry_reason::kv_collection_outdated:
+            case couchbase::retry_reason::key_value_collection_outdated:
                 name = "kv_collection_outdated";
                 break;
-            case couchbase::retry_reason::kv_error_map_retry_indicated:
+            case couchbase::retry_reason::key_value_error_map_retry_indicated:
                 name = "kv_error_map_retry_indicated";
                 break;
-            case couchbase::retry_reason::kv_locked:
+            case couchbase::retry_reason::key_value_locked:
                 name = "kv_locked";
                 break;
-            case couchbase::retry_reason::kv_temporary_failure:
+            case couchbase::retry_reason::key_value_temporary_failure:
                 name = "kv_temporary_failure";
                 break;
-            case couchbase::retry_reason::kv_sync_write_in_progress:
+            case couchbase::retry_reason::key_value_sync_write_in_progress:
                 name = "kv_sync_write_in_progress";
                 break;
-            case couchbase::retry_reason::kv_sync_write_re_commit_in_progress:
+            case couchbase::retry_reason::key_value_sync_write_re_commit_in_progress:
                 name = "kv_sync_write_re_commit_in_progress";
                 break;
             case couchbase::retry_reason::service_response_code_indicated:

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

@@ -60,7 +60,8 @@ struct increment_options : public common_durability_options<increment_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        return { build_common_durability_options(), expiry_, delta_, initial_value_ };
+        auto base = build_common_durability_options();
+        return { base, expiry_, delta_, initial_value_ };
     }
 
     /**

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

@@ -61,7 +61,8 @@ struct insert_options : public common_durability_options<insert_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        return { build_common_durability_options(), expiry_ };
+        auto base = build_common_durability_options();
+        return { base, expiry_ };
     }
 
     /**

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

@@ -69,7 +69,7 @@ class key_value_error_context : public error_context
     key_value_error_context(std::error_code ec,
                             std::optional<std::string> last_dispatched_to,
                             std::optional<std::string> last_dispatched_from,
-                            int retry_attempts,
+                            std::size_t retry_attempts,
                             std::set<retry_reason> retry_reasons,
                             std::string id,
                             std::string bucket,
@@ -221,4 +221,4 @@ class key_value_error_context : public error_context
     std::optional<key_value_error_map_info> error_map_info_{};
     std::optional<key_value_extended_error_info> extended_error_info_{};
 };
-} // namespace couchbase
+} // namespace couchbase

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

@@ -89,5 +89,19 @@ enum class key_value_status_code : std::uint16_t {
     subdoc_xattr_unknown_vattr_macro = 0xd5,
     subdoc_can_only_revive_deleted_documents = 0xd6,
     subdoc_deleted_document_cannot_have_value = 0xd7,
+
+    // occurs during a range scan to indicate that the range scan was cancelled.
+    range_scan_cancelled = 0xa5,
+
+    // occurs during a range scan to indicate that a range scan has more results.
+    range_scan_more = 0xa6,
+
+    // occurs during a range scan to indicate that a range scan has completed.
+    range_scan_complete = 0xa7,
+
+    // occurs during a range scan to indicate that a vb-uuid mismatch has occurred.
+    range_scan_vb_uuid_not_equal = 0xa8,
+
+    unknown = 0xffff,
 };
-} // namespace couchbase
+} // namespace couchbase

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

@@ -65,7 +65,8 @@ struct lookup_in_options : public common_durability_options<lookup_in_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        return { build_common_durability_options(), access_deleted_ };
+        auto base = build_common_durability_options();
+        return { base, access_deleted_ };
     }
 
     /**

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

@@ -61,7 +61,7 @@ class manager_error_context : public error_context
     manager_error_context(std::error_code ec,
                           std::optional<std::string> last_dispatched_to,
                           std::optional<std::string> last_dispatched_from,
-                          int retry_attempts,
+                          std::size_t retry_attempts,
                           std::set<retry_reason> retry_reasons,
                           std::string client_context_id,
                           std::uint32_t http_status,
@@ -133,4 +133,4 @@ class manager_error_context : public error_context
     std::string content_{};
     std::string path_{};
 };
-} // namespace couchbase
+} // namespace couchbase

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

@@ -69,9 +69,8 @@ struct mutate_in_options : public common_durability_options<mutate_in_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        return {
-            build_common_durability_options(), expiry_, preserve_expiry_, store_semantics_, cas_, access_deleted_, create_as_deleted_
-        };
+        auto base = build_common_durability_options();
+        return { base, expiry_, preserve_expiry_, store_semantics_, cas_, access_deleted_, create_as_deleted_ };
     }
 
     /**

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

@@ -61,7 +61,8 @@ struct prepend_options : public common_durability_options<prepend_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        return { build_common_durability_options(), cas_ };
+        auto base = build_common_durability_options();
+        return { base, cas_ };
     }
 
     /**

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

@@ -44,7 +44,7 @@ class query_error_context : public error_context
     query_error_context(std::error_code ec,
                         std::optional<std::string> last_dispatched_to,
                         std::optional<std::string> last_dispatched_from,
-                        int retry_attempts,
+                        std::size_t retry_attempts,
                         std::set<retry_reason> retry_reasons,
                         std::uint64_t first_error_code,
                         std::string first_error_message,

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

@@ -351,7 +351,7 @@ struct query_options : public common_options<query_options> {
      */
     auto scope_qualifier(std::string scope_qualifier) -> query_options&
     {
-        client_context_id_ = std::move(scope_qualifier);
+        scope_qualifier_ = std::move(scope_qualifier);
         return self();
     }
 
@@ -460,6 +460,26 @@ struct query_options : public common_options<query_options> {
         return self();
     }
 
+    /**
+     * Set map of raw options for a query.
+     *
+     * This function expects that all parameters encoded into pairs containing mapping names of the parameter to valid JSON values encoded
+     * as string.
+     *
+     * @note This function is low-level, and instead @ref raw() should be considered.
+     *
+     * @param options mapping of pairs, where each entry contains string with valid JSON value.
+     * @return this options builder for chaining purposes.
+     *
+     * @since 1.0.0
+     * @uncommitted
+     */
+    auto encoded_raw_options(std::map<std::string, codec::binary, std::less<>> options) -> query_options&
+    {
+        raw_ = std::move(options);
+        return self();
+    }
+
     /**
      * Set list of positional parameters for a query.
      *

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

@@ -99,5 +99,4 @@ class query_result
     query_meta_data meta_data_{};
     std::vector<codec::binary> rows_{};
 };
-
 } // namespace couchbase

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

@@ -61,7 +61,8 @@ struct remove_options : public common_durability_options<remove_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        return { build_common_durability_options(), cas_ };
+        auto base = build_common_durability_options();
+        return { base, cas_ };
     }
 
     /**

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

@@ -63,7 +63,8 @@ struct replace_options : public common_durability_options<replace_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        return { build_common_durability_options(), expiry_, preserve_expiry_, cas_ };
+        auto base = build_common_durability_options();
+        return { base, expiry_, preserve_expiry_, cas_ };
     }
 
     /**

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

@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2022-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 <chrono>
+
+namespace couchbase
+{
+class retry_action
+{
+  public:
+    static auto do_not_retry() -> const retry_action&;
+
+    explicit retry_action(std::chrono::milliseconds waiting_duration);
+
+    [[nodiscard]] auto need_to_retry() const -> bool;
+
+    [[nodiscard]] auto duration() const -> std::chrono::milliseconds
+    {
+        return waiting_duration_;
+    }
+
+  private:
+    std::chrono::milliseconds waiting_duration_;
+};
+} // namespace couchbase

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

@@ -42,7 +42,7 @@ enum class retry_reason {
     socket_not_available,
 
     /**
-     * The service on a node (i.e. kv, query) is not available.
+     * The service on a node (i.e. key_value, query) is not available.
      */
     service_not_available,
 
@@ -54,25 +54,25 @@ enum class retry_reason {
     /**
      * A not my vbucket response has been received.
      */
-    kv_not_my_vbucket,
+    key_value_not_my_vbucket,
 
     /**
      * A KV response has been received which signals an outdated collection.
      */
-    kv_collection_outdated,
+    key_value_collection_outdated,
 
     /**
      * An unknown response was returned and the consulted KV error map indicated a retry.
      */
-    kv_error_map_retry_indicated,
+    key_value_error_map_retry_indicated,
 
-    kv_locked,
+    key_value_locked,
 
-    kv_temporary_failure,
+    key_value_temporary_failure,
 
-    kv_sync_write_in_progress,
+    key_value_sync_write_in_progress,
 
-    kv_sync_write_re_commit_in_progress,
+    key_value_sync_write_re_commit_in_progress,
 
     service_response_code_indicated,
 
@@ -98,4 +98,10 @@ enum class retry_reason {
 
     views_no_active_partition,
 };
+
+bool
+allows_non_idempotent_retry(retry_reason reason);
+
+bool
+always_retry(retry_reason reason);
 } // namespace couchbase

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

@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2022-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/retry_reason.hxx>
+
+#include <set>
+#include <string>
+
+namespace couchbase
+{
+class retry_request
+{
+  public:
+    [[nodiscard]] virtual auto retry_attempts() const -> std::size_t = 0;
+    [[nodiscard]] virtual auto identifier() const -> std::string = 0;
+    [[nodiscard]] virtual auto idempotent() const -> bool = 0;
+    [[nodiscard]] virtual auto retry_reasons() const -> std::set<retry_reason> = 0;
+
+    virtual ~retry_request() = default;
+
+    virtual void record_retry_attempt(retry_reason reason) = 0;
+};
+} // namespace couchbase

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

@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2022-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/retry_action.hxx>
+#include <couchbase/retry_reason.hxx>
+#include <couchbase/retry_request.hxx>
+
+#include <cstddef>
+
+namespace couchbase
+{
+class retry_strategy
+{
+  public:
+    virtual ~retry_strategy() = default;
+    virtual auto retry_after(const retry_request& request, retry_reason reason) -> retry_action = 0;
+    [[nodiscard]] virtual auto to_string() const -> std::string = 0;
+};
+} // namespace couchbase

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

@@ -65,7 +65,7 @@ class subdocument_error_context : public key_value_error_context
     subdocument_error_context(std::error_code ec,
                               std::optional<std::string> last_dispatched_to,
                               std::optional<std::string> last_dispatched_from,
-                              int retry_attempts,
+                              std::size_t retry_attempts,
                               std::set<retry_reason> retry_reasons,
                               std::string id,
                               std::string bucket,