fix some comments

Author: WZhuo

src/iceberg/catalog/memory/in_memory_catalog.cc

@@ -29,6 +29,7 @@
 #include "iceberg/table_requirements.h"
 #include "iceberg/table_update.h"
 #include "iceberg/transaction.h"
+#include "iceberg/util/checked_cast.h"
 #include "iceberg/util/macros.h"
 
 namespace iceberg {
@@ -423,8 +424,7 @@ Result<std::shared_ptr<Table>> InMemoryCatalog::CreateTable(
   ICEBERG_RETURN_UNEXPECTED(
       root_namespace_->UpdateTableMetadataLocation(identifier, metadata_file_location));
   return Table::Make(identifier, std::move(table_metadata),
-                     std::move(metadata_file_location), file_io_,
-                     std::static_pointer_cast<Catalog>(shared_from_this()));
+                     std::move(metadata_file_location), file_io_, shared_from_this());
 }
 
 Result<std::shared_ptr<Table>> InMemoryCatalog::UpdateTable(
@@ -444,7 +444,8 @@ Result<std::shared_ptr<Table>> InMemoryCatalog::UpdateTable(
     for (const auto& update : updates) {
       if (update->kind() == TableUpdate::Kind::kUpgradeFormatVersion) {
         format_version =
-            dynamic_cast<const table::UpgradeFormatVersion&>(*update).format_version();
+            internal::checked_cast<const table::UpgradeFormatVersion&>(*update)
+                .format_version();
       }
     }
     builder = TableMetadataBuilder::BuildFromEmpty(format_version);
@@ -496,7 +497,8 @@ Result<std::shared_ptr<Transaction>> InMemoryCatalog::StageCreateTable(
   ICEBERG_ASSIGN_OR_RAISE(
       auto table, StagedTable::Make(identifier, std::move(table_metadata), "", file_io_,
                                     shared_from_this()));
-  return Transaction::Make(std::move(table), Transaction::Kind::kCreate, false);
+  return Transaction::Make(std::move(table), Transaction::Kind::kCreate,
+                           /* auto_commit */ false);
 }
 
 Result<bool> InMemoryCatalog::TableExists(const TableIdentifier& identifier) const {

src/iceberg/table_identifier.cc

@@ -26,7 +26,11 @@ namespace iceberg {
 std::string Namespace::ToString() const { return FormatRange(levels, ".", "", ""); }
 
 std::string TableIdentifier::ToString() const {
-  return std::format("{}.{}", ns.ToString(), name);
+  if (!ns.levels.empty()) {
+    return std::format("{}.{}", ns.ToString(), name);
+  } else {
+    return name;
+  }
 }
 
 }  // namespace iceberg

src/iceberg/table_metadata.cc

@@ -1099,18 +1099,18 @@ std::unique_ptr<TableMetadataBuilder> TableMetadataBuilder::BuildFromEmpty(
 }
 
 std::unique_ptr<TableMetadataBuilder> TableMetadataBuilder::BuildFrom(
-    const TableMetadata* base, bool is_create) {
-  if (is_create) {
-    ICEBERG_DCHECK(base != nullptr, "base should not be nullptr if is_create is true");
-    auto builder = BuildFromEmpty();
-    for (auto& change : base->ChangesForCreate()) {
-      change->ApplyTo(*builder);
-    }
-    return builder;
-  }
+    const TableMetadata* base) {
   return std::unique_ptr<TableMetadataBuilder>(new TableMetadataBuilder(base));  // NOLINT
 }
 
+TableMetadataBuilder& TableMetadataBuilder::ApplyChangesForCreate(
+    const TableMetadata& base) {
+  for (auto& change : base.ChangesForCreate()) {
+    change->ApplyTo(*this);
+  }
+  return *this;
+}
+
 TableMetadataBuilder& TableMetadataBuilder::SetMetadataLocation(
     std::string_view metadata_location) {
   impl_->SetMetadataLocation(metadata_location);

src/iceberg/table_metadata.h

@@ -219,13 +219,15 @@ class ICEBERG_EXPORT TableMetadataBuilder : public ErrorCollector {
   /// \brief Create a builder from existing table metadata
   ///
   /// \param base The base table metadata to build from
-  /// \param is_create Whether the builder is for creating a new table. It will call
-  /// `BuildFromEmpty` and set changes to make the tablemetadata but not copy the base
-  /// metadata directly if true.
   /// \return A new TableMetadataBuilder instance initialized
   /// with base metadata
-  static std::unique_ptr<TableMetadataBuilder> BuildFrom(const TableMetadata* base,
-                                                         bool is_create = false);
+  static std::unique_ptr<TableMetadataBuilder> BuildFrom(const TableMetadata* base);
+
+  /// \brief Apply changes required to create this table metadata
+  ///
+  /// \param base The table metadata to build from
+  /// \return Reference to this builder for method chaining
+  TableMetadataBuilder& ApplyChangesForCreate(const TableMetadata& base);
 
   /// \brief Set the metadata location of the table
   ///

src/iceberg/test/formatter_test.cc

@@ -167,7 +167,7 @@ TEST(FormatterTest, TableIdentifierFormat) {
       .ns = Namespace({}),
       .name = "table_name",
   };
-  EXPECT_EQ(".table_name", std::format("{}", empty_ns_table));
+  EXPECT_EQ("table_name", std::format("{}", empty_ns_table));
 
   TableIdentifier table{
       .ns = Namespace({"ns1", "ns2"}),

src/iceberg/transaction.cc

@@ -36,12 +36,12 @@
 
 namespace iceberg {
 
-Transaction::Transaction(std::shared_ptr<Table> table, Kind kind, bool auto_commit)
+Transaction::Transaction(std::shared_ptr<Table> table, Kind kind, bool auto_commit,
+                         std::unique_ptr<TableMetadataBuilder> metadata_builder)
     : table_(std::move(table)),
+      metadata_builder_(std::move(metadata_builder)),
       kind_(kind),
-      auto_commit_(auto_commit),
-      metadata_builder_(TableMetadataBuilder::BuildFrom(table_->metadata().get(),
-                                                        kind == Kind::kCreate)) {}
+      auto_commit_(auto_commit) {}
 
 Transaction::~Transaction() = default;
 
@@ -50,8 +50,17 @@ Result<std::shared_ptr<Transaction>> Transaction::Make(std::shared_ptr<Table> ta
   if (!table || !table->catalog()) [[unlikely]] {
     return InvalidArgument("Table and catalog cannot be null");
   }
+
+  std::unique_ptr<TableMetadataBuilder> metadata_builder;
+  if (kind == Kind::kCreate) {
+    metadata_builder = TableMetadataBuilder::BuildFromEmpty();
+    std::ignore = metadata_builder->ApplyChangesForCreate(*table->metadata());
+  } else {
+    metadata_builder = TableMetadataBuilder::BuildFrom(table->metadata().get());
+  }
+
   return std::shared_ptr<Transaction>(
-      new Transaction(std::move(table), kind, auto_commit));
+      new Transaction(std::move(table), kind, auto_commit, std::move(metadata_builder)));
 }
 
 const TableMetadata* Transaction::base() const { return metadata_builder_->base(); }

src/iceberg/transaction.h

@@ -69,7 +69,8 @@ class ICEBERG_EXPORT Transaction : public std::enable_shared_from_this<Transacti
   Result<std::shared_ptr<UpdateSortOrder>> NewUpdateSortOrder();
 
  private:
-  Transaction(std::shared_ptr<Table> table, Kind kind, bool auto_commit);
+  Transaction(std::shared_ptr<Table> table, Kind kind, bool auto_commit,
+              std::unique_ptr<TableMetadataBuilder> metadata_builder);
 
   Status AddUpdate(const std::shared_ptr<PendingUpdate>& update);