fix(schema): address review nits on default-value validation/serde

- ValidateDefault: use internal::checked_pointer_cast and ICEBERG_ASSIGN_OR_RAISE
  so an uncastable default surfaces the original CastTo error instead of a generic
  message; keep the out-of-range (sentinel) case as an invalid-schema error.
- json_serde: error out directly when a timestamptz default is not a string, drop
  the offset-specific wording from the UTC error message (it also accepts -00:00),
  and use auto for the parsed default JSON.
- Update schema tests for the propagated cast error and the out-of-range case.

Author: huan233usc

src/iceberg/json_serde.cc

@@ -578,15 +578,14 @@ Status ValidateTimestamptzDefaultIsUtc(const Type& type, const nlohmann::json& v
     return {};
   }
   if (!value.is_string()) {
-    // Let LiteralFromJson report the type mismatch.
-    return {};
+    return JsonParseError("Invalid timestamptz default {} for {}: expected a string",
+                          SafeDumpJson(value), type.ToString());
   }
   const auto str = value.get<std::string>();
   ICEBERG_ASSIGN_OR_RAISE(bool is_utc, TemporalUtils::IsUtcOffset(str));
   if (!is_utc) {
     return JsonParseError(
-        "Invalid timestamptz default '{}' for {}: default values must use UTC "
-        "(offset 'Z' or '+00:00')",
+        "Invalid timestamptz default '{}' for {}: default values must use a UTC offset",
         str, type.ToString());
   }
   return {};
@@ -601,9 +600,9 @@ Result<std::unique_ptr<SchemaField>> FieldFromJson(const nlohmann::json& json) {
   ICEBERG_ASSIGN_OR_RAISE(auto name, GetJsonValue<std::string>(json, kName));
   ICEBERG_ASSIGN_OR_RAISE(auto required, GetJsonValue<bool>(json, kRequired));
   ICEBERG_ASSIGN_OR_RAISE(auto doc, GetJsonValueOrDefault<std::string>(json, kDoc));
-  ICEBERG_ASSIGN_OR_RAISE(std::optional<nlohmann::json> initial_default_json,
+  ICEBERG_ASSIGN_OR_RAISE(auto initial_default_json,
                           GetJsonValueOptional<nlohmann::json>(json, kInitialDefault));
-  ICEBERG_ASSIGN_OR_RAISE(std::optional<nlohmann::json> write_default_json,
+  ICEBERG_ASSIGN_OR_RAISE(auto write_default_json,
                           GetJsonValueOptional<nlohmann::json>(json, kWriteDefault));
 
   std::shared_ptr<const Literal> initial_default;

src/iceberg/schema_field.cc

@@ -25,6 +25,7 @@
 
 #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"
 
@@ -107,11 +108,11 @@ Status ValidateDefault(const SchemaField& field, const Literal& value,
   // a string default on a date/timestamp/uuid field). Reject only defaults that cannot
   // be cast to the field type or fall outside its range (CastTo signals out-of-range as
   // an above-max/below-min sentinel).
-  auto field_type = std::static_pointer_cast<PrimitiveType>(field.type());
-  auto cast = value.CastTo(field_type);
-  if (!cast.has_value() || cast->IsAboveMax() || cast->IsBelowMin()) {
-    return InvalidSchema("{} of field {} has type {} that cannot be cast to {}", kind,
-                         field.name(), *value.type(), *field.type());
+  auto field_type = internal::checked_pointer_cast<PrimitiveType>(field.type());
+  ICEBERG_ASSIGN_OR_RAISE(auto cast, value.CastTo(field_type));
+  if (cast.IsAboveMax() || cast.IsBelowMin()) {
+    return InvalidSchema("{} of field {} ({}) is out of range for {}", kind, field.name(),
+                         *value.type(), *field.type());
   }
   return {};
 }

src/iceberg/test/schema_test.cc

@@ -162,9 +162,11 @@ TEST(SchemaTest, ValidateRejectsMismatchedDefaultValue) {
       1, "id", iceberg::int32(), false, /*doc=*/{}, /*initial_default=*/nullptr,
       std::make_shared<const iceberg::Literal>(iceberg::Literal::String("oops")))});
 
+  // The default literal is cast to the field type; an uncastable type surfaces the
+  // original cast error.
   auto status = schema.Validate(iceberg::TableMetadata::kSupportedTableFormatVersion);
-  ASSERT_THAT(status, iceberg::IsError(iceberg::ErrorKind::kInvalidSchema));
-  EXPECT_THAT(status, iceberg::HasErrorMessage("write-default"));
+  ASSERT_THAT(status, iceberg::IsError(iceberg::ErrorKind::kNotSupported));
+  EXPECT_THAT(status, iceberg::HasErrorMessage("Cast from String"));
 }
 
 TEST(SchemaTest, ValidateCastsDefaultToFieldType) {
@@ -176,11 +178,12 @@ TEST(SchemaTest, ValidateCastsDefaultToFieldType) {
   EXPECT_THAT(widened.Validate(iceberg::TableMetadata::kSupportedTableFormatVersion),
               iceberg::IsOk());
 
-  // A default whose type cannot be cast to the field type is still rejected.
-  iceberg::Schema uncastable({iceberg::SchemaField(
+  // A default outside the field type's range is rejected (CastTo returns an
+  // above-max/below-min sentinel).
+  iceberg::Schema out_of_range({iceberg::SchemaField(
       1, "id", iceberg::int32(), false, /*doc=*/{},
-      std::make_shared<const iceberg::Literal>(iceberg::Literal::String("oops")))});
-  EXPECT_THAT(uncastable.Validate(iceberg::TableMetadata::kSupportedTableFormatVersion),
+      std::make_shared<const iceberg::Literal>(iceberg::Literal::Long(5'000'000'000)))});
+  EXPECT_THAT(out_of_range.Validate(iceberg::TableMetadata::kSupportedTableFormatVersion),
               iceberg::IsError(iceberg::ErrorKind::kInvalidSchema));
 }