couchbase 4.2.0 → 4.2.2

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/scope.hxx

@@ -104,8 +104,11 @@ class scope
     template<typename Handler>
     void query(std::string statement, const query_options& options, Handler&& handler) const
     {
-        return core::impl::initiate_query_operation(
-          core_, std::move(statement), bucket_name_, name_, options.build(), std::forward<Handler>(handler));
+        return core::impl::initiate_query_operation(core_,
+                                                    std::move(statement),
+                                                    fmt::format("default:`{}`.`{}`", bucket_name_, name_),
+                                                    options.build(),
+                                                    std::forward<Handler>(handler));
     }
 
     /**

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,

package/deps/couchbase-cxx-client/couchbase/tracing/request_tracer.hxx

@@ -72,6 +72,22 @@ class request_tracer
     request_tracer& operator=(request_tracer&& other) = default;
     virtual ~request_tracer() = default;
 
+    /**
+     * SDK invokes this method when cluster is ready to trace. Override it as NO-OP if no action is necessary.
+     */
+    virtual void start()
+    {
+        /* do nothing */
+    }
+
+    /**
+     * SDK invokes this method when cluster is closed. Override it as NO-OP if no action is necessary.
+     */
+    virtual void stop()
+    {
+        /* do nothing */
+    }
+
     virtual std::shared_ptr<request_span> start_span(std::string name, std::shared_ptr<request_span> parent = {}) = 0;
 };
 

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

@@ -17,7 +17,9 @@
 
 #pragma once
 
-#include <couchbase/error_context.hxx>
+#include <couchbase/key_value_error_context.hxx>
+#include <couchbase/query_error_context.hxx>
+#include <variant>
 
 namespace couchbase
 {
@@ -26,25 +28,49 @@ class transaction_op_error_context
   public:
     transaction_op_error_context() = default;
 
-    transaction_op_error_context(std::error_code ec, couchbase::error_context cause = {})
-      : ec_(std::move(ec))
+    transaction_op_error_context(std::error_code ec)
+      : ec_(ec)
+    {
+    }
+
+    transaction_op_error_context(std::error_code ec, couchbase::key_value_error_context cause)
+      : ec_(ec)
+      , cause_(std::move(cause))
+    {
+    }
+
+    transaction_op_error_context(std::error_code ec, couchbase::query_error_context cause)
+      : ec_(ec)
       , cause_(std::move(cause))
     {
     }
+
+    /**
+     * The error_code associated with this error context.   This will always be a @ref transaction_op_error_code
+     *
+     * Note that some query errors are not _transaction_ errors, so this error code will be 0, but there will be
+     * a @ref transaction_op_error_code#cause() with a query_error_context in it.  These errors do not rollback a
+     * transaction.   If you want to roll it back, raise an exception.
+     *
+     * @return a transaction_op_error_code, if any.
+     */
     [[nodiscard]] std::error_code ec() const
     {
         return ec_;
     }
 
-    [[nodiscard]] couchbase::error_context cause() const
+    /**
+     * The underlying cause of this error.   This can be either a @ref key_value_error_code or a @ref query_error_context.
+     *
+     * @return the error_context associated with the underlying cause of this error.
+     */
+    [[nodiscard]] std::variant<key_value_error_context, query_error_context> cause() const
     {
         return cause_;
     }
 
   private:
     std::error_code ec_{}; // a transaction_op error_code
-    // TODO: perhaps a variant later to house a kv or query error_context,
-    //       or maybe they both have a common base, etc...
-    couchbase::error_context cause_{};
+    std::variant<key_value_error_context, query_error_context> cause_{};
 };
 } // namespace couchbase

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

@@ -16,20 +16,23 @@
 #pragma once
 
 #include <couchbase/transactions/transaction_get_result.hxx>
