feat: static table metadata access support

Author: shuxu.li

src/iceberg/CMakeLists.txt

@@ -38,7 +38,7 @@ set(ICEBERG_SOURCES
     sort_field.cc
     sort_order.cc
     statistics_file.cc
-    table.cc
+    table_impl.cc
     table_metadata.cc
     transform.cc
     transform_function.cc

src/iceberg/table.h

@@ -19,17 +19,12 @@
 
 #pragma once
 
-#include <memory>
-#include <mutex>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "iceberg/iceberg_export.h"
-#include "iceberg/location_provider.h"
 #include "iceberg/result.h"
-#include "iceberg/table_scan.h"
-#include "iceberg/transaction.h"
 #include "iceberg/type_fwd.h"
 
 namespace iceberg {
@@ -92,10 +87,11 @@ class ICEBERG_EXPORT Table {
   /// \return a vector of history entries
   virtual const std::vector<std::shared_ptr<HistoryEntry>>& history() const = 0;
 
-  /// \brief Create a new table scan for this table
-  ///
-  /// Once a table scan is created, it can be refined to project columns and filter data.
-  virtual Result<std::unique_ptr<TableScan>> NewScan() const = 0;
+  // TODO(lishuxu): TableScan is not implemented yet, disable it for now.
+  // /// \brief Create a new table scan for this table
+  // ///
+  // /// Once a table scan is created, it can be refined to project columns and filter
+  // data. virtual Result<std::unique_ptr<TableScan>> NewScan() const = 0;
 
   /// \brief Create a new append API to add files to this table and commit
   virtual Result<std::shared_ptr<AppendFiles>> NewAppend() = 0;
@@ -112,100 +108,4 @@ class ICEBERG_EXPORT Table {
   virtual Result<std::unique_ptr<LocationProvider>> location_provider() const = 0;
 };
 
-/// \brief An abstract base implementation of the Iceberg Table interface.
-///
-/// BaseTable provides common functionality for Iceberg table implementations,
-/// including lazy initialization of schema, partition specs, sort orders,
-/// and snapshot metadata.
-///
-/// This class is not intended to be used directly by users, but serves as a foundation
-/// for concrete implementations such as StaticTable or CatalogTable.
-class ICEBERG_EXPORT BaseTable : public Table {
- public:
-  ~BaseTable() override = default;
-
-  BaseTable(std::string name, std::shared_ptr<TableMetadata> metadata);
-
-  const std::string& name() const override { return name_; }
-
-  const std::string& uuid() const override;
-
-  Result<std::shared_ptr<Schema>> schema() const override;
-
-  const std::unordered_map<int32_t, std::shared_ptr<Schema>>& schemas() const override;
-
-  Result<std::shared_ptr<PartitionSpec>> spec() const override;
-
-  const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>& specs()
-      const override;
-
-  Result<std::shared_ptr<SortOrder>> sort_order() const override;
-
-  const std::unordered_map<int32_t, std::shared_ptr<SortOrder>>& sort_orders()
-      const override;
-
-  const std::unordered_map<std::string, std::string>& properties() const override;
-
-  const std::string& location() const override;
-
-  Result<std::shared_ptr<Snapshot>> current_snapshot() const override;
-
-  Result<std::shared_ptr<Snapshot>> snapshot(int64_t snapshot_id) const override;
-
-  const std::vector<std::shared_ptr<Snapshot>>& snapshots() const override;
-
-  const std::vector<std::shared_ptr<HistoryEntry>>& history() const override;
-
- private:
-  void InitSchema() const;
-  void InitPartitionSpec() const;
-  void InitSortOrder() const;
-  void InitSnapshot() const;
-
-  const std::string name_;
-
-  mutable std::shared_ptr<Schema> schema_;
-  mutable std::unordered_map<int32_t, std::shared_ptr<Schema>> schemas_map_;
-
-  mutable std::shared_ptr<PartitionSpec> partition_spec_;
-  mutable std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>> partition_spec_map_;
-
-  mutable std::shared_ptr<SortOrder> sort_order_;
-  mutable std::unordered_map<int32_t, std::shared_ptr<SortOrder>> sort_orders_map_;
-
-  mutable std::shared_ptr<Snapshot> current_snapshot_;
-  mutable std::unordered_map<int64_t, std::shared_ptr<Snapshot>> snapshots_map_;
-
-  mutable std::vector<std::shared_ptr<HistoryEntry>> history_;
-
-  std::shared_ptr<TableMetadata> metadata_;
-
-  // once_flags
-  mutable std::once_flag init_schema_once_;
-  mutable std::once_flag init_partition_spec_once_;
-  mutable std::once_flag init_sort_order_once_;
-  mutable std::once_flag init_snapshot_once_;
-};
-
-/// \brief A read-only implementation of an Iceberg table.
-///
-/// StaticTable represents a snapshot of a table that does not support mutation.
-class ICEBERG_EXPORT StaticTable : public BaseTable {
- public:
-  ~StaticTable() override = default;
-
-  StaticTable(std::string name, std::shared_ptr<TableMetadata> metadata)
-      : BaseTable(std::move(name), std::move(metadata)) {}
-
-  Status Refresh() override;
-
-  Result<std::unique_ptr<TableScan>> NewScan() const override;
-
-  Result<std::shared_ptr<AppendFiles>> NewAppend() override;
-
-  Result<std::unique_ptr<Transaction>> NewTransaction() override;
-
-  Result<std::unique_ptr<LocationProvider>> location_provider() const override;
-};
-
 }  // namespace iceberg

src/iceberg/table.cc renamed to src/iceberg/table_impl.cc

@@ -17,13 +17,9 @@
  * under the License.
  */
 
-#include "iceberg/table.h"
+#include "iceberg/table_impl.h"
 
-#include <iostream>
-
-#include "iceberg/exception.h"
 #include "iceberg/partition_spec.h"
-#include "iceberg/result.h"
 #include "iceberg/schema.h"
 #include "iceberg/snapshot.h"
 #include "iceberg/sort_order.h"
@@ -160,10 +156,6 @@ Status StaticTable::Refresh() {
   return NotSupported("Refresh is not supported for StaticTable");
 }
 
-Result<std::unique_ptr<TableScan>> StaticTable::NewScan() const {
-  return NotSupported("NewScan is not supported for StaticTable");
-}
-
 Result<std::shared_ptr<AppendFiles>> StaticTable::NewAppend() {
   return NotSupported("NewAppend is not supported for StaticTable");
 }

src/iceberg/table_impl.h

@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "iceberg/iceberg_export.h"
+#include "iceberg/location_provider.h"
+#include "iceberg/result.h"
+#include "iceberg/table.h"
+#include "iceberg/transaction.h"
+#include "iceberg/type_fwd.h"
+
+namespace iceberg {
+
+/// \brief An abstract base implementation of the Iceberg Table interface.
+///
+/// BaseTable provides common functionality for Iceberg table implementations,
+/// including lazy initialization of schema, partition specs, sort orders,
+/// and snapshot metadata.
+///
+/// This class is not intended to be used directly by users, but serves as a foundation
+/// for concrete implementations such as StaticTable or CatalogTable.
+class ICEBERG_EXPORT BaseTable : public Table {
+ public:
+  ~BaseTable() override = default;
+
+  BaseTable(std::string name, std::shared_ptr<TableMetadata> metadata);
+
+  const std::string& name() const override { return name_; }
+
+  const std::string& uuid() const override;
+
+  Result<std::shared_ptr<Schema>> schema() const override;
+
+  const std::unordered_map<int32_t, std::shared_ptr<Schema>>& schemas() const override;
+
+  Result<std::shared_ptr<PartitionSpec>> spec() const override;
+
+  const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>& specs()
+      const override;
+
+  Result<std::shared_ptr<SortOrder>> sort_order() const override;
+
+  const std::unordered_map<int32_t, std::shared_ptr<SortOrder>>& sort_orders()
+      const override;
+
+  const std::unordered_map<std::string, std::string>& properties() const override;
+
+  const std::string& location() const override;
+
+  Result<std::shared_ptr<Snapshot>> current_snapshot() const override;
+
+  Result<std::shared_ptr<Snapshot>> snapshot(int64_t snapshot_id) const override;
+
+  const std::vector<std::shared_ptr<Snapshot>>& snapshots() const override;
+
+  const std::vector<std::shared_ptr<HistoryEntry>>& history() const override;
+
+ private:
+  void InitSchema() const;
+  void InitPartitionSpec() const;
+  void InitSortOrder() const;
+  void InitSnapshot() const;
+
+  const std::string name_;
+
+  mutable std::shared_ptr<Schema> schema_;
+  mutable std::unordered_map<int32_t, std::shared_ptr<Schema>> schemas_map_;
+
+  mutable std::shared_ptr<PartitionSpec> partition_spec_;
+  mutable std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>> partition_spec_map_;
+
+  mutable std::shared_ptr<SortOrder> sort_order_;
+  mutable std::unordered_map<int32_t, std::shared_ptr<SortOrder>> sort_orders_map_;
+
+  mutable std::shared_ptr<Snapshot> current_snapshot_;
+  mutable std::unordered_map<int64_t, std::shared_ptr<Snapshot>> snapshots_map_;
+
+  mutable std::vector<std::shared_ptr<HistoryEntry>> history_;
+
+  std::shared_ptr<TableMetadata> metadata_;
+
+  // once_flags
+  mutable std::once_flag init_schema_once_;
+  mutable std::once_flag init_partition_spec_once_;
+  mutable std::once_flag init_sort_order_once_;
+  mutable std::once_flag init_snapshot_once_;
+};
+
+/// \brief A read-only implementation of an Iceberg table.
+///
+/// StaticTable represents a snapshot of a table that does not support mutation.
+class ICEBERG_EXPORT StaticTable : public BaseTable {
+ public:
+  ~StaticTable() override = default;
+
+  StaticTable(std::string name, std::shared_ptr<TableMetadata> metadata)
+      : BaseTable(std::move(name), std::move(metadata)) {}
+
+  Status Refresh() override;
+
+  Result<std::shared_ptr<AppendFiles>> NewAppend() override;
+
+  Result<std::unique_ptr<Transaction>> NewTransaction() override;
+
+  Result<std::unique_ptr<LocationProvider>> location_provider() const override;
+};
+
+}  // namespace iceberg

src/iceberg/table_scan.h

@@ -50,8 +50,7 @@ class MetadataSerdeTest : public ::testing::Test {
 
 TEST_F(MetadataSerdeTest, DeserializeV1Valid) {
   std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(
-      test::ReadTableMetadata("TableMetadataV1Valid.json", &metadata));
+  ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV1Valid.json", &metadata));
 
   EXPECT_EQ(metadata->format_version, 1);
   EXPECT_EQ(metadata->table_uuid, "d20125c8-7284-442c-9aea-15fee620737c");
@@ -84,12 +83,13 @@ TEST_F(MetadataSerdeTest, DeserializeV1Valid) {
   auto partition_spec = metadata->PartitionSpec();
   ASSERT_TRUE(partition_spec.has_value());
   EXPECT_EQ(*(partition_spec.value().get()), *expected_spec);
+  auto snapshot = metadata->Snapshot();
+  ASSERT_FALSE(snapshot.has_value());
 }
 
 TEST_F(MetadataSerdeTest, DeserializeV2Valid) {
   std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(
-      test::ReadTableMetadata("TableMetadataV2Valid.json", &metadata));
+  ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV2Valid.json", &metadata));
 
   EXPECT_EQ(metadata->format_version, 2);
   EXPECT_EQ(metadata->table_uuid, "9c12d441-03fe-4693-9a96-a0705ddf69c1");
@@ -136,7 +136,11 @@ TEST_F(MetadataSerdeTest, DeserializeV2Valid) {
   ASSERT_TRUE(sort_order.has_value());
   EXPECT_EQ(*(sort_order.value().get()), *expected_sort_order);
 
+  // Compare snapshot
   EXPECT_EQ(metadata->current_snapshot_id, 3055729675574597004);
+  auto snapshot = metadata->Snapshot();
+  ASSERT_TRUE(snapshot.has_value());
+  EXPECT_EQ(snapshot.value()->snapshot_id, 3055729675574597004);
 
   // Compare snapshots
   std::vector<Snapshot> expected_snapshots{