static table metadata access support

Author: shuxu.li

src/iceberg/CMakeLists.txt

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

src/iceberg/table.cc

@@ -0,0 +1,173 @@
+/*
+ * 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.
+ */
+
+#include "iceberg/table.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"
+#include "iceberg/table_metadata.h"
+
+namespace iceberg {
+
+BaseTable::BaseTable(std::string name, std::shared_ptr<TableMetadata> metadata)
+    : name_(std::move(name)), metadata_(std::move(metadata)) {
+  if (!metadata_) {
+    throw std::invalid_argument("Table metadata cannot be null");
+  }
+}
+
+void BaseTable::InitSchema() const {
+  for (const auto& schema : metadata_->schemas) {
+    if (schema->schema_id() != std::nullopt) {
+      schemas_map_.emplace(schema->schema_id().value(), schema);
+      if (schema->schema_id().value() == metadata_->current_schema_id) {
+        schema_ = schema;
+      }
+    }
+  }
+  // compatible with V1 table schema
+  if (!schema_ && metadata_->schemas.size() == 1UL) {
+    schema_ = metadata_->schemas.front();
+  }
+}
+
+void BaseTable::InitPartitionSpec() const {
+  for (const auto& spec : metadata_->partition_specs) {
+    partition_spec_map_[spec->spec_id()] = spec;
+    if (spec->spec_id() == metadata_->default_spec_id) {
+      partition_spec_ = spec;
+    }
+  }
+}
+
+void BaseTable::InitSortOrder() const {
+  for (const auto& order : metadata_->sort_orders) {
+    sort_orders_map_[order->order_id()] = order;
+    if (order->order_id() == metadata_->default_sort_order_id) {
+      sort_order_ = order;
+    }
+  }
+}
+
+void BaseTable::InitSnapshot() const {
+  auto snapshots = metadata_->snapshots;
+  for (const auto& snapshot : snapshots) {
+    if (snapshot->snapshot_id == metadata_->current_snapshot_id) {
+      current_snapshot_ = snapshot;
+    }
+    snapshots_map_[snapshot->snapshot_id] = snapshot;
+  }
+}
+
+const std::string& BaseTable::uuid() const { return metadata_->table_uuid; }
+
+const std::shared_ptr<Schema>& BaseTable::schema() const {
+  std::call_once(init_schema_once_, [this]() { InitSchema(); });
+  if (!schema_) {
+    throw IcebergError("Current schema is not defined for this table");
+  }
+  return schema_;
+}
+
+const std::unordered_map<int32_t, std::shared_ptr<Schema>>& BaseTable::schemas() const {
+  std::call_once(init_schema_once_, [this]() { InitSchema(); });
+  return schemas_map_;
+}
+
+const std::shared_ptr<PartitionSpec>& BaseTable::spec() const {
+  std::call_once(init_partition_spec_once_, [this]() { InitPartitionSpec(); });
+  return partition_spec_;
+}
+
+const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>& BaseTable::specs()
+    const {
+  std::call_once(init_partition_spec_once_, [this]() { InitPartitionSpec(); });
+  return partition_spec_map_;
+}
+
+const std::shared_ptr<SortOrder>& BaseTable::sort_order() const {
+  std::call_once(init_sort_order_once_, [this]() { InitSortOrder(); });
+  return sort_order_;
+}
+
+const std::unordered_map<int32_t, std::shared_ptr<SortOrder>>& BaseTable::sort_orders()
+    const {
+  std::call_once(init_sort_order_once_, [this]() { InitSortOrder(); });
+  return sort_orders_map_;
+}
+
+const std::unordered_map<std::string, std::string>& BaseTable::properties() const {
+  return metadata_->properties;
+}
+
+const std::string& BaseTable::location() const { return metadata_->location; }
+
+const std::shared_ptr<Snapshot>& BaseTable::current_snapshot() const {
+  std::call_once(init_snapshot_once_, [this]() { InitSnapshot(); });
+  if (!current_snapshot_) {
+    throw IcebergError("Current snapshot is not defined for this table");
+  }
+  return current_snapshot_;
+}
+
+Result<std::shared_ptr<Snapshot>> BaseTable::snapshot(int64_t snapshot_id) const {
+  std::call_once(init_snapshot_once_, [this]() { InitSnapshot(); });
+  auto iter = snapshots_map_.find(snapshot_id);
+  if (iter == snapshots_map_.end()) {
+    return NotFound("Snapshot with ID {} not found", snapshot_id);
+  }
+  return iter->second;
+}
+
+const std::vector<std::shared_ptr<Snapshot>>& BaseTable::snapshots() const {
+  return metadata_->snapshots;
+}
+
+const std::vector<std::shared_ptr<HistoryEntry>>& BaseTable::history() const {
+  // TODO: Implement history retrieval
+  throw IcebergError("history is not supported for BaseTable now");
+}
+
+Status StaticTable::Refresh() {
+  throw IcebergError("Refresh is not supported for StaticTable");
+}
+
+std::unique_ptr<TableScan> StaticTable::NewScan() const {
+  throw IcebergError("NewScan is not supported for StaticTable");
+}
+
+std::shared_ptr<AppendFiles> StaticTable::NewAppend() {
+  throw IcebergError("NewAppend is not supported for StaticTable");
+}
+
+std::unique_ptr<Transaction> StaticTable::NewTransaction() {
+  throw IcebergError("NewTransaction is not supported for StaticTable");
+}
+
+std::unique_ptr<LocationProvider> StaticTable::location_provider() const {
+  throw IcebergError("location_provider is not supported for StaticTable");
+}
+
+}  // namespace iceberg

src/iceberg/table.h

@@ -108,4 +108,85 @@ class ICEBERG_EXPORT Table {
   virtual std::unique_ptr<LocationProvider> location_provider() const = 0;
 };
 