+#include <couchbase/transactions/transaction_query_options.hxx>
+#include <couchbase/transactions/transaction_query_result.hxx>
 
 namespace couchbase::transactions
 {
 using async_result_handler = std::function<void(transaction_get_result_ptr)>;
+using async_query_handler = std::function<void(transaction_query_result_ptr)>;
 using async_err_handler = std::function<void(transaction_op_error_context)>;
 class async_attempt_context
 {
 
   public:
-    virtual void get(std::shared_ptr<collection> coll, std::string id, async_result_handler&& handler) = 0;
+    virtual void get(const collection& coll, std::string id, async_result_handler&& handler) = 0;
     virtual void remove(transaction_get_result_ptr doc, async_err_handler&& handler) = 0;
 
     template<typename Content>
-    void insert(std::shared_ptr<collection> coll, std::string id, Content&& content, async_result_handler&& handler)
+    void insert(const collection& coll, std::string id, Content&& content, async_result_handler&& handler)
     {
         if constexpr (std::is_same_v<Content, std::vector<std::byte>>) {
             return insert_raw(content, id, content, std::move(handler));
@@ -48,13 +51,28 @@ class async_attempt_context
         }
     }
 
+    void query(const scope& scope, std::string statement, transaction_query_options opts, async_query_handler&& handler)
+    {
+        return query(std::move(statement), std::move(opts), fmt::format("{}.{}", scope.bucket_name(), scope.name()), std::move(handler));
+    }
+
+    void query(std::string statement, transaction_query_options opts, async_query_handler&& handler)
+    {
+        return query(statement, opts, {}, std::move(handler));
+    };
+
+    void query(std::string statement, async_query_handler&& handler)
+    {
+        return query(statement, {}, {}, std::move(handler));
+    }
     virtual ~async_attempt_context() = default;
 
   protected:
-    virtual void insert_raw(std::shared_ptr<collection> coll,
-                            std::string id,
-                            std::vector<std::byte> content,
-                            async_result_handler&& handler) = 0;
+    virtual void insert_raw(const collection& coll, std::string id, std::vector<std::byte> content, async_result_handler&& handler) = 0;
     virtual void replace_raw(transaction_get_result_ptr doc, std::vector<std::byte> content, async_result_handler&& handler) = 0;
+    virtual void query(std::string statement,
+                       transaction_query_options opts,
+                       std::optional<std::string> query_context,
+                       async_query_handler&&) = 0;
 };
 } // namespace couchbase::transactions

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

@@ -16,16 +16,18 @@
 #pragma once
 
 #include <couchbase/transactions/transaction_get_result.hxx>
