refactor(schema): drop unused default-value cast machinery

SchemaField::Make and the file-local NormalizeDefault cast a cross-type
default (e.g. an int literal on a long field) to the field type, but they
have no production callers: defaults arrive already at the field type
(FieldFromJson parses with the field type), and ValidateDefault's exact
type match already rejects any cross-type default. The cast was therefore
dead in production and, as wgtmac noted in review, allocated a new Literal
even in the same-type case.

Remove Make and NormalizeDefault (and their tests). The constructor stores
defaults verbatim and Validate rejects type mismatches. The cast belongs
in the follow-up that adds a real caller (e.g. schema evolution), where
Java performs it in the NestedField constructor (castDefault).

Author: huan233usc

src/iceberg/schema_field.cc

@@ -25,38 +25,13 @@
 
 #include "iceberg/expression/literal.h"
 #include "iceberg/type.h"
-#include "iceberg/util/checked_cast.h"
 #include "iceberg/util/formatter.h"  // IWYU pragma: keep
 #include "iceberg/util/macros.h"
 
 namespace iceberg {
 
 namespace {
 
-// Normalizes a default value to the field type so the stored value always matches the
-// field. A cross-type default (e.g. an int literal on a long field) is cast to the field
-// type; a value that already matches the field type, or a null, is returned unchanged.
-// The cast error is propagated and an out-of-range value is rejected rather than
-// swallowed.
-Result<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->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(
-      auto cast,
-      value->CastTo(internal::checked_pointer_cast<PrimitiveType>(field_type)));
-  if (cast.IsAboveMax() || cast.IsBelowMin()) {
-    return InvalidSchema("default value of type {} is out of range for {}",
-                         *value->type(), *field_type);
-  }
-  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) {
@@ -80,19 +55,6 @@ SchemaField::SchemaField(int32_t field_id, std::string_view name,
       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,
-                                      std::string_view doc,
-                                      std::shared_ptr<const Literal> initial_default,
-                                      std::shared_ptr<const Literal> write_default) {
-  ICEBERG_ASSIGN_OR_RAISE(initial_default,
-                          NormalizeDefault(std::move(initial_default), type));
-  ICEBERG_ASSIGN_OR_RAISE(write_default,
-                          NormalizeDefault(std::move(write_default), type));
-  return SchemaField(field_id, name, std::move(type), optional, doc,
-                     std::move(initial_default), std::move(write_default));
-}
-
 SchemaField SchemaField::MakeOptional(int32_t field_id, std::string_view name,
                                       std::shared_ptr<Type> type, std::string_view doc) {
   return {field_id, name, std::move(type), true, doc};
@@ -156,9 +118,8 @@ Status ValidateDefault(const SchemaField& field, const Literal& value,
         "Invalid {} value for {}: default values are only supported for primitive types",
         kind, field.name());
   }
-  // A default is normalized to the field type by SchemaField::Make (which casts a
-  // cross-type default and reports any cast error), so a stored default whose type does
-  // not match the field type is invalid here.
+  // Defaults are stored verbatim (no implicit cast), so a default whose literal type does
+  // not match the field type is invalid.
   if (*value.type() != *field.type()) {
     return InvalidSchema("{} of field {} has type {} but expected {}", kind, field.name(),
                          *value.type(), *field.type());

src/iceberg/schema_field.h

@@ -62,17 +62,6 @@ class ICEBERG_EXPORT SchemaField : public iceberg::util::Formattable {
   static SchemaField MakeRequired(int32_t field_id, std::string_view name,
                                   std::shared_ptr<Type> type, std::string_view doc = {});
 
-  /// \brief Construct a field, normalizing the default values to the field type.
-  ///
-  /// Unlike the constructor (which stores the defaults verbatim), this casts a default
-  /// whose literal type differs from the field type to the field type — e.g. an int
-  /// default on a long field — matching the spec/Java cast behavior. Returns an error if
-  /// a default cannot be cast to the field type or falls outside its range.
-  static Result<SchemaField> Make(
-      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 = nullptr,
-      std::shared_ptr<const Literal> write_default = nullptr);
-
   /// \brief Get the field ID.
   [[nodiscard]] int32_t field_id() const;
 

src/iceberg/test/schema_json_test.cc

@@ -241,23 +241,6 @@ TEST(SchemaJsonTest, NestedFieldWithDefaultValuesRoundTrip) {
   ASSERT_EQ(schema_json.dump(), json);
 }
 
-TEST(SchemaJsonTest, CrossTypeDefaultNormalizedRoundTrip) {
-  // A cross-type default (an int literal on a long field) built via SchemaField::Make is
-  // normalized to the field type, 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).
-  ICEBERG_UNWRAP_OR_FAIL(
-      auto field, SchemaField::Make(1, "id", int64(), /*optional=*/false, /*doc=*/{},
-                                    std::make_shared<const Literal>(Literal::Int(34))));
-  ASSERT_NE(field.initial_default(), nullptr);
-  EXPECT_EQ(*field.initial_default(), Literal::Long(34));
-
-  Schema original({std::move(field)});
-  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

@@ -158,8 +158,7 @@ TEST(SchemaTest, ValidateDoesNotVersionGateWriteDefault) {
 }
 
 TEST(SchemaTest, ValidateRejectsMismatchedDefaultValue) {
-  // The constructor stores defaults verbatim (normalization happens in
-  // SchemaField::Make), so a stored default whose type differs from the field type is
+  // Defaults are stored verbatim, so a default whose type differs from the field type is
   // rejected by Validate.
   iceberg::Schema schema({iceberg::SchemaField(
       1, "id", iceberg::int32(), false, /*doc=*/{}, /*initial_default=*/nullptr,
@@ -170,29 +169,6 @@ TEST(SchemaTest, ValidateRejectsMismatchedDefaultValue) {
   EXPECT_THAT(status, iceberg::HasErrorMessage("write-default"));
 }
 
-TEST(SchemaTest, MakeNormalizesDefaultToFieldType) {
-  // Make casts a cross-type default to the field type (int -> long) and stores the
-  // normalized value, so projection/serialization/equality all observe a long.
-  ICEBERG_UNWRAP_OR_FAIL(
-      auto field, iceberg::SchemaField::Make(1, "id", iceberg::int64(), false, /*doc=*/{},
-                                             std::make_shared<const iceberg::Literal>(
-                                                 iceberg::Literal::Int(34))));
-  ASSERT_NE(field.initial_default(), nullptr);
-  EXPECT_EQ(*field.initial_default(), iceberg::Literal::Long(34));
-
-  // A default outside the field type's range is rejected by Make.
-  EXPECT_THAT(iceberg::SchemaField::Make(1, "id", iceberg::int32(), false, /*doc=*/{},
-                                         std::make_shared<const iceberg::Literal>(
-                                             iceberg::Literal::Long(5'000'000'000))),
-              iceberg::IsError(iceberg::ErrorKind::kInvalidSchema));
-
-  // A default whose type cannot be cast to the field type surfaces the cast error.
-  EXPECT_THAT(iceberg::SchemaField::Make(1, "id", iceberg::int32(), false, /*doc=*/{},
-                                         std::make_shared<const iceberg::Literal>(
-                                             iceberg::Literal::String("oops"))),
-              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