feat: add json serde for table metadata

Author: wgtmac

src/iceberg/json_internal.cc

@@ -24,6 +24,9 @@
 #include <nlohmann/json_fwd.hpp>
 
 #include "iceberg/result.h"
+#include "iceberg/snapshot.h"
+#include "iceberg/statistics_file.h"
+#include "iceberg/table_metadata.h"
 #include "iceberg/type_fwd.h"
 
 namespace iceberg {
@@ -74,19 +77,19 @@ Result<std::unique_ptr<SortOrder>> SortOrderFromJson(const nlohmann::json& json)
 ///
 /// \param[in] schema The Iceberg schema to convert.
 /// \return The JSON representation of the schema.
-nlohmann::json SchemaToJson(const Schema& schema);
+nlohmann::json ToJson(const Schema& schema);
 
 /// \brief Convert an Iceberg Type to JSON.
 ///
 /// \param[in] type The Iceberg type to convert.
 /// \return The JSON representation of the type.
-nlohmann::json TypeToJson(const Type& type);
+nlohmann::json ToJson(const Type& type);
 
 /// \brief Convert an Iceberg SchemaField to JSON.
 ///
 /// \param[in] field The Iceberg field to convert.
 /// \return The JSON representation of the field.
-nlohmann::json FieldToJson(const SchemaField& field);
+nlohmann::json ToJson(const SchemaField& field);
 
 /// \brief Convert JSON to an Iceberg Schema.
 ///
@@ -153,4 +156,73 @@ Result<std::unique_ptr<PartitionField>> PartitionFieldFromJson(
 /// the JSON is malformed or missing expected fields, an error will be returned.
 Result<std::unique_ptr<PartitionSpec>> PartitionSpecFromJson(
     const std::shared_ptr<Schema>& schema, const nlohmann::json& json);
+
+/// \brief Serializes a `StatisticsFile` object to JSON.
+///
+/// \param statistics_file The `StatisticsFile` object to be serialized.
+/// \return A JSON object representing the `StatisticsFile`.
+nlohmann::json ToJson(const StatisticsFile& statistics_file);
+
+/// \brief Deserializes a JSON object into a `StatisticsFile` object.
+///
+/// \param json The JSON object representing a `StatisticsFile`.
+/// \return A `StatisticsFile` object or an error if the conversion fails.
+Result<std::unique_ptr<StatisticsFile>> StatisticsFileFromJson(
+    const nlohmann::json& json);
+
+/// \brief Serializes a `PartitionStatisticsFile` object to JSON.
+///
+/// \param partition_statistics_file The `PartitionStatisticsFile` object to be
+/// serialized. \return A JSON object representing the `PartitionStatisticsFile`.
+nlohmann::json ToJson(const PartitionStatisticsFile& partition_statistics_file);
+
+/// \brief Deserializes a JSON object into a `PartitionStatisticsFile` object.
+///
+/// \param json The JSON object representing a `PartitionStatisticsFile`.
+/// \return A `PartitionStatisticsFile` object or an error if the conversion fails.
+Result<std::unique_ptr<PartitionStatisticsFile>> PartitionStatisticsFileFromJson(
+    const nlohmann::json& json);
+
+/// \brief Serializes a `SnapshotLogEntry` object to JSON.
+///
+/// \param snapshot_log_entry The `SnapshotLogEntry` object to be serialized.
+/// \return A JSON object representing the `SnapshotLogEntry`.
+nlohmann::json ToJson(const SnapshotLogEntry& snapshot_log_entry);
+
+/// \brief Deserializes a JSON object into a `SnapshotLogEntry` object.
+///
+/// \param json The JSON object representing a `SnapshotLogEntry`.
+/// \return A `SnapshotLogEntry` object or an error if the conversion fails.
+Result<SnapshotLogEntry> SnapshotLogEntryFromJson(const nlohmann::json& json);
+
+/// \brief Serializes a `MetadataLogEntry` object to JSON.
+///
+/// \param metadata_log_entry The `MetadataLogEntry` object to be serialized.
+/// \return A JSON object representing the `MetadataLogEntry`.
+nlohmann::json ToJson(const MetadataLogEntry& metadata_log_entry);
+
+/// \brief Deserializes a JSON object into a `MetadataLogEntry` object.
+///
+/// \param json The JSON object representing a `MetadataLogEntry`.
+/// \return A `MetadataLogEntry` object or an error if the conversion fails.
+Result<MetadataLogEntry> MetadataLogEntryFromJson(const nlohmann::json& json);
+
+/// \brief Serializes a `TableMetadata` object to JSON.
+///
+/// \param table_metadata The `TableMetadata` object to be serialized.
+/// \return A JSON object representing the `TableMetadata`.
+nlohmann::json ToJson(const TableMetadata& table_metadata);
+
+/// \brief Deserializes a JSON object into a `TableMetadata` object.
+///
+/// \param json The JSON object representing a `TableMetadata`.
+/// \return A `TableMetadata` object or an error if the conversion fails.
+Result<std::unique_ptr<TableMetadata>> TableMetadataFromJson(const nlohmann::json& json);
+
+// Functions below will be available after https://github.com/apache/iceberg-cpp/pull/74
+nlohmann::json ToJson(const Snapshot& snapshot);
+nlohmann::json ToJson(const SnapshotRef& snapshot_ref);
+Result<std::unique_ptr<Snapshot>> SnapshotFromJson(const nlohmann::json& json);
+Result<std::unique_ptr<SnapshotRef>> SnapshotRefFromJson(const nlohmann::json& json);
+
 }  // namespace iceberg

src/iceberg/json_internal.h

@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include <format>
 #include <string>
 
 #include "iceberg/expected.h"
@@ -60,4 +61,20 @@ using Result = expected<T, E>;
 
 using Status = Result<void>;
 
+/// \brief Create an unexpected error with kNotImplemented
+template <typename... Args>
+auto NotImplementedError(const std::format_string<Args...> fmt, Args&&... args)
+    -> unexpected<Error> {
+  return unexpected<Error>({.kind = ErrorKind::kNotImplemented,
+                            .message = std::format(fmt, std::forward<Args>(args)...)});
+}
+
+/// \brief Create an unexpected error with kJsonParseError
+template <typename... Args>
+auto JsonParseError(const std::format_string<Args...> fmt, Args&&... args)
+    -> unexpected<Error> {
+  return unexpected<Error>({.kind = ErrorKind::kJsonParseError,
+                            .message = std::format(fmt, std::forward<Args>(args)...)});
+}
+
 }  // namespace iceberg