+#include <couchbase/transactions/transaction_query_options.hxx>
+#include <couchbase/transactions/transaction_query_result.hxx>
 
 namespace couchbase::transactions
 {
 class attempt_context
 {
   public:
-    virtual transaction_get_result_ptr get(std::shared_ptr<couchbase::collection> coll, const std::string& id) = 0;
+    virtual transaction_get_result_ptr get(const couchbase::collection& coll, const std::string& id) = 0;
 
     template<typename Content>
-    transaction_get_result_ptr insert(std::shared_ptr<couchbase::collection> coll, const std::string& id, const Content& content)
+    transaction_get_result_ptr insert(const couchbase::collection& coll, const std::string& id, const Content& content)
     {
         if constexpr (std::is_same_v<Content, std::vector<std::byte>>) {
             return insert_raw(content, id, content);
@@ -46,16 +48,26 @@ class attempt_context
 
     virtual transaction_op_error_context remove(transaction_get_result_ptr doc) = 0;
 
-    // TODO: when public api has query, we will be able to use non-core options to create the transaction_query_options.
-    // virtual transaction_op_error_context query(const std::string& statement, const transaction_query_options& options, QueryCallback&&
-    // cb) = 0;
+    transaction_query_result_ptr query(const std::string& statement, const transaction_query_options& options = {})
+    {
+        return do_public_query(statement, options, {});
+    }
+
+    transaction_query_result_ptr query(const scope& scope, std::string& statement, const transaction_query_options& opts = {})
+    {
+        auto new_opts = opts;
+        return do_public_query(statement, opts, fmt::format("{}.{}", scope.bucket_name(), scope.name()));
+    }
 
     virtual ~attempt_context() = default;
 
   protected:
     virtual transaction_get_result_ptr replace_raw(const transaction_get_result_ptr doc, std::vector<std::byte> content) = 0;
-    virtual transaction_get_result_ptr insert_raw(std::shared_ptr<couchbase::collection> coll,
+    virtual transaction_get_result_ptr insert_raw(const couchbase::collection& coll,
                                                   const std::string& id,
                                                   std::vector<std::byte> content) = 0;
+    virtual transaction_query_result_ptr do_public_query(const std::string& statement,
+                                                         const transaction_query_options& options,
+                                                         std::optional<std::string> query_context) = 0;
 };
 } // namespace couchbase::transactions

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

@@ -18,6 +18,7 @@
 #include "couchbase/collection.hxx"
 #include "couchbase/scope.hxx"
 
+#include <fmt/format.h>
 #include <string>
 #include <utility>
 
@@ -27,10 +28,27 @@ namespace couchbase::transactions
  * @brief  Offline, serializable representation of a bucket, scope, and collection
  */
 struct transaction_keyspace {
+
     std::string bucket;
     std::string scope{ couchbase::scope::default_name };
     std::string collection{ couchbase::collection::default_name };
 
+    transaction_keyspace(const transaction_keyspace&) = default;
+    transaction_keyspace(transaction_keyspace&&) = default;
+    transaction_keyspace& operator=(const transaction_keyspace& keyspace)
+    {
+        if (this != &keyspace) {
+            bucket = keyspace.bucket;
+            scope = keyspace.scope;
+            collection = keyspace.collection;
+        }
+        return *this;
+    }
+    bool operator==(const transaction_keyspace& keyspace)
+    {
+        return bucket == keyspace.bucket && scope == keyspace.scope && collection == keyspace.collection;
+    }
+
     transaction_keyspace(std::string bucket_name, std::string scope_name, std::string collection_name)
       : bucket(std::move(bucket_name))
       , scope(std::move(scope_name))
@@ -48,5 +66,36 @@ struct transaction_keyspace {
       : transaction_keyspace{ bucket_name, couchbase::scope::default_name, couchbase::collection::default_name }
     {
     }
+
+    bool valid()
+    {
+        return !bucket.empty() && !scope.empty() && !collection.empty();
+    }
+
+    template<typename OStream>
+    friend OStream& operator<<(OStream& os, const transaction_keyspace& keyspace)
+    {
+        os << "transaction_keyspace{";
+        os << "bucket: " << keyspace.bucket;
+        os << ", scope: " << keyspace.scope;
+        os << ", collection: " << keyspace.collection;
+        os << "}";
+        return os;
+    }
 };
-} // namespace couchbase::transactions
+} // namespace couchbase::transactions
+template<>
+struct fmt::formatter<couchbase::transactions::transaction_keyspace> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const couchbase::transactions::transaction_keyspace& k, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(), "transaction_keyspace:{{ bucket: {}, scope: {}, collection: {} }}", k.bucket, k.scope, k.collection);
+    }
+};

package/deps/couchbase-cxx-client/couchbase/transactions/{per_transaction_config.hxx → transaction_options.hxx}

@@ -16,21 +16,20 @@
 
 #pragma once
 
