fix ubsan

Author: wgtmac

src/iceberg/transaction.cc

@@ -51,11 +51,11 @@ const TableMetadata* Transaction::base() const { return metadata_builder_->base(
 
 const TableMetadata* Transaction::current() const { return metadata_builder_->current(); }
 
-Status Transaction::AddUpdate(std::shared_ptr<PendingUpdate> update) {
+Status Transaction::AddUpdate(const std::shared_ptr<PendingUpdate>& update) {
   if (!last_update_committed_) {
     return InvalidArgument("Cannot add update when previous update is not committed");
   }
-  pending_updates_.emplace_back(std::move(update));
+  pending_updates_.emplace_back(std::weak_ptr<PendingUpdate>(update));
   last_update_committed_ = false;
   return {};
 }

src/iceberg/transaction.h

@@ -63,7 +63,7 @@ class ICEBERG_EXPORT Transaction : public std::enable_shared_from_this<Transacti
  private:
   Transaction(std::shared_ptr<Table> table, Kind kind, bool auto_commit);
 
-  Status AddUpdate(std::shared_ptr<PendingUpdate> update);
+  Status AddUpdate(const std::shared_ptr<PendingUpdate>& update);
 
   /// \brief Apply the pending changes to current table.
   Status Apply(std::vector<std::unique_ptr<TableUpdate>> updates);
@@ -75,9 +75,11 @@ class ICEBERG_EXPORT Transaction : public std::enable_shared_from_this<Transacti
   const Kind kind_;
   const bool auto_commit_;
 
-  // Staged updates
+  // To make the state simple, we require updates are added and committed in order.
   bool last_update_committed_ = true;
-  std::vector<std::shared_ptr<PendingUpdate>> pending_updates_;
+  // Staged updates. Use weak_ptr to avoid circular references.
+  std::vector<std::weak_ptr<PendingUpdate>> pending_updates_;
+  // Accumulated updates from all pending updates.
   std::unique_ptr<TableMetadataBuilder> metadata_builder_;
 };
 

src/iceberg/update/update_properties.cc

@@ -19,8 +19,10 @@
 
 #include "iceberg/update/update_properties.h"
 
+#include <charconv>
 #include <cstdint>
 #include <memory>
+#include <system_error>
 
 #include "iceberg/metrics_config.h"
 #include "iceberg/result.h"
@@ -32,12 +34,12 @@
 
 namespace iceberg {
 
-Result<std::unique_ptr<UpdateProperties>> UpdateProperties::Make(
+Result<std::shared_ptr<UpdateProperties>> UpdateProperties::Make(
     std::shared_ptr<Transaction> transaction) {
   if (!transaction) [[unlikely]] {
     return InvalidArgument("Cannot create UpdateProperties without a transaction");
   }
-  return std::unique_ptr<UpdateProperties>(new UpdateProperties(std::move(transaction)));
+  return std::shared_ptr<UpdateProperties>(new UpdateProperties(std::move(transaction)));
 }
 
 UpdateProperties::UpdateProperties(std::shared_ptr<Transaction> transaction)
@@ -83,21 +85,23 @@ Result<PendingUpdate::ApplyResult> UpdateProperties::Apply() {
 
   auto iter = updates_.find(TableProperties::kFormatVersion.key());
   if (iter != updates_.end()) {
-    try {
-      int parsed_version = std::stoi(iter->second);
-      if (parsed_version > TableMetadata::kSupportedTableFormatVersion) {
-        return InvalidArgument(
-            "Cannot upgrade table to unsupported format version: v{} (supported: v{})",
-            parsed_version, TableMetadata::kSupportedTableFormatVersion);
-      }
-      format_version_ = static_cast<int8_t>(parsed_version);
-    } catch (const std::invalid_argument& e) {
-      return InvalidArgument("Invalid format version '{}': not a valid integer",
-                             iter->second);
-    } catch (const std::out_of_range& e) {
-      return InvalidArgument("Format version '{}' is out of range", iter->second);
+    int parsed_version = 0;
+    const auto& val = iter->second;
+    auto [ptr, ec] = std::from_chars(val.data(), val.data() + val.size(), parsed_version);
+
+    if (ec == std::errc::invalid_argument) {
+      return InvalidArgument("Invalid format version '{}': not a valid integer", val);
+    } else if (ec == std::errc::result_out_of_range) {
+      return InvalidArgument("Format version '{}' is out of range", val);
     }
 
+    if (parsed_version > TableMetadata::kSupportedTableFormatVersion) {
+      return InvalidArgument(
+          "Cannot upgrade table to unsupported format version: v{} (supported: v{})",
+          parsed_version, TableMetadata::kSupportedTableFormatVersion);
+    }
+    format_version_ = static_cast<int8_t>(parsed_version);
+
     updates_.erase(iter);
   }
 

src/iceberg/update/update_properties.h

@@ -34,7 +34,7 @@ namespace iceberg {
 /// \brief Updates table properties.
 class ICEBERG_EXPORT UpdateProperties : public PendingUpdate {
  public:
-  static Result<std::unique_ptr<UpdateProperties>> Make(
+  static Result<std::shared_ptr<UpdateProperties>> Make(
       std::shared_ptr<Transaction> transaction);
 
   ~UpdateProperties() override;