+class ICEBERG_EXPORT BaseTable : public Table {
+ public:
+  virtual ~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;
+
+  const std::shared_ptr<Schema>& schema() const override;
+
+  const std::unordered_map<int32_t, std::shared_ptr<Schema>>& schemas() const override;
+
+  const std::shared_ptr<PartitionSpec>& spec() const override;
+
+  const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>& specs()
+      const override;
+
+  const 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;
+
+  const 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_;
+
+  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_;
+};
+
+class ICEBERG_EXPORT StaticTable : public BaseTable {
+ public:
+  virtual ~StaticTable() override = default;
+  StaticTable(std::string name, std::shared_ptr<TableMetadata> metadata)
+      : BaseTable(std::move(name), std::move(metadata)) {}
+
+  Status Refresh() override;
+
+  std::unique_ptr<TableScan> NewScan() const override;
+
+  std::shared_ptr<AppendFiles> NewAppend() override;
+
+  std::unique_ptr<Transaction> NewTransaction() override;
+
+  std::unique_ptr<LocationProvider> location_provider() const override;
+};
+
 }  // namespace iceberg

test/CMakeLists.txt

@@ -44,6 +44,14 @@ target_sources(schema_test
 target_link_libraries(schema_test PRIVATE iceberg_static GTest::gtest_main GTest::gmock)
 add_test(NAME schema_test COMMAND schema_test)
 
+add_executable(table_test)
+target_include_directories(table_test PRIVATE "${CMAKE_BINARY_DIR}")
+target_sources(table_test PRIVATE table_test_helper.cc json_internal_test.cc table_test.cc
+                                  schema_json_test.cc)
+target_link_libraries(table_test PRIVATE iceberg_static GTest::gtest_main
+                                         GTest::gmock)
+add_test(NAME table_test COMMAND table_test)
+
 add_executable(expression_test)
 target_sources(expression_test PRIVATE expression_test.cc)
 target_link_libraries(expression_test PRIVATE iceberg_static GTest::gtest_main
@@ -52,7 +60,7 @@ add_test(NAME expression_test COMMAND expression_test)
 
 add_executable(json_serde_test)
 target_include_directories(json_serde_test PRIVATE "${CMAKE_BINARY_DIR}")
-target_sources(json_serde_test PRIVATE json_internal_test.cc metadata_serde_test.cc
+target_sources(json_serde_test PRIVATE table_test_helper.cc json_internal_test.cc metadata_serde_test.cc
                                        schema_json_test.cc)
 target_link_libraries(json_serde_test PRIVATE iceberg_static GTest::gtest_main
                                               GTest::gmock)

test/metadata_serde_test.cc

@@ -20,13 +20,11 @@
 #include <filesystem>
 #include <fstream>
 #include <optional>
-#include <sstream>
 #include <string>
 
 #include <gtest/gtest.h>
 #include <nlohmann/json.hpp>
 
-#include "iceberg/json_internal.h"
 #include "iceberg/partition_field.h"
 #include "iceberg/partition_spec.h"
 #include "iceberg/schema.h"
@@ -35,9 +33,9 @@
 #include "iceberg/sort_field.h"
 #include "iceberg/sort_order.h"
 #include "iceberg/table_metadata.h"
-#include "iceberg/test/test_config.h"
 #include "iceberg/transform.h"
 #include "iceberg/type.h"
+#include "table_test_helper.h"
 
 namespace iceberg {
 
@@ -46,40 +44,14 @@ namespace {
 class MetadataSerdeTest : public ::testing::Test {
  protected:
   void SetUp() override {}
-
-  static std::string GetResourcePath(const std::string& file_name) {
-    return std::string(ICEBERG_TEST_RESOURCES) + "/" + file_name;
-  }
-
-  static void ReadJsonFile(const std::string& file_name, std::string* content) {
-    std::filesystem::path path{GetResourcePath(file_name)};
-    ASSERT_TRUE(std::filesystem::exists(path))
-        << "File does not exist: " << path.string();
-
-    std::ifstream file(path);
-    std::stringstream buffer;
-    buffer << file.rdbuf();
-    *content = buffer.str();
-  }
-
-  static void ReadTableMetadata(const std::string& file_name,
-                                std::unique_ptr<TableMetadata>* metadata) {
-    std::string json_content;
-    ReadJsonFile(file_name, &json_content);
-
-    nlohmann::json json = nlohmann::json::parse(json_content);
-    auto result = TableMetadataFromJson(json);
-    ASSERT_TRUE(result.has_value()) << "Failed to parse table metadata from " << file_name
-                                    << ": " << result.error().message;
-    *metadata = std::move(result.value());
-  }
 };
 
 }  // namespace
 
 TEST_F(MetadataSerdeTest, DeserializeV1Valid) {
   std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV1Valid.json", &metadata));
+  ASSERT_NO_FATAL_FAILURE(
+      TableTestHelper::ReadTableMetadata("TableMetadataV1Valid.json", &metadata));
 
   EXPECT_EQ(metadata->format_version, 1);
   EXPECT_EQ(metadata->table_uuid, "d20125c8-7284-442c-9aea-15fee620737c");
@@ -116,7 +88,8 @@ TEST_F(MetadataSerdeTest, DeserializeV1Valid) {
 
 TEST_F(MetadataSerdeTest, DeserializeV2Valid) {
   std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV2Valid.json", &metadata));
+  ASSERT_NO_FATAL_FAILURE(
+      TableTestHelper::ReadTableMetadata("TableMetadataV2Valid.json", &metadata));
 
   EXPECT_EQ(metadata->format_version, 2);
   EXPECT_EQ(metadata->table_uuid, "9c12d441-03fe-4693-9a96-a0705ddf69c1");