fix(schema): normalize default value to the field type at construction

A cross-type default (e.g. an int literal on a long field, accepted to match
Java's cast behavior) was stored un-normalized, so projection materialized a
wrong-typed fill value and a ToJson/FieldFromJson round-trip compared unequal
(Int(34) vs Long(34)). Cast the default to the field type when constructing the
field; values that already match are untouched and uncastable ones are left for
Validate() to reject. Fixes the projection and round-trip-equality paths.

Author: huan233usc

src/iceberg/schema_field.cc

@@ -31,6 +31,31 @@
 
 namespace iceberg {
 
+namespace {
+
+// Normalizes a default value to the field type. A cross-type default (e.g. an int
+// literal on a long field) is accepted, so it is cast to the field type up front;
+// otherwise projection, JSON round-trip and equality would observe a literal whose type
+// differs from the field. A value that already matches the field type is returned as-is
+// (no needless copy), and a value that cannot be cast is left unchanged so Validate()
+// can report it.
+std::shared_ptr<const Literal> NormalizeDefault(std::shared_ptr<const Literal> value,
+                                                const std::shared_ptr<Type>& field_type) {
+  if (value == nullptr || field_type == nullptr || !field_type->is_primitive()) {
+    return value;
+  }
+  if (*value->type() == *field_type) {
+    return value;
+  }
+  auto cast = value->CastTo(internal::checked_pointer_cast<PrimitiveType>(field_type));
+  if (!cast.has_value() || cast->IsAboveMax() || cast->IsBelowMin()) {
+    return value;
+  }
+  return std::make_shared<const Literal>(std::move(cast).value());
+}
+
+}  // namespace
+
 SchemaField::SchemaField(int32_t field_id, std::string_view name,
                          std::shared_ptr<Type> type, bool optional, std::string_view doc,
                          std::shared_ptr<const Literal> initial_default,
@@ -40,8 +65,8 @@ SchemaField::SchemaField(int32_t field_id, std::string_view name,
       type_(std::move(type)),
       optional_(optional),
       doc_(doc),
-      initial_default_(std::move(initial_default)),
-      write_default_(std::move(write_default)) {}
+      initial_default_(NormalizeDefault(std::move(initial_default), type_)),
+      write_default_(NormalizeDefault(std::move(write_default), type_)) {}
 
 SchemaField SchemaField::MakeOptional(int32_t field_id, std::string_view name,
                                       std::shared_ptr<Type> type, std::string_view doc) {

src/iceberg/test/schema_json_test.cc

@@ -241,6 +241,22 @@ TEST(SchemaJsonTest, NestedFieldWithDefaultValuesRoundTrip) {
   ASSERT_EQ(schema_json.dump(), json);
 }
 
+TEST(SchemaJsonTest, CrossTypeDefaultNormalizedRoundTrip) {
+  // A programmatically-constructed cross-type default (an int literal on a long field) is
+  // normalized to the field type at construction, so it survives a ToJson/SchemaFromJson
+  // round-trip as an equal schema (an un-normalized int literal would compare unequal to
+  // the re-parsed long literal).
+  Schema original({SchemaField(1, "id", int64(), /*optional=*/false, /*doc=*/{},
+                               std::make_shared<const Literal>(Literal::Int(34)))});
+  const auto& field = original.fields()[0];
+  ASSERT_TRUE(field.initial_default().has_value());
+  EXPECT_EQ(field.initial_default()->get(), Literal::Long(34));
+
+  ICEBERG_UNWRAP_OR_FAIL(auto json, ToJson(original));
+  ICEBERG_UNWRAP_OR_FAIL(auto reparsed, SchemaFromJson(json));
+  EXPECT_EQ(original, *reparsed);
+}
+
 TEST(SchemaJsonTest, UnknownFieldRoundTrip) {
   constexpr std::string_view json =
       R"({"fields":[{"id":1,"name":"mystery","required":false,"type":"unknown"}],"schema-id":1,"type":"struct"})";

src/iceberg/test/schema_test.cc

@@ -177,6 +177,11 @@ TEST(SchemaTest, ValidateCastsDefaultToFieldType) {
       std::make_shared<const iceberg::Literal>(iceberg::Literal::Int(34)))});
   EXPECT_THAT(widened.Validate(iceberg::TableMetadata::kSupportedTableFormatVersion),
               iceberg::IsOk());
+  // The stored default is normalized to the field type (long), not kept as the narrower
+  // int literal, so projection/serialization/equality all observe a long.
+  const auto& widened_field = widened.fields()[0];
+  ASSERT_TRUE(widened_field.initial_default().has_value());
+  EXPECT_EQ(widened_field.initial_default()->get(), iceberg::Literal::Long(34));
 
   // A default outside the field type's range is rejected (CastTo returns an
   // above-max/below-min sentinel).