Merge branch 'main' into expr

Author: yingcai-cy

src/iceberg/CMakeLists.txt

@@ -31,7 +31,9 @@ set(ICEBERG_SOURCES
     statistics_file.cc
     table_metadata.cc
     transform.cc
+    transform_function.cc
     type.cc
+    snapshot.cc
     expression.cc)
 
 set(ICEBERG_STATIC_BUILD_INTERFACE_LIBS)

src/iceberg/arrow/arrow_error_transform_internal.h

@@ -22,7 +22,6 @@
 #include <arrow/result.h>
 #include <arrow/status.h>
 
-#include "iceberg/expected.h"
 #include "iceberg/result.h"
 
 namespace iceberg::arrow {

src/iceberg/json_internal.cc

@@ -24,14 +24,14 @@
 
 #include <nlohmann/json.hpp>
 
-#include "iceberg/expected.h"
+#include "iceberg/partition_spec.h"
 #include "iceberg/result.h"
 #include "iceberg/schema.h"
 #include "iceberg/schema_internal.h"
 #include "iceberg/sort_order.h"
 #include "iceberg/transform.h"
 #include "iceberg/type.h"
-#include "iceberg/util/formatter.h"
+#include "iceberg/util/formatter.h"  // IWYU pragma: keep
 #include "iceberg/util/macros.h"
 
 namespace iceberg {
@@ -68,6 +68,9 @@ constexpr std::string_view kRequired = "required";
 constexpr std::string_view kElementRequired = "element-required";
 constexpr std::string_view kValueRequired = "value-required";
 
+constexpr std::string_view kFieldId = "field-id";
+constexpr std::string_view kSpecId = "spec-id";
+
 template <typename T>
 Result<T> GetJsonValue(const nlohmann::json& json, std::string_view key) {
   if (!json.contains(key)) {
@@ -113,7 +116,7 @@ Result<std::unique_ptr<SortField>> SortFieldFromJson(const nlohmann::json& json)
   ICEBERG_ASSIGN_OR_RAISE(auto source_id, GetJsonValue<int32_t>(json, kSourceId));
   ICEBERG_ASSIGN_OR_RAISE(
       auto transform,
-      GetJsonValue<std::string>(json, kTransform).and_then(TransformFunctionFromString));
+      GetJsonValue<std::string>(json, kTransform).and_then(TransformFromString));
   ICEBERG_ASSIGN_OR_RAISE(
       auto direction,
       GetJsonValue<std::string>(json, kDirection).and_then(SortDirectionFromString));
@@ -370,4 +373,50 @@ Result<std::unique_ptr<Schema>> SchemaFromJson(const nlohmann::json& json) {
   return FromStructType(std::move(struct_type), schema_id);
 }
 
+nlohmann::json ToJson(const PartitionField& partition_field) {
+  nlohmann::json json;
+  json[kSourceId] = partition_field.source_id();
+  json[kFieldId] = partition_field.field_id();
+  json[kTransform] = std::format("{}", *partition_field.transform());
+  json[kName] = partition_field.name();
+  return json;
+}
+
+nlohmann::json ToJson(const PartitionSpec& partition_spec) {
+  nlohmann::json json;
+  json[kSpecId] = partition_spec.spec_id();
+
+  nlohmann::json fields_json = nlohmann::json::array();
+  for (const auto& field : partition_spec.fields()) {
+    fields_json.push_back(ToJson(field));
+  }
+  json[kFields] = fields_json;
+  return json;
+}
+
+Result<std::unique_ptr<PartitionField>> PartitionFieldFromJson(
+    const nlohmann::json& json) {
+  ICEBERG_ASSIGN_OR_RAISE(auto source_id, GetJsonValue<int32_t>(json, kSourceId));
+  ICEBERG_ASSIGN_OR_RAISE(auto field_id, GetJsonValue<int32_t>(json, kFieldId));
+  ICEBERG_ASSIGN_OR_RAISE(
+      auto transform,
+      GetJsonValue<std::string>(json, kTransform).and_then(TransformFromString));
+  ICEBERG_ASSIGN_OR_RAISE(auto name, GetJsonValue<std::string>(json, kName));
+  return std::make_unique<PartitionField>(source_id, field_id, name,
+                                          std::move(transform));
+}
+
+Result<std::unique_ptr<PartitionSpec>> PartitionSpecFromJson(
+    const std::shared_ptr<Schema>& schema, const nlohmann::json& json) {
+  ICEBERG_ASSIGN_OR_RAISE(auto spec_id, GetJsonValue<int32_t>(json, kSpecId));
+  ICEBERG_ASSIGN_OR_RAISE(auto fields, GetJsonValue<nlohmann::json>(json, kFields));
+
+  std::vector<PartitionField> partition_fields;
+  for (const auto& field_json : fields) {
+    ICEBERG_ASSIGN_OR_RAISE(auto partition_field, PartitionFieldFromJson(field_json));
+    partition_fields.push_back(std::move(*partition_field));
+  }
+  return std::make_unique<PartitionSpec>(schema, spec_id, std::move(partition_fields));
+}
+
 }  // namespace iceberg

src/iceberg/json_internal.h

@@ -20,11 +20,9 @@
 #pragma once
 
 #include <memory>
-#include <string_view>
 
 #include <nlohmann/json_fwd.hpp>
 
-#include "iceberg/expected.h"
 #include "iceberg/result.h"
 #include "iceberg/type_fwd.h"
 
@@ -108,4 +106,51 @@ Result<std::unique_ptr<Type>> TypeFromJson(const nlohmann::json& json);
 /// \return The Iceberg field or an error if the conversion fails.
 Result<std::unique_ptr<SchemaField>> FieldFromJson(const nlohmann::json& json);
 
+/// \brief Serializes a `PartitionField` object to JSON.
+///
+/// This function converts a `PartitionField` object into a JSON representation.
+/// The resulting JSON object includes the transform type, source ID, field ID, and
+/// name.
+///
+/// \param partition_field The `PartitionField` object to be serialized.
+/// \return A JSON object representing the `PartitionField` in the form of key-value
+/// pairs.
+nlohmann::json ToJson(const PartitionField& partition_field);
+
+/// \brief Serializes a `PartitionSpec` object to JSON.
+///
+/// This function converts a `PartitionSpec` object into a JSON representation.
+/// The resulting JSON includes the spec ID and a list of `PartitionField` objects.
+/// Each `PartitionField` is serialized as described in the `ToJson(PartitionField)`
+/// function.
+///
+/// \param partition_spec The `PartitionSpec` object to be serialized.
+/// \return A JSON object representing the `PartitionSpec` with its order ID and fields
+/// array.
+nlohmann::json ToJson(const PartitionSpec& partition_spec);
+
+/// \brief Deserializes a JSON object into a `PartitionField` object.
+///
+/// This function parses the provided JSON and creates a `PartitionField` object.
+/// It expects the JSON object to contain keys for the transform, source ID, field ID,
+/// and name.
+///
+/// \param json The JSON object representing a `PartitionField`.
+/// \return An `expected` value containing either a `PartitionField` object or an error.
+/// If the JSON is malformed or missing expected fields, an error will be returned.
+Result<std::unique_ptr<PartitionField>> PartitionFieldFromJson(
+    const nlohmann::json& json);
+
+/// \brief Deserializes a JSON object into a `PartitionSpec` object.
+///
+/// This function parses the provided JSON and creates a `PartitionSpec` object.
+/// It expects the JSON object to contain the spec ID and a list of `PartitionField`
+/// objects. Each `PartitionField` will be parsed using the `PartitionFieldFromJson`
+/// function.
+///
+/// \param json The JSON object representing a `PartitionSpec`.
+/// \return An `expected` value containing either a `PartitionSpec` object or an error. If
+/// 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);
 }  // namespace iceberg

src/iceberg/partition_field.cc

@@ -23,12 +23,12 @@
 
 #include "iceberg/transform.h"
 #include "iceberg/type.h"
-#include "iceberg/util/formatter.h"
+#include "iceberg/util/formatter.h"  // IWYU pragma: keep
 
 namespace iceberg {
 
 PartitionField::PartitionField(int32_t source_id, int32_t field_id, std::string name,
-                               std::shared_ptr<TransformFunction> transform)
+                               std::shared_ptr<Transform> transform)
     : source_id_(source_id),
       field_id_(field_id),
       name_(std::move(name)),
@@ -40,9 +40,7 @@ int32_t PartitionField::field_id() const { return field_id_; }
 
 std::string_view PartitionField::name() const { return name_; }
 
-std::shared_ptr<TransformFunction> const& PartitionField::transform() const {
-  return transform_;
-}
+std::shared_ptr<Transform> const& PartitionField::transform() const { return transform_; }
 
 std::string PartitionField::ToString() const {
   return std::format("{} ({} {}({}))", name_, field_id_, *transform_, source_id_);

src/iceberg/partition_field.h

@@ -26,7 +26,6 @@
 #include <memory>
 #include <string>
 #include <string_view>
-#include <vector>
 
 #include "iceberg/iceberg_export.h"
 #include "iceberg/type_fwd.h"
@@ -43,7 +42,7 @@ class ICEBERG_EXPORT PartitionField : public util::Formattable {
   /// \param[in] name The partition field name.
   /// \param[in] transform The transform function.
   PartitionField(int32_t source_id, int32_t field_id, std::string name,
-                 std::shared_ptr<TransformFunction> transform);
+                 std::shared_ptr<Transform> transform);
 
   /// \brief Get the source field ID.
   int32_t source_id() const;
@@ -55,7 +54,7 @@ class ICEBERG_EXPORT PartitionField : public util::Formattable {
   std::string_view name() const;
 
   /// \brief Get the transform type.
-  std::shared_ptr<TransformFunction> const& transform() const;
+  std::shared_ptr<Transform> const& transform() const;
 
   std::string ToString() const override;
 
@@ -74,7 +73,7 @@ class ICEBERG_EXPORT PartitionField : public util::Formattable {
   int32_t source_id_;
   int32_t field_id_;
   std::string name_;
-  std::shared_ptr<TransformFunction> transform_;
+  std::shared_ptr<Transform> transform_;
 };
 
 }  // namespace iceberg

src/iceberg/partition_spec.cc

@@ -23,7 +23,7 @@
 
 #include "iceberg/schema.h"
 #include "iceberg/type.h"
-#include "iceberg/util/formatter.h"
+#include "iceberg/util/formatter.h"  // IWYU pragma: keep
 
 namespace iceberg {
 

src/iceberg/schema_field.cc

@@ -22,7 +22,7 @@
 #include <format>
 
 #include "iceberg/type.h"
-#include "iceberg/util/formatter.h"
+#include "iceberg/util/formatter.h"  // IWYU pragma: keep
 
 namespace iceberg {
 

src/iceberg/schema_internal.cc

@@ -24,7 +24,6 @@
 #include <optional>
 #include <string>
 
-#include "iceberg/expected.h"
 #include "iceberg/schema.h"
 #include "iceberg/type.h"
 

src/iceberg/schema_internal.h

@@ -23,7 +23,6 @@
 
 #include <nanoarrow/nanoarrow.h>
 
-#include "iceberg/expected.h"
 #include "iceberg/result.h"
 #include "iceberg/type_fwd.h"