couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/transactions/transaction_links.hxx

@@ -16,250 +16,271 @@
 
 #pragma once
 
+#include <couchbase/codec/encoded_value.hxx>
+
 #include <fmt/format.h>
+#include <tao/json/value.hpp>
+
 #include <optional>
 #include <ostream>
 #include <string>
-#include <tao/json/value.hpp>
 
 namespace couchbase::core::transactions
 {
 /** @internal */
 class transaction_links
 {
-  private:
-    std::optional<std::string> atr_id_;
-    std::optional<std::string> atr_bucket_name_;
-    std::optional<std::string> atr_scope_name_;
-    std::optional<std::string> atr_collection_name_;
-    // id of the transaction that has staged content
-    std::optional<std::string> staged_transaction_id_;
-    std::optional<std::string> staged_attempt_id_;
-    std::optional<std::string> staged_operation_id_;
-    std::optional<std::vector<std::byte>> staged_content_;
-
-    // for {BACKUP_FIELDS}
-    std::optional<std::string> cas_pre_txn_;
-    std::optional<std::string> revid_pre_txn_;
-    std::optional<std::uint32_t> exptime_pre_txn_;
-    std::optional<std::string> crc32_of_staging_;
-    std::optional<std::string> op_;
-    std::optional<tao::json::value> forward_compat_;
-    bool is_deleted_{ false };
-
-  public:
-    transaction_links() = default;
-    transaction_links(std::optional<std::string> atr_id,
-                      std::optional<std::string> atr_bucket_name,
-                      std::optional<std::string> atr_scope_name,
-                      std::optional<std::string> atr_collection_name,
-                      std::optional<std::string> staged_transaction_id,
-                      std::optional<std::string> staged_attempt_id,
-                      std::optional<std::string> staged_operation_id,
-                      std::optional<std::vector<std::byte>> staged_content,
-                      std::optional<std::string> cas_pre_txn,
-                      std::optional<std::string> revid_pre_txn,
-                      std::optional<std::uint32_t> exptime_pre_txn,
-                      std::optional<std::string> crc32_of_staging,
-                      std::optional<std::string> op,
-                      std::optional<tao::json::value> forward_compat,
-                      bool is_deleted)
-      : atr_id_(std::move(atr_id))
-      , atr_bucket_name_(std::move(atr_bucket_name))
-      , atr_scope_name_(std::move(atr_scope_name))
-      , atr_collection_name_(std::move(atr_collection_name))
-      , staged_transaction_id_(std::move(staged_transaction_id))
-      , staged_attempt_id_(std::move(staged_attempt_id))
-      , staged_operation_id_(std::move(staged_operation_id))
-      , staged_content_(std::move(staged_content))
-      , cas_pre_txn_(std::move(cas_pre_txn))
-      , revid_pre_txn_(std::move(revid_pre_txn))
-      , exptime_pre_txn_(exptime_pre_txn)
-      , crc32_of_staging_(std::move(crc32_of_staging))
-      , op_(std::move(op))
-      , forward_compat_(forward_compat)
-      , is_deleted_(is_deleted)
-    {
-    }
+private:
+  std::optional<std::string> atr_id_;
+  std::optional<std::string> atr_bucket_name_;
+  std::optional<std::string> atr_scope_name_;
+  std::optional<std::string> atr_collection_name_;
+  // id of the transaction that has staged content
+  std::optional<std::string> staged_transaction_id_;
+  std::optional<std::string> staged_attempt_id_;
+  std::optional<std::string> staged_operation_id_;
+  std::optional<codec::encoded_value> staged_content_json_;
+  std::optional<codec::encoded_value> staged_content_binary_;
 
-    /** @brief create links from query result
-     *
-     * @param json the returned row object from a txn query response.
-     */
-    explicit transaction_links(const tao::json::value& json)
-    {
-        if (const auto* meta = json.find("txnMeta"); meta != nullptr && meta->is_object()) {
-            for (const auto& [key, value] : meta->get_object()) {
-                if (key == "atmpt") {
-                    staged_attempt_id_ = value.get_string();
-                }
-                if (key == "txn") {
-                    staged_transaction_id_ = value.get_string();
-                }
-                if (key == "atr" && value.is_object()) {
-                    atr_id_ = value.at("key").get_string();
-                    atr_bucket_name_ = value.at("bkt").get_string();
-                    atr_scope_name_ = value.at("scp").get_string();
-                    atr_collection_name_ = value.at("coll").get_string();
-                }
-            }
-        }
-    }
+  // for {BACKUP_FIELDS}
+  std::optional<std::string> cas_pre_txn_;
+  std::optional<std::string> revid_pre_txn_;
+  std::optional<std::uint32_t> exptime_pre_txn_;
+  std::optional<std::string> crc32_of_staging_;
+  std::optional<std::string> op_;
+  std::optional<tao::json::value> forward_compat_;
+  bool is_deleted_{ false };
 
-    void append_to_json(tao::json::value& obj) const
-    {
-        if (staged_attempt_id_) {
-            obj["txnMeta"]["atmpt"] = staged_attempt_id_.value();
-        }
-        if (staged_transaction_id_) {
-            obj["txnMeta"]["txn"] = staged_transaction_id_.value();
-        }
-        if (staged_operation_id_) {
-            obj["txnMeta"]["txn"] = staged_operation_id_.value();
-        }
-        if (atr_id_) {
-            obj["txnMeta"]["atr"]["key"] = atr_id_.value();
-        }
-        if (atr_bucket_name_) {
-            obj["txnMeta"]["atr"]["bkt"] = atr_bucket_name_.value();
+public:
+  transaction_links() = default;
+  transaction_links(std::optional<std::string> atr_id,
+                    std::optional<std::string> atr_bucket_name,
+                    std::optional<std::string> atr_scope_name,
+                    std::optional<std::string> atr_collection_name,
+                    std::optional<std::string> staged_transaction_id,
+                    std::optional<std::string> staged_attempt_id,
+                    std::optional<std::string> staged_operation_id,
+                    std::optional<codec::encoded_value> staged_content_json,
+                    std::optional<codec::encoded_value> staged_content_binary,
+                    std::optional<std::string> cas_pre_txn,
+                    std::optional<std::string> revid_pre_txn,
+                    std::optional<std::uint32_t> exptime_pre_txn,
+                    std::optional<std::string> crc32_of_staging,
+                    std::optional<std::string> op,
+                    std::optional<tao::json::value> forward_compat,
+                    bool is_deleted)
+    : atr_id_(std::move(atr_id))
+    , atr_bucket_name_(std::move(atr_bucket_name))
+    , atr_scope_name_(std::move(atr_scope_name))
+    , atr_collection_name_(std::move(atr_collection_name))
+    , staged_transaction_id_(std::move(staged_transaction_id))
+    , staged_attempt_id_(std::move(staged_attempt_id))
+    , staged_operation_id_(std::move(staged_operation_id))
+    , staged_content_json_(std::move(staged_content_json))
+    , staged_content_binary_(std::move(staged_content_binary))
+    , cas_pre_txn_(std::move(cas_pre_txn))
+    , revid_pre_txn_(std::move(revid_pre_txn))
+    , exptime_pre_txn_(exptime_pre_txn)
+    , crc32_of_staging_(std::move(crc32_of_staging))
+    , op_(std::move(op))
+    , forward_compat_(forward_compat)
+    , is_deleted_(is_deleted)
+  {
+  }
+
+  /** @brief create links from query result
+   *
+   * @param json the returned row object from a txn query response.
+   */
+  explicit transaction_links(const tao::json::value& json)
+  {
+    if (const auto* meta = json.find("txnMeta"); meta != nullptr && meta->is_object()) {
+      for (const auto& [key, value] : meta->get_object()) {
+        if (key == "atmpt") {
+          staged_attempt_id_ = value.get_string();
         }
-        if (atr_scope_name_) {
-            obj["txnMeta"]["atr"]["scp"] = atr_scope_name_.value();
+        if (key == "txn") {
+          staged_transaction_id_ = value.get_string();
         }
-        if (atr_collection_name_) {
-            obj["txnMeta"]["atr"]["coll"] = atr_collection_name_.value();
+        if (key == "atr" && value.is_object()) {
+          atr_id_ = value.at("key").get_string();
+          atr_bucket_name_ = value.at("bkt").get_string();
+          atr_scope_name_ = value.at("scp").get_string();
+          atr_collection_name_ = value.at("coll").get_string();
         }
+      }
     }
+  }
 
-    /**
-     * Note this doesn't guarantee an active transaction, as it may have expired and need rolling back.
-     */
-    [[nodiscard]] bool is_document_in_transaction() const
-    {
-        return !!(atr_id_);
+  void append_to_json(tao::json::value& obj) const
+  {
+    if (staged_attempt_id_) {
+      obj["txnMeta"]["atmpt"] = staged_attempt_id_.value();
     }
-    [[nodiscard]] bool has_staged_content() const
-    {
-        return !!(staged_content_);
+    if (staged_transaction_id_) {
+      obj["txnMeta"]["txn"] = staged_transaction_id_.value();
     }
-    [[nodiscard]] bool is_document_being_removed() const
-    {
-        return (!!op_ && *op_ == "remove");
+    if (staged_operation_id_) {
+      obj["txnMeta"]["txn"] = staged_operation_id_.value();
     }
-
-    [[nodiscard]] bool is_document_being_inserted() const
-    {
-        return (!!op_ && *op_ == "insert");
+    if (atr_id_) {
+      obj["txnMeta"]["atr"]["key"] = atr_id_.value();
     }
-
-    [[nodiscard]] bool has_staged_write() const
-    {
-        return !!(staged_attempt_id_);
+    if (atr_bucket_name_) {
+      obj["txnMeta"]["atr"]["bkt"] = atr_bucket_name_.value();
     }
-
-    [[nodiscard]] std::optional<std::string> atr_id() const
-    {
-        return atr_id_;
+    if (atr_scope_name_) {
+      obj["txnMeta"]["atr"]["scp"] = atr_scope_name_.value();
     }
-
-    [[nodiscard]] std::optional<std::string> atr_bucket_name() const
-    {
-        return atr_bucket_name_;
+    if (atr_collection_name_) {
+      obj["txnMeta"]["atr"]["coll"] = atr_collection_name_.value();
     }
+  }
 
-    [[nodiscard]] std::optional<std::string> atr_scope_name() const
-    {
-        return atr_scope_name_;
-    }
+  /**
+   * Note this doesn't guarantee an active transaction, as it may have expired
+   * and need rolling back.
+   */
+  [[nodiscard]] auto is_document_in_transaction() const -> bool
+  {
+    return !!(atr_id_);
+  }
 
-    [[nodiscard]] std::optional<std::string> atr_collection_name() const
-    {
-        return atr_collection_name_;
-    }
+  [[nodiscard]] auto is_document_being_removed() const -> bool
+  {
+    return (!!op_ && *op_ == "remove");
+  }
 
-    [[nodiscard]] std::optional<std::string> staged_transaction_id() const
-    {
-        return staged_transaction_id_;
-    }
+  [[nodiscard]] auto is_document_being_inserted() const -> bool
+  {
+    return (!!op_ && *op_ == "insert");
+  }
 
-    [[nodiscard]] std::optional<std::string> staged_attempt_id() const
-    {
-        return staged_attempt_id_;
-    }
+  [[nodiscard]] auto has_staged_write() const -> bool
+  {
+    return !!(staged_attempt_id_);
+  }
 
-    [[nodiscard]] std::optional<std::string> staged_operation_id() const
-    {
-        return staged_operation_id_;
-    }
+  [[nodiscard]] auto atr_id() const -> std::optional<std::string>
+  {
+    return atr_id_;
+  }
 
-    [[nodiscard]] std::optional<std::string> cas_pre_txn() const
-    {
-        return cas_pre_txn_;
-    }
+  [[nodiscard]] auto atr_bucket_name() const -> std::optional<std::string>
+  {
+    return atr_bucket_name_;
+  }
 
-    [[nodiscard]] std::optional<std::string> revid_pre_txn() const
-    {
-        return revid_pre_txn_;
-    }
+  [[nodiscard]] auto atr_scope_name() const -> std::optional<std::string>
+  {
+    return atr_scope_name_;
+  }
 
-    [[nodiscard]] std::optional<std::uint32_t> exptime_pre_txn() const
-    {
-        return exptime_pre_txn_;
-    }
+  [[nodiscard]] auto atr_collection_name() const -> std::optional<std::string>
+  {
+    return atr_collection_name_;
+  }
 
-    [[nodiscard]] std::optional<std::string> op() const
-    {
-        return op_;
-    }
+  [[nodiscard]] auto staged_transaction_id() const -> std::optional<std::string>
+  {
+    return staged_transaction_id_;
+  }
 
-    [[nodiscard]] std::optional<std::string> crc32_of_staging() const
-    {
-        return crc32_of_staging_;
-    }
+  [[nodiscard]] auto staged_attempt_id() const -> std::optional<std::string>
+  {
+    return staged_attempt_id_;
+  }
 
-    [[nodiscard]] std::vector<std::byte> staged_content() const
-    {
-        return staged_content_.value_or(std::vector<std::byte>{});
-    }
+  [[nodiscard]] auto staged_operation_id() const -> std::optional<std::string>
+  {
+    return staged_operation_id_;
+  }
 
-    [[nodiscard]] std::optional<tao::json::value> forward_compat() const
-    {
-        return forward_compat_;
-    }
+  [[nodiscard]] auto cas_pre_txn() const -> std::optional<std::string>
+  {
+    return cas_pre_txn_;
+  }
 
-    [[nodiscard]] bool is_deleted() const
-    {
-        return is_deleted_;
-    }
+  [[nodiscard]] auto revid_pre_txn() const -> std::optional<std::string>
+  {
+    return revid_pre_txn_;
+  }
+
+  [[nodiscard]] auto exptime_pre_txn() const -> std::optional<std::uint32_t>
+  {
+    return exptime_pre_txn_;
+  }
 
-    friend std::ostream& operator<<(std::ostream& os, const transaction_links& links);
+  [[nodiscard]] auto op() const -> std::optional<std::string>
+  {
+    return op_;
+  }
+
+  [[nodiscard]] auto crc32_of_staging() const -> std::optional<std::string>
+  {
+    return crc32_of_staging_;
+  }
+
+  [[nodiscard]] auto has_staged_content() const -> bool
+  {
+    return staged_content_json_ || staged_content_binary_;
+  }
+
+  [[nodiscard]] codec::encoded_value staged_content_json_or_binary() const
+  {
+    return staged_content_json_.value_or(staged_content_binary_.value_or(codec::encoded_value{}));
+  }
+
+  [[nodiscard]] codec::encoded_value staged_content_json() const
+  {
+    return staged_content_json_.value_or(codec::encoded_value{});
+  }
+
+  [[nodiscard]] codec::encoded_value staged_content_binary() const
+  {
+    return staged_content_binary_.value_or(codec::encoded_value{});
+  }
+
+  [[nodiscard]] auto forward_compat() const -> std::optional<tao::json::value>
+  {
+    return forward_compat_;
+  }
+
+  [[nodiscard]] auto is_deleted() const -> bool
+  {
+    return is_deleted_;
+  }
+
+  friend auto operator<<(std::ostream& os, const transaction_links& links) -> std::ostream&;
 };
 
-std::ostream&
-operator<<(std::ostream& os, const transaction_links& links);
+auto
+operator<<(std::ostream& os, const transaction_links& links) -> std::ostream&;
 } // namespace couchbase::core::transactions
 
 template<>
 struct fmt::formatter<couchbase::core::transactions::transaction_links> {
-  public:
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
+public:
+  template<typename ParseContext>
+  constexpr auto parse(ParseContext& ctx)
+  {
+    return ctx.begin();
+  }
 
-    template<typename FormatContext>
-    constexpr auto format(const couchbase::core::transactions::transaction_links& r, FormatContext& ctx) const
-    {
-        return format_to(ctx.out(),
-                         "transaction_links:{{ atr: {}.{}.{}.{}, txn_id: {}, attempt_id: {}, operation_id: {}, crc32_of_staging: {} }}",
-                         r.atr_bucket_name().value_or("none"),
-                         r.atr_scope_name().value_or("none"),
-                         r.atr_collection_name().value_or("none"),
-                         r.atr_id().value_or("none"),
-                         r.staged_transaction_id().value_or("none"),
-                         r.staged_attempt_id().value_or("none"),
-                         r.staged_operation_id().value_or("none"),
-                         r.crc32_of_staging().value_or("none"));
-    }
+  template<typename FormatContext>
+  constexpr auto format(const couchbase::core::transactions::transaction_links& r,
+                        FormatContext& ctx) const
+  {
+    return format_to(ctx.out(),
+                     "transaction_links:{{ atr: {}.{}.{}.{}, txn_id: {}, attempt_id: {}, "
+                     "operation_id: {}, crc32_of_staging: {} }}",
+                     r.atr_bucket_name().value_or("none"),
+                     r.atr_scope_name().value_or("none"),
+                     r.atr_collection_name().value_or("none"),
+                     r.atr_id().value_or("none"),
+                     r.staged_transaction_id().value_or("none"),
+                     r.staged_attempt_id().value_or("none"),
+                     r.staged_operation_id().value_or("none"),
+                     r.crc32_of_staging().value_or("none"));
+  }
 };

data/ext/couchbase/core/transactions/transaction_options.cxx

@@ -22,74 +22,77 @@
 
 namespace couchbase::transactions
 {
-transactions_config::built
+auto
 transaction_options::apply(const transactions_config::built& conf) const
+  -> transactions_config::built
 {
-    auto query_config = conf.query_config;
-    if (scan_consistency_) {
-        query_config.scan_consistency = *scan_consistency_;
-    }
-    return { durability_.value_or(conf.level),
-             timeout_.value_or(conf.timeout),
-             attempt_context_hooks_ ? attempt_context_hooks_ : conf.attempt_context_hooks,
-             cleanup_hooks_ ? cleanup_hooks_ : conf.cleanup_hooks,
-             metadata_collection_ ? metadata_collection_ : conf.metadata_collection,
-             query_config,
-             conf.cleanup_config };
+  auto query_config = conf.query_config;
+  if (scan_consistency_) {
+    query_config.scan_consistency = *scan_consistency_;
+  }
+  return { durability_.value_or(conf.level),
+           timeout_.value_or(conf.timeout),
+           attempt_context_hooks_ ? attempt_context_hooks_ : conf.attempt_context_hooks,
+           cleanup_hooks_ ? cleanup_hooks_ : conf.cleanup_hooks,
+           metadata_collection_ ? metadata_collection_ : conf.metadata_collection,
+           query_config,
+           conf.cleanup_config };
 }
 
-transaction_options&
-transaction_options::test_factories(std::shared_ptr<core::transactions::attempt_context_testing_hooks> hooks,
-                                    std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks)
+auto
+transaction_options::test_factories(
+  std::shared_ptr<core::transactions::attempt_context_testing_hooks> hooks,
+  std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks) -> transaction_options&
 {
-    attempt_context_hooks_ = hooks;
-    cleanup_hooks_ = cleanup_hooks;
-    return *this;
+  attempt_context_hooks_ = hooks;
+  cleanup_hooks_ = cleanup_hooks;
+  return *this;
 }
 
-std::optional<transaction_keyspace>
-transaction_options::metadata_collection() const
+auto
+transaction_options::metadata_collection() const -> std::optional<transaction_keyspace>
 {
-    return metadata_collection_;
+  return metadata_collection_;
 }
 
-transaction_options&
-transaction_options::durability_level(couchbase::durability_level level)
+auto
+transaction_options::durability_level(couchbase::durability_level level) -> transaction_options&
 {
-    durability_ = level;
-    return *this;
+  durability_ = level;
+  return *this;
 }
 
-std::optional<couchbase::durability_level>
-transaction_options::durability_level() const
+auto
+transaction_options::durability_level() const -> std::optional<couchbase::durability_level>
 {
-    return durability_;
+  return durability_;
 }
 
-transaction_options&
+auto
 transaction_options::scan_consistency(query_scan_consistency scan_consistency)
+  -> transaction_options&
 {
-    scan_consistency_ = scan_consistency;
-    return *this;
+  scan_consistency_ = scan_consistency;
+  return *this;
 }
 
-std::optional<query_scan_consistency>
-transaction_options::scan_consistency() const
+auto
+transaction_options::scan_consistency() const -> std::optional<query_scan_consistency>
 {
-    return scan_consistency_;
+  return scan_consistency_;
 }
 
-std::optional<std::chrono::nanoseconds>
-transaction_options::timeout()
+auto
+transaction_options::timeout() -> std::optional<std::chrono::nanoseconds>
 {
-    return timeout_;
+  return timeout_;
 }
 
-transaction_options&
-transaction_options::metadata_collection(const couchbase::collection& coll)
+auto
+transaction_options::metadata_collection(const couchbase::collection& coll) -> transaction_options&
 {
-    metadata_collection_.emplace(coll.bucket_name(), coll.scope_name(), coll.name());
-    return *this;
+  metadata_collection_.emplace(coll.bucket_name(), coll.scope_name(), coll.name());
+  return *this;
 }
 
 } // namespace couchbase::transactions