@@ -35,6 +35,23 @@ MetadataTable::MetadataTable(std::shared_ptr<Table> source_table,
 
 MetadataTable::~MetadataTable() = default;
 
+bool MetadataTable::supports_time_travel() const noexcept {
+  // Time travel is supported for tables that read from a single snapshot's
+  // manifests. Tables that scan all snapshots or return in-memory history do
+  // not.
+  switch (kind()) {
+    case Kind::kSnapshots:
+    case Kind::kHistory:
+      return false;
+  }
+  return false;
+}
+
+Result<ArrowArray> MetadataTable::Scan(
+    std::optional<SnapshotSelection> /*snapshot_selection*/) {
+  return NotSupported("Scan is not supported for this metadata table type");
+}
+
 Result<std::unique_ptr<MetadataTable>> MetadataTable::Make(std::shared_ptr<Table> table,
                                                            Kind kind) {
   if (table == nullptr) [[unlikely]] {
 
@@ -20,14 +20,28 @@
 #pragma once
 
 #include <memory>
+#include <optional>
+#include <string>
 
+#include "iceberg/arrow_c_data.h"
 #include "iceberg/iceberg_export.h"
 #include "iceberg/result.h"
 #include "iceberg/table_identifier.h"
 #include "iceberg/type_fwd.h"
+#include "iceberg/util/timepoint.h"
 
 namespace iceberg {
 
+/// \brief Parameters for snapshot selection (time travel).
+struct SnapshotSelection {
+  /// \brief The snapshot ID to read.
+  std::optional<int64_t> snapshot_id;
+  /// \brief Read the snapshot that was current at this timestamp.
+  std::optional<TimePointMs> as_of_timestamp;
+  /// \brief Read the snapshot referenced by this named ref (branch or tag).
+  std::optional<std::string> ref_name;
+};
+
 /// \brief Base class for Iceberg metadata tables.
 class ICEBERG_EXPORT MetadataTable {
  public:
@@ -43,6 +57,28 @@ class ICEBERG_EXPORT MetadataTable {
 
   virtual Kind kind() const noexcept = 0;
 
+  /// \brief Whether this metadata table supports time-travel queries.
+  ///
+  /// Time travel is supported for tables that read from a single snapshot's
+  /// manifests (e.g., Entries, Files, Manifests, Partitions). Tables that
+  /// scan all snapshots (All*) or return in-memory history (Snapshots,
+  /// History, Refs) do not support time travel.
+  bool supports_time_travel() const noexcept;
+
+  /// \brief Scan the metadata table using the current snapshot.
+  ///
+  /// Convenience overload — delegates to Scan(std::nullopt).
+  Result<ArrowArray> Scan() { return Scan(std::nullopt); }
+
+  /// \brief Scan the metadata table and return all rows as an Arrow struct array.
+  ///
+  /// The returned ArrowArray is a struct array where each element is one row.
+  /// The caller takes ownership and must call ArrowArrayRelease when done.
+  ///
+  /// The default implementation returns NotSupported. Subclasses override this
+  /// to materialize their data.
+  virtual Result<ArrowArray> Scan(std::optional<SnapshotSelection> snapshot_selection);
+
   const TableIdentifier& name() const { return identifier_; }
 
   const std::shared_ptr<Schema>& schema() const { return schema_; }
 
@@ -19,15 +19,18 @@
 
 #include "iceberg/inspect/snapshots_table.h"
 
+#include <chrono>
 #include <memory>
 #include <utility>
 #include <vector>
 
+#include "iceberg/arrow_row_builder_internal.h"
 #include "iceberg/schema.h"
 #include "iceberg/schema_field.h"
 #include "iceberg/table.h"
 #include "iceberg/table_identifier.h"
 #include "iceberg/type.h"
+#include "iceberg/util/macros.h"
 
 namespace iceberg {
 namespace {
@@ -65,4 +68,46 @@ Result<std::unique_ptr<SnapshotsTable>> SnapshotsTable::Make(
   return std::unique_ptr<SnapshotsTable>(new SnapshotsTable(std::move(table)));
 }
 
+Result<ArrowArray> SnapshotsTable::Scan(
+    std::optional<SnapshotSelection> /*snapshot_selection*/) {
+  ICEBERG_ASSIGN_OR_RAISE(auto builder, ArrowRowBuilder::Make(*schema()));
+
+  for (const auto& snapshot : source_table()->snapshots()) {
+    // column 0: committed_at (timestamptz → int64 micros)
+    ICEBERG_RETURN_UNEXPECTED(AppendInt(
+        builder.column(0), std::chrono::duration_cast<std::chrono::microseconds>(
+                               snapshot->timestamp_ms.time_since_epoch())
+                               .count()));
+
+    // column 1: snapshot_id (long)
+    ICEBERG_RETURN_UNEXPECTED(AppendInt(builder.column(1), snapshot->snapshot_id));
+
+    // column 2: parent_id (long, optional)
+    if (snapshot->parent_snapshot_id.has_value()) {
+      ICEBERG_RETURN_UNEXPECTED(
+          AppendInt(builder.column(2), *snapshot->parent_snapshot_id));
+    } else {
+      ICEBERG_RETURN_UNEXPECTED(AppendNull(builder.column(2)));
+    }
+
+    // column 3: operation (string, optional)
+    auto op = snapshot->Operation();
+    if (op.has_value()) {
+      ICEBERG_RETURN_UNEXPECTED(AppendString(builder.column(3), *op));
+    } else {
+      ICEBERG_RETURN_UNEXPECTED(AppendNull(builder.column(3)));
+    }
+
+    // column 4: manifest_list (string, optional)
+    ICEBERG_RETURN_UNEXPECTED(AppendString(builder.column(4), snapshot->manifest_list));
+
+    // column 5: summary (map<string,string>)
+    ICEBERG_RETURN_UNEXPECTED(AppendStringMap(builder.column(5), snapshot->summary));
+
+    ICEBERG_RETURN_UNEXPECTED(builder.FinishRow());
+  }
+
+  return std::move(builder).Finish();
+}
+
 }  // namespace iceberg
@@ -37,6 +37,13 @@ class ICEBERG_EXPORT SnapshotsTable : public MetadataTable {
 
   Kind kind() const noexcept override { return Kind::kSnapshots; }
 
+  /// \brief Scan all snapshots as rows.
+  ///
+  /// The snapshots table always returns every known snapshot, so the
+  /// snapshot_selection parameter is ignored.
+  Result<ArrowArray> Scan(
+      std::optional<SnapshotSelection> /*snapshot_selection*/) override;
+
  private:
   explicit SnapshotsTable(std::shared_ptr<Table> table);
 };
 
@@ -188,7 +188,11 @@ if(ICEBERG_BUILD_BUNDLE)
 
   add_iceberg_test(catalog_test USE_BUNDLE SOURCES in_memory_catalog_test.cc)
 
-  add_iceberg_test(metadata_table_test USE_BUNDLE SOURCES metadata_table_test.cc)
+  add_iceberg_test(metadata_table_test
+                   USE_BUNDLE
+                   SOURCES
+                   metadata_table_test.cc
+                   snapshots_scan_test.cc)
 
   add_iceberg_test(eval_expr_test
                    USE_BUNDLE
 
@@ -28,8 +28,7 @@
 #include "iceberg/table_identifier.h"
 #include "iceberg/table_metadata.h"
 #include "iceberg/test/matchers.h"
-#include "iceberg/test/mock_catalog.h"
-#include "iceberg/test/mock_io.h"
+#include "iceberg/test/metadata_table_test_base.h"
 #include "iceberg/type.h"
 
 namespace iceberg {
@@ -58,11 +57,10 @@ std::shared_ptr<Schema> MakeHistorySchema() {
 
 }  // namespace
 
-class MetadataTableTest : public ::testing::Test {
+class MetadataTableTest : public MetadataTableTestBase {
  protected:
   void SetUp() override {
-    io_ = std::make_shared<MockFileIO>();
-    catalog_ = std::make_shared<MockCatalog>();
+    MetadataTableTestBase::SetUp();
 
     auto schema = std::make_shared<Schema>(
         std::vector<SchemaField>{SchemaField::MakeRequired(1, "id", int64()),
@@ -84,8 +82,6 @@ class MetadataTableTest : public ::testing::Test {
     snapshots_table_ = std::move(*snapshots_table_result);
   }
 
-  std::shared_ptr<MockFileIO> io_;
-  std::shared_ptr<MockCatalog> catalog_;
   std::shared_ptr<TableMetadata> metadata_;
   std::shared_ptr<Table> source_table_;
   std::unique_ptr<MetadataTable> snapshots_table_;
 
@@ -0,0 +1,147 @@
+/*
+ * 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.
+ */
+
+/// \file metadata_table_test_base.h
+/// Shared test base for all metadata table tests.
+///
+/// Provides common helpers (FinishAndImport, MakeTestSnapshots,
+/// MakeTableWithSnapshots) and the MockFileIO + MockCatalog fixture that
+/// every metadata table test needs.
+
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <arrow/array.h>
+#include <arrow/c/bridge.h>
+#include <arrow/record_batch.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "iceberg/schema.h"
+#include "iceberg/schema_field.h"
+#include "iceberg/schema_internal.h"
+#include "iceberg/snapshot.h"
+#include "iceberg/table.h"
+#include "iceberg/table_identifier.h"
+#include "iceberg/table_metadata.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/test/mock_catalog.h"
+#include "iceberg/test/mock_io.h"
+#include "iceberg/type.h"
+#include "iceberg/util/timepoint.h"
+
+namespace iceberg {
+
+/// \brief Base class for all metadata table tests.
+///
+/// Provides MockFileIO and MockCatalog instances plus helpers shared across
+/// metadata table tests (SnapshotsTable, HistoryTable, RefsTable, ...).
+class MetadataTableTestBase : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    io_ = std::make_shared<MockFileIO>();
+    catalog_ = std::make_shared<MockCatalog>();
+  }
+
+  /// \brief Import a Scan()-produced ArrowArray into an Arrow RecordBatch.
+  static std::shared_ptr<::arrow::RecordBatch> FinishAndImport(ArrowArray array,
+                                                               const Schema& schema) {
+    ArrowSchema c_schema;
+    EXPECT_THAT(ToArrowSchema(schema, &c_schema), IsOk());
+    auto arrow_schema = ::arrow::ImportSchema(&c_schema).ValueOrDie();
+
+    // ImportRecordBatch takes ownership of the array and releases it.
+    return ::arrow::ImportRecordBatch(&array, arrow_schema).ValueOrDie();
+  }
+
+  /// \brief Create two snapshots matching the Java TestDataTaskParser test data.
+  ///
+  /// Snapshot 1: id=1, no parent, timestamp=1234567890000, operation="append"
+  /// Snapshot 2: id=2, parent=1, timestamp=9876543210000, operation="append"
+  static std::pair<std::shared_ptr<Snapshot>, std::shared_ptr<Snapshot>>
+  MakeTestSnapshots() {
+    std::unordered_map<std::string, std::string> summary1{
+        {"added-data-files", "1"},       {"added-records", "1"},
+        {"added-files-size", "10"},      {"changed-partition-count", "1"},
+        {"total-records", "1"},          {"total-files-size", "10"},
+        {"total-data-files", "1"},       {"total-delete-files", "0"},
+        {"total-position-deletes", "0"}, {"total-equality-deletes", "0"},
+        {"operation", "append"},
+    };
+
+    std::unordered_map<std::string, std::string> summary2{
+        {"added-data-files", "1"},       {"added-records", "1"},
+        {"added-files-size", "10"},      {"changed-partition-count", "1"},
+        {"total-records", "2"},          {"total-files-size", "20"},
+        {"total-data-files", "2"},       {"total-delete-files", "0"},
+        {"total-position-deletes", "0"}, {"total-equality-deletes", "0"},
+        {"operation", "append"},
+    };
+
+    auto snap1 = std::make_shared<Snapshot>(Snapshot{
+        .snapshot_id = 1,
+        .parent_snapshot_id = std::nullopt,
+        .sequence_number = 1,
+        .timestamp_ms = TimePointMsFromUnixMs(1234567890000),
+        .manifest_list = "file:/tmp/manifest1.avro",
+        .summary = std::move(summary1),
+        .schema_id = 1,
+    });
+
+    auto snap2 = std::make_shared<Snapshot>(Snapshot{
+        .snapshot_id = 2,
+        .parent_snapshot_id = 1,
+        .sequence_number = 2,
+        .timestamp_ms = TimePointMsFromUnixMs(9876543210000),
+        .manifest_list = "file:/tmp/manifest2.avro",
+        .summary = std::move(summary2),
+        .schema_id = 1,
+    });
+
+    return {snap1, snap2};
+  }
+
+  /// \brief Create a Table with the given snapshots.
+  Result<std::shared_ptr<Table>> MakeTableWithSnapshots(
+      std::vector<std::shared_ptr<Snapshot>> snapshots, int64_t current_snapshot_id) {
+    auto schema = std::make_shared<Schema>(
+        std::vector<SchemaField>{SchemaField::MakeRequired(1, "id", int64()),
+                                 SchemaField::MakeOptional(2, "name", string())},
+        1);
+    auto metadata = std::make_shared<TableMetadata>(TableMetadata{
+        .format_version = 2,
+        .schemas = {schema},
+        .current_schema_id = 1,
+        .current_snapshot_id = current_snapshot_id,
+        .snapshots = std::move(snapshots),
+    });
+
+    TableIdentifier ident{.ns = Namespace{.levels = {"db"}}, .name = "test_table"};
+    return Table::Make(ident, metadata, "s3://bucket/meta.json", io_, catalog_);
+  }
+
+  std::shared_ptr<MockFileIO> io_;
+  std::shared_ptr<MockCatalog> catalog_;
+};
+
+}  // namespace iceberg