-#include "couchbase/transactions/transaction_config.hxx"
-
-#include "couchbase/query_scan_consistency.hxx"
+#include <couchbase/query_scan_consistency.hxx>
+#include <couchbase/transactions/transactions_config.hxx>
 
 #include <chrono>
 #include <optional>
 
 namespace couchbase::transactions
 {
-class per_transaction_config
+class transaction_options
 {
   public:
-    per_transaction_config() = default;
+    transaction_options() = default;
 
-    per_transaction_config& durability_level(durability_level level)
+    transaction_options& durability_level(durability_level level)
     {
         durability_ = level;
         return *this;
@@ -41,7 +40,7 @@ class per_transaction_config
         return durability_;
     }
 
-    per_transaction_config& scan_consistency(query_scan_consistency scan_consistency)
+    transaction_options& scan_consistency(query_scan_consistency scan_consistency)
     {
         scan_consistency_ = scan_consistency;
         return *this;
@@ -52,7 +51,7 @@ class per_transaction_config
         return scan_consistency_;
     }
 
-    per_transaction_config& kv_timeout(std::chrono::milliseconds kv_timeout)
+    transaction_options& kv_timeout(std::chrono::milliseconds kv_timeout)
     {
         kv_timeout_ = kv_timeout;
         return *this;
@@ -64,7 +63,7 @@ class per_transaction_config
     }
 
     template<typename T>
-    per_transaction_config& expiration_time(T expiration_time)
+    transaction_options& expiration_time(T expiration_time)
     {
         expiration_time_ = std::chrono::duration_cast<std::chrono::nanoseconds>(expiration_time);
         return *this;
@@ -75,44 +74,42 @@ class per_transaction_config
         return expiration_time_;
     }
 
-    per_transaction_config& custom_metadata_collection(const transaction_keyspace& keyspace)
+    transaction_options& metadata_collection(const couchbase::collection& coll)
     {
-        custom_metadata_collection_.emplace(keyspace);
+        metadata_collection_.emplace(coll.bucket_name(), coll.scope_name(), coll.name());
         return *this;
     }
 
-    std::optional<transaction_keyspace> custom_metadata_collection()
+    transaction_options& metadata_collection(const couchbase::transactions::transaction_keyspace& keyspace)
     {
-        return custom_metadata_collection_;
+        metadata_collection_.emplace(keyspace);
+        return *this;
     }
 
-    transaction_config apply(const transaction_config& conf) const
+    std::optional<transaction_keyspace> metadata_collection()
     {
-        transaction_config retval = conf;
-        if (durability_) {
-            retval.durability_level(*durability_);
-        }
-        if (scan_consistency_) {
-            retval.scan_consistency(*scan_consistency_);
-        }
-        if (kv_timeout_) {
-            retval.kv_timeout(*kv_timeout_);
-        }
-        if (expiration_time_) {
-            retval.expiration_time(*expiration_time_);
-        }
-        if (custom_metadata_collection_) {
-            retval.custom_metadata_collection(*custom_metadata_collection_);
-        }
-        return retval;
+        return metadata_collection_;
     }
 
+    /** @internal */
+    transaction_options& test_factories(std::shared_ptr<core::transactions::attempt_context_testing_hooks> hooks,
+                                        std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks)
+    {
+        attempt_context_hooks_ = hooks;
+        cleanup_hooks_ = cleanup_hooks;
+        return *this;
+    }
+
+    [[nodiscard]] transactions_config::built apply(const transactions_config::built& conf) const;
+
   private:
     std::optional<couchbase::durability_level> durability_;
-    std::optional<query_scan_consistency> scan_consistency_;
+    std::optional<couchbase::query_scan_consistency> scan_consistency_;
     std::optional<std::chrono::milliseconds> kv_timeout_;
     std::optional<std::chrono::nanoseconds> expiration_time_;
-    std::optional<transaction_keyspace> custom_metadata_collection_;
+    std::optional<transaction_keyspace> metadata_collection_;
+    std::shared_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks_;
+    std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks_;
 };
 
 } // namespace couchbase::transactions

package/deps/couchbase-cxx-client/{core → couchbase}/transactions/transaction_query_options.hxx

@@ -15,9 +15,14 @@
  */
 #pragma once
 
+// TODO: remove this when moving the wrap_request call
 #include "core/operations/document_query.hxx"
+#include <couchbase/query_options.hxx>
 
