Update MetadataTable to inherit from StaticTable

Author: All-less

src/iceberg/inspect/history_table.cc

@@ -31,20 +31,19 @@
 namespace iceberg {
 
 HistoryTable::HistoryTable(std::shared_ptr<Table> table)
-    : BaseMetadataTable(table, CreateName(table->name()), CreateSchema()) {}
-
-HistoryTable::~HistoryTable() = default;
-
-std::shared_ptr<Schema> HistoryTable::CreateSchema() {
-  return std::make_shared<Schema>(
+    : MetadataTable(table, CreateName(table->name())) {
+  this->schema_ = std::make_shared<Schema>(
       std::vector<SchemaField>{
-          SchemaField::MakeRequired(1, "made_current_at", int64()),
+          SchemaField::MakeRequired(1, "made_current_at", timestamp_tz()),
           SchemaField::MakeRequired(2, "snapshot_id", int64()),
           SchemaField::MakeOptional(3, "parent_id", int64()),
           SchemaField::MakeRequired(4, "is_current_ancestor", boolean())},
       1);
+  this->schemas_[schema_->schema_id()] = schema_;
 }
 
+HistoryTable::~HistoryTable() = default;
+
 TableIdentifier HistoryTable::CreateName(const TableIdentifier& source_name) {
   return TableIdentifier{source_name.ns, source_name.name + ".history"};
 }

src/iceberg/inspect/history_table.h

@@ -36,7 +36,7 @@ namespace iceberg {
 /// - snapshot_id (long)
 /// - parent_id (long, optional)
 /// - is_current_ancestor (bool)
-class ICEBERG_EXPORT HistoryTable : public BaseMetadataTable {
+class ICEBERG_EXPORT HistoryTable : public MetadataTable {
  public:
   /// \brief Create a HistoryTable from table metadata
   ///
@@ -46,8 +46,10 @@ class ICEBERG_EXPORT HistoryTable : public BaseMetadataTable {
 
   ~HistoryTable() override;
 
+  MetadataTableType type() const noexcept override { return MetadataTableType::kHistory; }
+
  private:
-  HistoryTable(std::shared_ptr<Table> table);
+  explicit HistoryTable(std::shared_ptr<Table> table);
 
   std::shared_ptr<Schema> CreateSchema();
 

src/iceberg/inspect/metadata_table.cc

@@ -24,64 +24,44 @@
 #include <utility>
 
 #include "iceberg/file_io.h"
+#include "iceberg/inspect/history_table.h"
+#include "iceberg/inspect/snapshots_table.h"
 #include "iceberg/schema.h"
 #include "iceberg/schema_field.h"
 #include "iceberg/table_identifier.h"
 #include "iceberg/table_metadata.h"
 #include "iceberg/table_scan.h"
 #include "iceberg/type.h"
+#include "iceberg/type_fwd.h"
 #include "iceberg/util/uuid.h"
 
 namespace iceberg {
 
-BaseMetadataTable::BaseMetadataTable(std::shared_ptr<Table> source_table,
-                                     TableIdentifier identifier,
-                                     std::shared_ptr<Schema> schema)
-    : Table(identifier, source_table->metadata(),
-            std::string(source_table->metadata_file_location()), source_table->io(),
-            source_table->catalog()),
-      source_table_(std::move(source_table)),
-      schema_(schema) {
+MetadataTable::MetadataTable(std::shared_ptr<Table> source_table,
+                             TableIdentifier identifier)
+    : StaticTable(identifier, source_table->metadata(),
+                  std::string(source_table->metadata_file_location()), source_table->io(),
+                  source_table->catalog()),
+      source_table_(std::move(source_table)) {
   uuid_ = Uuid::GenerateV4().ToString();
-  schemas_[schema->schema_id()] = schema;
 }
 
-BaseMetadataTable::~BaseMetadataTable() = default;
+MetadataTable::~MetadataTable() = default;
 
-Status BaseMetadataTable::Refresh() {
-  return NotSupported("Cannot refresh a metadata table");
-}
+Status MetadataTable::Refresh() { return source_table_->Refresh(); }
 
-Result<std::unique_ptr<TableScanBuilder>> BaseMetadataTable::NewScan() const {
+Result<std::unique_ptr<TableScanBuilder>> MetadataTable::NewScan() const {
   return NotSupported("TODO: Scanning metadata tables is not yet supported");
 };
 
-Result<std::shared_ptr<Transaction>> BaseMetadataTable::NewTransaction() {
-  return NotSupported("Cannot create a transaction for a metadata table");
-}
-
-Result<std::shared_ptr<UpdateProperties>> BaseMetadataTable::NewUpdateProperties() {
-  return NotSupported("Cannot create an update properties for a metadata table");
-}
-
-Result<std::shared_ptr<UpdateSchema>> BaseMetadataTable::NewUpdateSchema() {
-  return NotSupported("Cannot create an update schema for a metadata table");
-}
-
-Result<std::shared_ptr<UpdateLocation>> BaseMetadataTable::NewUpdateLocation() {
-  return NotSupported("Cannot create an update location for a metadata table");
-}
-
-Result<std::shared_ptr<UpdatePartitionSpec>> BaseMetadataTable::NewUpdatePartitionSpec() {
-  return NotSupported("Cannot create an update partition spec for a metadata table");
-}
-
-Result<std::shared_ptr<UpdateSortOrder>> BaseMetadataTable::NewUpdateSortOrder() {
-  return NotSupported("Cannot create an update sort order for a metadata table");
+Result<std::shared_ptr<SnapshotsTable>> MetadataTableFactory::GetSnapshotsTable(
+    std::shared_ptr<Table> table) {
+  return SnapshotsTable::Make(table);
 }
 
-Result<std::shared_ptr<ExpireSnapshots>> BaseMetadataTable::NewExpireSnapshots() {
-  return NotSupported("Cannot create an expire snapshots for a metadata table");
+Result<std::shared_ptr<HistoryTable>> MetadataTableFactory::GetHistoryTable(
+    std::shared_ptr<Table> table) {
+  return HistoryTable::Make(table);
 }
 
 }  // namespace iceberg

src/iceberg/inspect/metadata_table.h

@@ -29,20 +29,26 @@
 #include "iceberg/table.h"
 #include "iceberg/table_metadata.h"
 #include "iceberg/table_scan.h"
+#include "iceberg/type_fwd.h"
 
 namespace iceberg {
 
-/// Forward declarations
-class FileIO;
+/// \brief The type of metadata table
+enum class MetadataTableType {
+  kSnapshots,
+  kHistory,
+};
 
 /// \brief Base class for Iceberg metadata tables
 ///
 /// Metadata tables expose table metadata as queryable tables with schemas and scan
 /// support. They provide read-only access to metadata.
-class ICEBERG_EXPORT BaseMetadataTable : public Table {
+class ICEBERG_EXPORT MetadataTable : public StaticTable {
  public:
   /// \brief Returns the identifier of this table
-  const TableIdentifier& name() const { return identifier_; }
+  const TableIdentifier& name() const override { return identifier_; }
+
+  virtual MetadataTableType type() const noexcept = 0;
 
   /// \brief Returns the UUID of the table
   const std::string& uuid() const { return uuid_; }
@@ -137,32 +143,10 @@ class ICEBERG_EXPORT BaseMetadataTable : public Table {
   /// filter data.
   Result<std::unique_ptr<TableScanBuilder>> NewScan() const;
 
-  /// \brief Creating transactions is not supported in metadata tables.
-  Result<std::shared_ptr<Transaction>> NewTransaction() override;
-
-  /// \brief Updating partition specs is not supported in metadata tables.
-  Result<std::shared_ptr<UpdatePartitionSpec>> NewUpdatePartitionSpec() override;
-
-  /// \brief Updating table properties is not supported in metadata tables.
-  Result<std::shared_ptr<UpdateProperties>> NewUpdateProperties() override;
-
-  /// \brief Updating sort orders is not supported in metadata tables.
-  Result<std::shared_ptr<UpdateSortOrder>> NewUpdateSortOrder() override;
-
-  /// \brief Updating schemas is not supported in metadata tables.
-  Result<std::shared_ptr<UpdateSchema>> NewUpdateSchema() override;
-
-  /// \brief Expiring snapshots is not supported in metadata tables.
-  Result<std::shared_ptr<ExpireSnapshots>> NewExpireSnapshots() override;
-
-  /// \brief Updating table location is not supported in metadata tables.
-  Result<std::shared_ptr<UpdateLocation>> NewUpdateLocation() override;
-
  protected:
-  BaseMetadataTable(std::shared_ptr<Table> source_table, TableIdentifier identifier,
-                    std::shared_ptr<Schema> schema);
+  explicit MetadataTable(std::shared_ptr<Table> source_table, TableIdentifier identifier);
 
-  virtual ~BaseMetadataTable();
+  ~MetadataTable();
 
   std::shared_ptr<Table> source_table_;
   std::string uuid_;
@@ -177,4 +161,31 @@ class ICEBERG_EXPORT BaseMetadataTable : public Table {
       {partition_spec->spec_id(), partition_spec}};
 };
 
+/// \brief Metadata table factory and inspector
+///
+/// MetadataTable provides factory methods to create specific metadata tables for
+/// inspecting table metadata. Each metadata table exposes a different aspect of the
+/// table's metadata as a scannable Iceberg table.
+///
+/// Usage:
+///   auto snapshots = ICEBERG_TRY(MetadataTable::GetSnapshotsTable(table));
+///   auto scan = ICEBERG_TRY(snapshots->NewScan());
+///   // ... scan and read snapshot data
+class ICEBERG_EXPORT MetadataTableFactory {
+ public:
+  /// \brief Create a SnapshotsTable from a table
+  ///
+  /// \param table The source table
+  /// \return A SnapshotsTable exposing all snapshots or error status
+  static Result<std::shared_ptr<SnapshotsTable>> GetSnapshotsTable(
+      std::shared_ptr<Table> table);
+
+  /// \brief Create a HistoryTable from a table
+  ///
+  /// \param table The source table
+  /// \return A HistoryTable exposing snapshot history or error status
+  static Result<std::shared_ptr<HistoryTable>> GetHistoryTable(
+      std::shared_ptr<Table> table);
+};
+
 }  // namespace iceberg

src/iceberg/inspect/metadata_table_factory.cc

@@ -31,24 +31,25 @@
 namespace iceberg {
 
 SnapshotsTable::SnapshotsTable(std::shared_ptr<Table> table)
-    : BaseMetadataTable(table, CreateName(table->name()), CreateSchema()) {}
-
-SnapshotsTable::~SnapshotsTable() = default;
-
-std::shared_ptr<Schema> SnapshotsTable::CreateSchema() {
-  return std::make_shared<Schema>(
-      std::vector<SchemaField>{SchemaField::MakeRequired(1, "committed_at", int64()),
-                               SchemaField::MakeOptional(2, "snapshot_id", int64()),
-                               SchemaField::MakeRequired(3, "parent_id", int64()),
-                               SchemaField::MakeRequired(4, "manifest_list", string()),
-                               SchemaField::MakeRequired(
-                                   5, "summary",
-                                   std::make_shared<iceberg::MapType>(
-                                       SchemaField::MakeRequired(6, "key", string()),
-                                       SchemaField::MakeRequired(7, "value", string())))},
+    : MetadataTable(table, CreateName(table->name())) {
+  this->schema_ = std::make_shared<Schema>(
+      std::vector<SchemaField>{
+          SchemaField::MakeRequired(1, "committed_at", timestamp_tz()),
+          SchemaField::MakeRequired(2, "snapshot_id", int64()),
+          SchemaField::MakeRequired(3, "parent_id", int64()),
+          SchemaField::MakeOptional(4, "operation", int64()),
+          SchemaField::MakeOptional(5, "manifest_list", string()),
+          SchemaField::MakeOptional(
+              6, "summary",
+              std::make_shared<iceberg::MapType>(
+                  SchemaField::MakeRequired(7, "key", string()),
+                  SchemaField::MakeRequired(8, "value", string())))},
       1);
+  this->schemas_[schema_->schema_id()] = schema_;
 }
 
+SnapshotsTable::~SnapshotsTable() = default;
+
 TableIdentifier SnapshotsTable::CreateName(const TableIdentifier& source_name) {
   return TableIdentifier{source_name.ns, source_name.name + ".snapshots"};
 }

src/iceberg/inspect/metadata_table_factory.h

@@ -36,7 +36,7 @@ namespace iceberg {
 /// - parent_id (long)
 /// - manifest_list (string)
 /// - summary (map<string, string>)
-class ICEBERG_EXPORT SnapshotsTable : public BaseMetadataTable {
+class ICEBERG_EXPORT SnapshotsTable : public MetadataTable {
  public:
   /// \brief Create a SnapshotsTable from table metadata
   ///
@@ -46,8 +46,12 @@ class ICEBERG_EXPORT SnapshotsTable : public BaseMetadataTable {
 
   ~SnapshotsTable() override;
 
+  MetadataTableType type() const noexcept override {
+    return MetadataTableType::kSnapshots;
+  }
+
  private:
-  SnapshotsTable(std::shared_ptr<Table> table);
+  explicit SnapshotsTable(std::shared_ptr<Table> table);
 
   std::shared_ptr<Schema> CreateSchema();