fix(schema): model a null default value as absence

Per review, a present-null default (Literal::Null) is no longer rejected: it is
modeled as the absence of a default (matching Java), and dropped at construction so it
is never stored. This also makes two such fields compare equal with no change to
Literal::operator<=> (no null Literal is ever stored or compared), so the global
comparison semantics used by expression predicates are left untouched.

Author: huan233usc

src/iceberg/schema_field.cc

@@ -43,7 +43,8 @@ Result<std::shared_ptr<const Literal>> NormalizeDefault(
   if (value == nullptr || field_type == nullptr || !field_type->is_primitive()) {
     return value;
   }
-  if (*value->type() == *field_type) {
+  if (value->IsNull() || *value->type() == *field_type) {
+    // A null default is modeled as absence (dropped at construction), so do not cast it.
     return value;
   }
   ICEBERG_ASSIGN_OR_RAISE(
@@ -56,6 +57,15 @@ Result<std::shared_ptr<const Literal>> NormalizeDefault(
   return std::make_shared<const Literal>(std::move(cast));
 }
 
+// A null default value is modeled as the absence of a default (matching Java), so it is
+// not stored.
+std::shared_ptr<const Literal> DropNullDefault(std::shared_ptr<const Literal> value) {
+  if (value != nullptr && value->IsNull()) {
+    return nullptr;
+  }
+  return value;
+}
+
 }  // namespace
 
 SchemaField::SchemaField(int32_t field_id, std::string_view name,
@@ -67,8 +77,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_(DropNullDefault(std::move(initial_default))),
+      write_default_(DropNullDefault(std::move(write_default))) {}
 
 Result<SchemaField> SchemaField::Make(int32_t field_id, std::string_view name,
                                       std::shared_ptr<Type> type, bool optional,
@@ -115,8 +125,10 @@ namespace {
 
 Status ValidateDefault(const SchemaField& field, const Literal& value,
                        std::string_view kind) {
-  if (value.IsNull() || value.IsAboveMax() || value.IsBelowMin()) {
-    return InvalidSchema("Invalid {} value for {}: must be a non-null value", kind,
+  // A null default is modeled as absence and dropped at construction, so it never reaches
+  // here; only the out-of-range cast sentinels need rejecting.
+  if (value.IsAboveMax() || value.IsBelowMin()) {
+    return InvalidSchema("Invalid {} value for {}: value is out of range", kind,
                          field.name());
   }
   // Defaults are only supported on primitive fields. The spec also permits JSON

src/iceberg/test/schema_test.cc

@@ -193,6 +193,23 @@ TEST(SchemaTest, MakeNormalizesDefaultToFieldType) {
               iceberg::IsError(iceberg::ErrorKind::kNotSupported));
 }
 
+TEST(SchemaTest, NullDefaultModeledAsAbsence) {
+  // A present-null default is modeled as the absence of a default (matching Java): it is
+  // dropped at construction, so the field has no stored default and compares equal to a
+  // field with no default, and it validates cleanly.
+  iceberg::SchemaField with_null(
+      1, "id", iceberg::int32(), /*optional=*/true, /*doc=*/{},
+      std::make_shared<const iceberg::Literal>(iceberg::Literal::Null(iceberg::int32())));
+  EXPECT_EQ(with_null.initial_default(), nullptr);
+
+  iceberg::SchemaField no_default(1, "id", iceberg::int32(), /*optional=*/true);
+  EXPECT_EQ(with_null, no_default);
+
+  iceberg::Schema schema({with_null});
+  EXPECT_THAT(schema.Validate(iceberg::TableMetadata::kSupportedTableFormatVersion),
+              iceberg::IsOk());
+}
+
 TEST(SchemaTest, ReassignIdsPreservesDefaultValues) {
   // Reassigning field IDs rebuilds each SchemaField, so the rebuild must carry the
   // default values over to the field with the new ID.