-namespace couchbase::core::transactions
+// NOTE: when query is in public api, we will hold a query_options struct instead, and
+// import that from the public api.
+
+namespace couchbase::transactions
 {
 class transaction_context;
 
@@ -27,117 +32,128 @@ class transaction_query_options
     transaction_query_options()
     {
         // set defaults specific to query in transactions.
-        query_req_.metrics = true;
+        opts_.metrics(true);
     }
-    transaction_query_options(const core::operations::query_request& req)
+    /*transaction_query_options(const core::operations::query_request& req)
       : query_req_(req)
     {
-    }
-
-    core::operations::query_request query_request() const
-    {
-        return query_req_;
-    }
+    }*/
 
-    transaction_query_options& raw(const std::string& key, const core::json_string& value)
+    template<typename Value>
+    transaction_query_options& raw(const std::string& key, const Value& value)
     {
-        query_req_.raw[key] = value;
+        opts_.raw(key, value);
         return *this;
     }
 
     transaction_query_options& ad_hoc(bool value)
     {
-        query_req_.adhoc = value;
+        opts_.adhoc(value);
         return *this;
     }
 
     transaction_query_options& scan_consistency(query_scan_consistency scan_consistency)
     {
-        query_req_.scan_consistency = scan_consistency;
+        opts_.scan_consistency(scan_consistency);
         return *this;
     }
 
     transaction_query_options& profile(query_profile mode)
     {
-        query_req_.profile = mode;
+        opts_.profile(mode);
         return *this;
     }
 
     transaction_query_options& client_context_id(const std::string& id)
     {
-        query_req_.client_context_id = id;
+        opts_.client_context_id(id);
         return *this;
     }
 
     transaction_query_options& scan_wait(std::chrono::milliseconds scan_wait)
     {
-        query_req_.scan_wait = scan_wait;
+        opts_.scan_wait(scan_wait);
         return *this;
     }
 
     transaction_query_options& readonly(bool readonly)
     {
-        query_req_.readonly = readonly;
+        opts_.readonly(readonly);
         return *this;
     }
 
     transaction_query_options& scan_cap(std::uint64_t cap)
     {
-        query_req_.scan_cap = cap;
+        opts_.scan_cap(cap);
         return *this;
     }
 
     transaction_query_options& pipeline_batch(std::uint64_t batch)
     {
-        query_req_.pipeline_batch = batch;
+        opts_.pipeline_batch(batch);
         return *this;
     }
 
     transaction_query_options& pipeline_cap(std::uint64_t cap)
     {
-        query_req_.pipeline_cap = cap;
+        opts_.pipeline_cap(cap);
         return *this;
     }
 
-    transaction_query_options& positional_parameters(std::vector<core::json_string> params)
+    template<typename... Parameters>
+    auto positional_parameters(const Parameters&... parameters)
     {
-        query_req_.positional_parameters = params;
+        opts_.positional_parameters(parameters...);
         return *this;
     }
 
-    transaction_query_options& named_parameters(std::map<std::string, core::json_string, std::less<>> params)
+    template<typename... Parameters>
+    transaction_query_options& named_parameters(const Parameters&... parameters)
     {
-        query_req_.named_parameters = params;
+        opts_.named_parameters(parameters...);
         return *this;
     }
 
-    transaction_query_options& bucket_name(const std::string& bucket)
+    transaction_query_options& metrics(bool metrics)
     {
-        query_req_.bucket_name = bucket;
+        opts_.metrics(metrics);
         return *this;
     }
 
-    transaction_query_options& scope_name(const std::string& scope)
+    transaction_query_options& max_parallelism(std::uint64_t max)
     {
-        query_req_.scope_name = scope;
+        opts_.max_parallelism(max);
         return *this;
     }
 
-    transaction_query_options& metrics(bool metrics)
+    /** @internal */
+    transaction_query_options& encoded_raw_options(std::map<std::string, codec::binary, std::less<>> options)
     {
-        query_req_.metrics = metrics;
+        opts_.encoded_raw_options(options);
         return *this;
     }
 
-    transaction_query_options& max_parallelism(std::uint64_t max)
+    /** @internal */
+    transaction_query_options& encoded_positional_parameters(std::vector<codec::binary> parameters)
     {
-        query_req_.max_parallelism = max;
+        opts_.encoded_positional_parameters(parameters);
         return *this;
     }
 
-    core::operations::query_request wrap_request(const transaction_context& txn_ctx) const;
+    /** @internal */
+    transaction_query_options& encoded_named_parameters(std::map<std::string, codec::binary, std::less<>> parameters)
+    {
+        opts_.encoded_named_parameters(parameters);
+        return *this;
+    }
+
+    /** @internal */
+    const query_options& get_query_options() const
+    {
+        return opts_;
+    }
 
   private:
-    core::operations::query_request query_req_;
+    query_options opts_{};
 };
-} // namespace couchbase::core::transactions
+} // namespace couchbase::transactions