feat: metadata access support for table

Author: shuxu.li

src/iceberg/snapshot.h

@@ -273,20 +273,4 @@ struct ICEBERG_EXPORT Snapshot {
   bool Equals(const Snapshot& other) const;
 };
 
-/// \brief Represents a snapshot log entry
-struct ICEBERG_EXPORT SnapshotLogEntry {
-  /// The timestamp in milliseconds of the change
-  TimePointMs timestamp_ms;
-  /// ID of the snapshot
-  int64_t snapshot_id;
-
-  friend bool operator==(const SnapshotLogEntry& lhs, const SnapshotLogEntry& rhs) {
-    return lhs.timestamp_ms == rhs.timestamp_ms && lhs.snapshot_id == rhs.snapshot_id;
-  }
-
-  friend bool operator!=(const SnapshotLogEntry& lhs, const SnapshotLogEntry& rhs) {
-    return !(lhs == rhs);
-  }
-};
-
 }  // namespace iceberg

src/iceberg/table.cc

@@ -28,67 +28,51 @@ namespace iceberg {
 
 const std::string& Table::uuid() const { return metadata_->table_uuid; }
 
-const std::shared_ptr<Schema>& Table::schema() const {
-  if (!schema_) {
-    const static std::shared_ptr<Schema> kEmptySchema =
-        std::make_shared<Schema>(std::vector<SchemaField>{});
-    auto schema = metadata_->Schema();
-    if (schema.has_value()) {
-      schema_ = schema.value();
-    } else {
-      schema_ = kEmptySchema;
-    }
-  }
-  return schema_;
-}
+Result<std::shared_ptr<Schema>> Table::schema() const { return metadata_->Schema(); }
 
-const std::unordered_map<int32_t, std::shared_ptr<Schema>>& Table::schemas() const {
-  std::call_once(init_schemas_once_, [this]() {
+const std::shared_ptr<std::unordered_map<int32_t, std::shared_ptr<Schema>>>&
+Table::schemas() const {
+  if (!schemas_map_) {
+    schemas_map_ =
+        std::make_shared<std::unordered_map<int32_t, std::shared_ptr<Schema>>>();
     for (const auto& schema : metadata_->schemas) {
       if (schema->schema_id()) {
-        schemas_map_.emplace(schema->schema_id().value(), schema);
+        schemas_map_->emplace(schema->schema_id().value(), schema);
       }
     }
-  });
+  }
   return schemas_map_;
 }
 
-const std::shared_ptr<PartitionSpec>& Table::spec() const {
-  std::call_once(init_partition_spec_once_, [this]() {
-    auto partition_spec = metadata_->PartitionSpec();
-    if (partition_spec.has_value()) {
-      partition_spec_ = partition_spec.value();
-    }
-  });
-  return partition_spec_;
+Result<std::shared_ptr<PartitionSpec>> Table::spec() const {
+  return metadata_->PartitionSpec();
 }
 
-const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>& Table::specs() const {
-  std::call_once(init_partition_specs_once_, [this]() {
+const std::shared_ptr<std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>>&
+Table::specs() const {
+  if (!partition_spec_map_) {
+    partition_spec_map_ =
+        std::make_shared<std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>>();
     for (const auto& spec : metadata_->partition_specs) {
-      partition_spec_map_[spec->spec_id()] = spec;
+      partition_spec_map_->emplace(spec->spec_id(), spec);
     }
-  });
+  }
   return partition_spec_map_;
 }
 
-const std::shared_ptr<SortOrder>& Table::sort_order() const {
-  std::call_once(init_sort_order_once_, [this]() {
-    auto sort_order = metadata_->SortOrder();
-    if (sort_order.has_value()) {
-      sort_order_ = sort_order.value();
-    }
-  });
-  return sort_order_;
+Result<std::shared_ptr<SortOrder>> Table::sort_order() const {
+  return metadata_->SortOrder();
 }
 
-const std::unordered_map<int32_t, std::shared_ptr<SortOrder>>& Table::sort_orders()
-    const {
-  std::call_once(init_sort_orders_once_, [this]() {
+const std::shared_ptr<std::unordered_map<int32_t, std::shared_ptr<SortOrder>>>&
+Table::sort_orders() const {
+  if (!sort_orders_map_) {
+    sort_orders_map_ =
+        std::make_shared<std::unordered_map<int32_t, std::shared_ptr<SortOrder>>>();
     for (const auto& order : metadata_->sort_orders) {
-      sort_orders_map_[order->order_id()] = order;
+      sort_orders_map_->emplace(order->order_id(), order);
     }
-  });
+  }
   return sort_orders_map_;
 }
 
@@ -98,23 +82,17 @@ const std::unordered_map<std::string, std::string>& Table::properties() const {
 
 const std::string& Table::location() const { return metadata_->location; }
 
-std::shared_ptr<Snapshot> Table::current_snapshot() const {
-  std::call_once(init_snapshot_once_, [this]() {
-    auto snapshot = metadata_->Snapshot();
-    if (snapshot.has_value()) {
-      current_snapshot_ = snapshot.value();
-    }
-  });
-  return current_snapshot_;
+Result<std::shared_ptr<Snapshot>> Table::current_snapshot() const {
+  return metadata_->Snapshot();
 }
 
-std::shared_ptr<Snapshot> Table::SnapshotById(int64_t snapshot_id) const {
+Result<std::shared_ptr<Snapshot>> Table::SnapshotById(int64_t snapshot_id) const {
   auto iter = std::ranges::find_if(metadata_->snapshots,
                                    [this, &snapshot_id](const auto& snapshot) {
                                      return snapshot->snapshot_id == snapshot_id;
                                    });
   if (iter == metadata_->snapshots.end()) {
-    return nullptr;
+    return NotFound("Snapshot with ID {} is not found", snapshot_id);
   }
   return *iter;
 }
@@ -127,4 +105,6 @@ const std::vector<SnapshotLogEntry>& Table::history() const {
   return metadata_->snapshot_log;
 }
 
+const std::shared_ptr<FileIO>& Table::io() const { return io_; }
+
 }  // namespace iceberg

src/iceberg/table.h

@@ -41,7 +41,8 @@ class ICEBERG_EXPORT Table {
   /// \param[in] metadata The metadata for the table.
   /// \param[in] metadata_location The location of the table metadata file.
   /// \param[in] io The FileIO to read and write table data and metadata files.
-  /// \param[in] catalog The catalog that this table belongs to.
+  /// \param[in] catalog The catalog that this table belongs to. If null, the table will
+  /// be read-only.
   Table(TableIdentifier identifier, std::shared_ptr<TableMetadata> metadata,
         std::string metadata_location, std::shared_ptr<FileIO> io,
         std::shared_ptr<Catalog> catalog)
@@ -57,41 +58,41 @@ class ICEBERG_EXPORT Table {
   /// \brief Returns the UUID of the table
   const std::string& uuid() const;
 
-  /// \brief Return the schema for this table, return empty schema if not found
-  const std::shared_ptr<Schema>& schema() const;
+  /// \brief Return the schema for this table, return NotFoundError if not found
+  Result<std::shared_ptr<Schema>> schema() const;
 
   /// \brief Return a map of schema for this table
-  const std::unordered_map<int32_t, std::shared_ptr<Schema>>& schemas() const;
+  const std::shared_ptr<std::unordered_map<int32_t, std::shared_ptr<Schema>>>& schemas()
+      const;
 
-  /// \brief Return the partition spec for this table, return null if default spec is not
-  /// found
-  const std::shared_ptr<PartitionSpec>& spec() const;
+  /// \brief Return the partition spec for this table, return NotFoundError if not found
+  Result<std::shared_ptr<PartitionSpec>> spec() const;
 
   /// \brief Return a map of partition specs for this table
-  const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>& specs() const;
+  const std::shared_ptr<std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>>&
+  specs() const;
 
-  /// \brief Return the sort order for this table, return null if default sort order is
-  /// not found
-  const std::shared_ptr<SortOrder>& sort_order() const;
+  /// \brief Return the sort order for this table, return NotFoundError if not found
+  Result<std::shared_ptr<SortOrder>> sort_order() const;
 
   /// \brief Return a map of sort order IDs to sort orders for this table
-  const std::unordered_map<int32_t, std::shared_ptr<SortOrder>>& sort_orders() const;
+  const std::shared_ptr<std::unordered_map<int32_t, std::shared_ptr<SortOrder>>>&
+  sort_orders() const;
 
   /// \brief Return a map of string properties for this table
   const std::unordered_map<std::string, std::string>& properties() const;
 
   /// \brief Return the table's base location
   const std::string& location() const;
 
-  /// \brief Return the table's current snapshot, return null if not found
-  std::shared_ptr<Snapshot> current_snapshot() const;
+  /// \brief Return the table's current snapshot, return NotFoundError if not found
+  Result<std::shared_ptr<Snapshot>> current_snapshot() const;
 
-  /// \brief Get the snapshot of this table with the given id, or null if there is no
-  /// matching snapshot
+  /// \brief Get the snapshot of this table with the given id
   ///
   /// \param snapshot_id the ID of the snapshot to get
-  /// \return the Snapshot with the given id
-  std::shared_ptr<Snapshot> SnapshotById(int64_t snapshot_id) const;
+  /// \return the Snapshot with the given id, return NotFoundError if not found
+  Result<std::shared_ptr<Snapshot>> SnapshotById(int64_t snapshot_id) const;
 
   /// \brief Get the snapshots of this table
   const std::vector<std::shared_ptr<Snapshot>>& snapshots() const;
@@ -101,31 +102,22 @@ class ICEBERG_EXPORT Table {
   /// \return a vector of history entries
   const std::vector<SnapshotLogEntry>& history() const;
 
+  /// \brief Returns a FileIO to read and write table data and metadata files
+  const std::shared_ptr<FileIO>& io() const;
+
  private:
   const TableIdentifier identifier_;
   const std::shared_ptr<TableMetadata> metadata_;
   const std::string metadata_location_;
   std::shared_ptr<FileIO> io_;
   std::shared_ptr<Catalog> catalog_;
 
-  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_;
-
-  // once_flags
-  mutable std::once_flag init_schemas_once_;
-  mutable std::once_flag init_partition_spec_once_;
-  mutable std::once_flag init_partition_specs_once_;
-  mutable std::once_flag init_sort_order_once_;
-  mutable std::once_flag init_sort_orders_once_;
-  mutable std::once_flag init_snapshot_once_;
+  mutable std::shared_ptr<std::unordered_map<int32_t, std::shared_ptr<Schema>>>
+      schemas_map_;
+  mutable std::shared_ptr<std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>>
+      partition_spec_map_;
+  mutable std::shared_ptr<std::unordered_map<int32_t, std::shared_ptr<SortOrder>>>
+      sort_orders_map_;
 };
 
 }  // namespace iceberg

src/iceberg/table_metadata.cc

@@ -47,24 +47,13 @@ std::string ToString(const MetadataLogEntry& entry) {
 }
 
 Result<std::shared_ptr<Schema>> TableMetadata::Schema() const {
-  std::call_once(init_schema_once, [this]() {
-    auto iter = std::ranges::find_if(schemas, [this](const auto& schema) {
-      return schema->schema_id() == current_schema_id;
-    });
-    if (iter != schemas.end()) {
-      schema = *iter;
-    }
-
-    // compatible with V1 table schema
-    if (!schema && schemas.size() == 1UL) {
-      schema = schemas.front();
-    }
+  auto iter = std::ranges::find_if(schemas, [this](const auto& schema) {
+    return schema->schema_id() == current_schema_id;
   });
-
-  if (!schema) {
-    return NotFound("Current schema is not defined for this table");
+  if (iter == schemas.end()) {
+    return NotFound("Current schema is not found");
   }
-  return schema;
+  return *iter;
 }
 
 Result<std::shared_ptr<PartitionSpec>> TableMetadata::PartitionSpec() const {
@@ -88,9 +77,6 @@ Result<std::shared_ptr<SortOrder>> TableMetadata::SortOrder() const {
 }
 
 Result<std::shared_ptr<Snapshot>> TableMetadata::Snapshot() const {
-  if (current_snapshot_id == Snapshot::kInvalidSnapshotId) {
-    return NotFound("Current snapshot is not defined for this table");
-  }
   auto iter = std::ranges::find_if(snapshots, [this](const auto& snapshot) {
     return snapshot->snapshot_id == current_snapshot_id;
   });

src/iceberg/table_metadata.h

@@ -36,6 +36,22 @@
 
 namespace iceberg {
 
+/// \brief Represents a snapshot log entry
+struct ICEBERG_EXPORT SnapshotLogEntry {
+  /// The timestamp in milliseconds of the change
+  TimePointMs timestamp_ms;
+  /// ID of the snapshot
+  int64_t snapshot_id;
+
+  friend bool operator==(const SnapshotLogEntry& lhs, const SnapshotLogEntry& rhs) {
+    return lhs.timestamp_ms == rhs.timestamp_ms && lhs.snapshot_id == rhs.snapshot_id;
+  }
+
+  friend bool operator!=(const SnapshotLogEntry& lhs, const SnapshotLogEntry& rhs) {
+    return !(lhs == rhs);
+  }
+};
+
 /// \brief Represents a metadata log entry
 struct ICEBERG_EXPORT MetadataLogEntry {
   /// The timestamp in milliseconds of the change
@@ -80,8 +96,6 @@ struct ICEBERG_EXPORT TableMetadata {
   TimePointMs last_updated_ms;
   /// The highest assigned column ID for the table
   int32_t last_column_id;
-  /// The current schema for the table, or null if not set
-  mutable std::shared_ptr<Schema> schema;
   /// A list of schemas
   std::vector<std::shared_ptr<Schema>> schemas;
   /// ID of the table's current schema
@@ -117,9 +131,6 @@ struct ICEBERG_EXPORT TableMetadata {
   /// A `long` higher than all assigned row IDs
   int64_t next_row_id;
 
-  /// \brief Used for lazy initialization of schema
-  mutable std::once_flag init_schema_once;
-
   /// \brief Get the current schema, return NotFoundError if not found
   Result<std::shared_ptr<Schema>> Schema() const;
   /// \brief Get the current partition spec, return NotFoundError if not found

src/iceberg/type_fwd.h

@@ -99,8 +99,9 @@ class TransformFunction;
 struct PartitionStatisticsFile;
 struct Snapshot;
 struct SnapshotRef;
-struct SnapshotLogEntry;
+
 struct MetadataLogEntry;
+struct SnapshotLogEntry;
 
 struct StatisticsFile;
 struct TableMetadata;