feat: add rename table interface to catalog

src/iceberg/catalog.h

@@ -161,6 +161,15 @@ class ICEBERG_EXPORT Catalog {
   ///         - On failure, contains error information.
   virtual Status DropTable(const TableIdentifier& identifier, bool purge) = 0;
 
+  /// \brief Rename a table
+  ///
+  /// \param from the current table identifier
+  /// \param to the new table identifier
+  /// \return Status indicating the outcome of the operation.
+  ///         - On success, the table was renamed.
+  ///         - On failure, contains error information.
+  virtual Status RenameTable(const TableIdentifier& from, const TableIdentifier& to) = 0;
+
   /// \brief Load a table
   ///
   /// \param identifier a table identifier

src/iceberg/catalog/memory/in_memory_catalog.cc

@@ -415,6 +415,12 @@ Status InMemoryCatalog::DropTable(const TableIdentifier& identifier, bool purge)
   return root_namespace_->UnregisterTable(identifier);
 }
 
+Status InMemoryCatalog::RenameTable(const TableIdentifier& from,
+                                    const TableIdentifier& to) {
+  std::unique_lock lock(mutex_);
+  return NotImplemented("rename table");
+}
+
 Result<std::unique_ptr<Table>> InMemoryCatalog::LoadTable(
     const TableIdentifier& identifier) {
   if (!file_io_) [[unlikely]] {

src/iceberg/catalog/memory/in_memory_catalog.h

@@ -89,6 +89,8 @@ class ICEBERG_EXPORT InMemoryCatalog
 
   Status DropTable(const TableIdentifier& identifier, bool purge) override;
 
+  Status RenameTable(const TableIdentifier& from, const TableIdentifier& to) override;
+
   Result<std::unique_ptr<Table>> LoadTable(const TableIdentifier& identifier) override;
 
   Result<std::shared_ptr<Table>> RegisterTable(

src/iceberg/table.cc

@@ -133,6 +133,10 @@ const std::vector<SnapshotLogEntry>& Table::history() const {
   return metadata_->snapshot_log;
 }
 
+std::unique_ptr<Transaction> Table::NewTransaction() const {
+  throw NotImplemented("Table::NewTransaction is not implemented");
+}
+
 const std::shared_ptr<FileIO>& Table::io() const { return io_; }
 
 std::unique_ptr<TableScanBuilder> Table::NewScan() const {

src/iceberg/table.h

@@ -109,6 +109,11 @@ class ICEBERG_EXPORT Table {
   /// filter data.
   virtual std::unique_ptr<TableScanBuilder> NewScan() const;
 
+  /// \brief Create a new transaction for this table
+  ///
+  /// \return a pointer to the new Transaction
+  virtual std::unique_ptr<Transaction> NewTransaction() const;
+
   /// \brief Returns a FileIO to read and write table data and metadata files
   const std::shared_ptr<FileIO>& io() const;
 

src/iceberg/test/mock_catalog.h

@@ -75,6 +75,9 @@ class MockCatalog : public Catalog {
 
   MOCK_METHOD(Status, DropTable, (const TableIdentifier&, bool), (override));
 
+  MOCK_METHOD(Status, RenameTable, (const TableIdentifier&, const TableIdentifier&),
+              (override));
+
   MOCK_METHOD((Result<std::unique_ptr<Table>>), LoadTable, (const TableIdentifier&),
               (override));
 

src/iceberg/transaction.h

@@ -21,8 +21,10 @@
 #pragma once
 
 #include <memory>
+#include <vector>
 
 #include "iceberg/iceberg_export.h"
+#include "iceberg/result.h"
 #include "iceberg/type_fwd.h"
 
 namespace iceberg {
@@ -42,12 +44,23 @@ class ICEBERG_EXPORT Transaction {
   /// \return a new AppendFiles
   virtual std::shared_ptr<AppendFiles> NewAppend() = 0;
 
+  /// \brief Apply multiple metadata updates to this transaction
+  ///
+  /// \param requirements the table requirements to validate
+  /// \param updates the table updates to apply
+  /// \return Status::OK if all updates were queued successfully
+  virtual Status UpdateTable(
+      const std::vector<std::unique_ptr<TableRequirement>>& requirements,
+      const std::vector<std::unique_ptr<TableUpdate>>& updates) = 0;
+
   /// \brief Apply the pending changes from all actions and commit
   ///
-  /// May throw ValidationException if any update cannot be applied to the current table
-  /// metadata. May throw CommitFailedException if the updates cannot be committed due to
-  /// conflicts.
-  virtual void CommitTransaction() = 0;
+  /// This method applies all pending data operations and metadata updates in the
+  /// transaction and commits them to the table in a single atomic operation.
+  ///
+  /// \return Status::OK if the transaction was committed successfully, or an error
+  ///         status if validation failed or the commit encountered conflicts
+  virtual Status CommitTransaction() = 0;
 };
 
 }  // namespace iceberg