src/iceberg/result.h

@@ -23,29 +23,26 @@
 
 namespace iceberg {
 
-bool BlobMetadata::Equals(const BlobMetadata& other) const {
-  return type == other.type && source_snapshot_id == other.source_snapshot_id &&
-         source_snapshot_sequence_number == other.source_snapshot_sequence_number &&
-         fields == other.fields && properties == other.properties;
-}
-
-std::string BlobMetadata::ToString() const {
+std::string ToString(const BlobMetadata& blob_metadata) {
   std::string repr = "BlobMetadata[";
   std::format_to(std::back_inserter(repr),
-                 "type='{}',sourceSnapshotId={},sourceSnapshotSequenceNumber={},", type,
-                 source_snapshot_id, source_snapshot_sequence_number);
+                 "type='{}',sourceSnapshotId={},sourceSnapshotSequenceNumber={},",
+                 blob_metadata.type, blob_metadata.source_snapshot_id,
+                 blob_metadata.source_snapshot_sequence_number);
   std::format_to(std::back_inserter(repr), "fields=[");
-  for (auto iter = fields.cbegin(); iter != fields.cend(); ++iter) {
-    if (iter != fields.cbegin()) {
+  for (auto iter = blob_metadata.fields.cbegin(); iter != blob_metadata.fields.cend();
+       ++iter) {
+    if (iter != blob_metadata.fields.cbegin()) {
       std::format_to(std::back_inserter(repr), ",{}", *iter);
     } else {
       std::format_to(std::back_inserter(repr), "{}", *iter);
     }
   }
   std::format_to(std::back_inserter(repr), "],properties=[");
-  for (auto iter = properties.cbegin(); iter != properties.cend(); ++iter) {
+  for (auto iter = blob_metadata.properties.cbegin();
+       iter != blob_metadata.properties.cend(); ++iter) {
     const auto& [key, value] = *iter;
-    if (iter != properties.cbegin()) {
+    if (iter != blob_metadata.properties.cbegin()) {
       std::format_to(std::back_inserter(repr), ",{}:{}", key, value);
     } else {
       std::format_to(std::back_inserter(repr), "{}:{}", key, value);
@@ -55,28 +52,32 @@ std::string BlobMetadata::ToString() const {
   return repr;
 }
 
-bool StatisticsFile::Equals(const StatisticsFile& other) const {
-  return snapshot_id == other.snapshot_id && path == other.path &&
-         file_size_in_bytes == other.file_size_in_bytes &&
-         file_footer_size_in_bytes == other.file_footer_size_in_bytes &&
-         blob_metadata == other.blob_metadata;
-}
-
-std::string StatisticsFile::ToString() const {
+std::string ToString(const StatisticsFile& statistics_file) {
   std::string repr = "StatisticsFile[";
   std::format_to(std::back_inserter(repr),
                  "snapshotId={},path={},fileSizeInBytes={},fileFooterSizeInBytes={},",
-                 snapshot_id, path, file_size_in_bytes, file_footer_size_in_bytes);
+                 statistics_file.snapshot_id, statistics_file.path,
+                 statistics_file.file_size_in_bytes,
+                 statistics_file.file_footer_size_in_bytes);
   std::format_to(std::back_inserter(repr), "blobMetadata=[");
-  for (auto iter = blob_metadata.cbegin(); iter != blob_metadata.cend(); ++iter) {
-    if (iter != blob_metadata.cbegin()) {
-      std::format_to(std::back_inserter(repr), ",{}", iter->ToString());
+  for (auto iter = statistics_file.blob_metadata.cbegin();
+       iter != statistics_file.blob_metadata.cend(); ++iter) {
+    if (iter != statistics_file.blob_metadata.cbegin()) {
+      std::format_to(std::back_inserter(repr), ",{}", ToString(*iter));
     } else {
-      std::format_to(std::back_inserter(repr), "{}", iter->ToString());
+      std::format_to(std::back_inserter(repr), "{}", ToString(*iter));
     }
   }
   repr += "]]";
   return repr;
 }
 
+std::string ToString(const PartitionStatisticsFile& partition_statistics_file) {
+  std::string repr = "PartitionStatisticsFile[";
+  std::format_to(std::back_inserter(repr), "snapshotId={},path={},fileSizeInBytes={},",
+                 partition_statistics_file.snapshot_id, partition_statistics_file.path,
+                 partition_statistics_file.file_size_in_bytes);
+  return repr;
+}
+
 }  // namespace iceberg

src/iceberg/statistics_file.cc

@@ -28,12 +28,11 @@
 #include <vector>
 
 #include "iceberg/iceberg_export.h"
-#include "iceberg/util/formattable.h"
 
 namespace iceberg {
 
 /// \brief A metadata about a statistics or indices blob
-struct ICEBERG_EXPORT BlobMetadata : public util::Formattable {
+struct ICEBERG_EXPORT BlobMetadata {
   /// Type of the blob
   std::string type;
   /// ID of the Iceberg table's snapshot the blob was computed from
@@ -47,22 +46,19 @@ struct ICEBERG_EXPORT BlobMetadata : public util::Formattable {
 
   /// \brief Compare two BlobMetadatas for equality.
   friend bool operator==(const BlobMetadata& lhs, const BlobMetadata& rhs) {
-    return lhs.Equals(rhs);
+    return lhs.type == rhs.type && lhs.source_snapshot_id == rhs.source_snapshot_id &&
+           lhs.source_snapshot_sequence_number == rhs.source_snapshot_sequence_number &&
+           lhs.fields == rhs.fields && lhs.properties == rhs.properties;
   }
 
   /// \brief Compare two BlobMetadatas for inequality.
   friend bool operator!=(const BlobMetadata& lhs, const BlobMetadata& rhs) {
     return !(lhs == rhs);
   }
-
-  std::string ToString() const override;
-
- private:
-  bool Equals(const BlobMetadata& other) const;
 };
 
 /// \brief Represents a statistics file in the Puffin format
-struct ICEBERG_EXPORT StatisticsFile : public util::Formattable {
+struct ICEBERG_EXPORT StatisticsFile {
   /// ID of the Iceberg table's snapshot the statistics file is associated with
   int64_t snapshot_id;
   /// Fully qualified path to the file
@@ -76,18 +72,16 @@ struct ICEBERG_EXPORT StatisticsFile : public util::Formattable {
 
   /// \brief Compare two StatisticsFiles for equality.
   friend bool operator==(const StatisticsFile& lhs, const StatisticsFile& rhs) {
-    return lhs.Equals(rhs);
+    return lhs.snapshot_id == rhs.snapshot_id && lhs.path == rhs.path &&
+           lhs.file_size_in_bytes == rhs.file_size_in_bytes &&
+           lhs.file_footer_size_in_bytes == rhs.file_footer_size_in_bytes &&
+           lhs.blob_metadata == rhs.blob_metadata;
   }
 
   /// \brief Compare two StatisticsFiles for inequality.
   friend bool operator!=(const StatisticsFile& lhs, const StatisticsFile& rhs) {
     return !(lhs == rhs);
   }
-
-  std::string ToString() const override;
-
- private:
-  bool Equals(const StatisticsFile& other) const;
 };
 
 /// \brief Represents a partition statistics file
@@ -99,6 +93,29 @@ struct ICEBERG_EXPORT PartitionStatisticsFile {
   std::string path;
   /// The size of the partition statistics file in bytes
   int64_t file_size_in_bytes;
+
+  /// \brief Compare two PartitionStatisticsFiles for equality.
+  friend bool operator==(const PartitionStatisticsFile& lhs,
+                         const PartitionStatisticsFile& rhs) {
+    return lhs.snapshot_id == rhs.snapshot_id && lhs.path == rhs.path &&
+           lhs.file_size_in_bytes == rhs.file_size_in_bytes;
+  }
+
+  /// \brief Compare two PartitionStatisticsFiles for inequality.
+  friend bool operator!=(const PartitionStatisticsFile& lhs,
+                         const PartitionStatisticsFile& rhs) {
+    return !(lhs == rhs);
+  }
 };
 
+/// \brief Returns a string representation of a BlobMetadata
+ICEBERG_EXPORT std::string ToString(const BlobMetadata& blob_metadata);
+
+/// \brief Returns a string representation of a StatisticsFile
+ICEBERG_EXPORT std::string ToString(const StatisticsFile& statistics_file);
+
+/// \brief Returns a string representation of a PartitionStatisticsFile
+ICEBERG_EXPORT std::string ToString(
+    const PartitionStatisticsFile& partition_statistics_file);
+
 }  // namespace iceberg

src/iceberg/statistics_file.h

@@ -22,17 +22,26 @@
 #include <format>
 #include <string>
 
-#include "iceberg/statistics_file.h"
-
 namespace iceberg {
 
-std::string SnapshotLogEntry::ToString() const {
-  return std::format("SnapshotLogEntry[timestampMillis={},snapshotId={}]", timestamp_ms,
-                     snapshot_id);
+std::string ToString(const SnapshotLogEntry& entry) {
+  return std::format("SnapshotLogEntry[timestampMillis={},snapshotId={}]",
+                     entry.timestamp_ms, entry.snapshot_id);
+}
+
+std::string ToString(const MetadataLogEntry& entry) {
+  return std::format("MetadataLogEntry[timestampMillis={},file={}]", entry.timestamp_ms,
+                     entry.metadata_file);
+}
+
+Result<TimePointMs> TimePointMsFromUnixMs(int64_t unix_ms) {
+  return TimePointMs{std::chrono::milliseconds(unix_ms)};
 }
 
-std::string MetadataLogEntry::ToString() const {
-  return std::format("MetadataLogEntry[timestampMillis={},file={}]", timestamp_ms, file);
+int64_t UnixMsFromTimePointMs(const TimePointMs& time_point_ms) {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(
+             time_point_ms.time_since_epoch())
+      .count();
 }
 
 }  // namespace iceberg