guard decimal default fast path against null and out-of-precision values

Author: huan233usc

src/iceberg/test/update_schema_test.cc

@@ -418,6 +418,32 @@ TEST_F(UpdateSchemaDefaultValueTest, UpdateColumnDefaultDifferentScaleDecimalFai
   EXPECT_THAT(result, HasErrorMessage("Cannot cast default value"));
 }
 
+TEST_F(UpdateSchemaDefaultValueTest, AddColumnWithOutOfPrecisionDecimalDefaultFails) {
+  // A same-scale decimal default whose unscaled value exceeds the column precision is
+  // rejected here, rather than being relabeled and later rejected by the JSON parser when
+  // the metadata is read back.
+  ICEBERG_UNWRAP_OR_FAIL(auto update, table_->NewUpdateSchema());
+  update->AddColumn("new_col", decimal(4, 2), "A decimal column",
+                    Literal::Decimal(1234567, 9, 2));
+
+  auto result = update->Apply();
+  EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+  EXPECT_THAT(result, HasErrorMessage("Cannot cast default value"));
+}
+
+TEST_F(UpdateSchemaDefaultValueTest, AddColumnWithTypedNullDecimalDefaultFails) {
+  // A typed null default carries decimal type metadata but no Decimal payload; the
+  // same-scale fast path must not read a Decimal out of it (which would be undefined),
+  // so it falls through and is rejected as a null default.
+  ICEBERG_UNWRAP_OR_FAIL(auto update, table_->NewUpdateSchema());
+  update->AddColumn("new_col", decimal(18, 2), "A decimal column",
+                    Literal::Null(decimal(18, 2)));
+
+  auto result = update->Apply();
+  EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+  EXPECT_THAT(result, HasErrorMessage("Cannot cast default value"));
+}
+
 TEST_F(UpdateSchemaTest, AddMultipleColumns) {
   ICEBERG_UNWRAP_OR_FAIL(auto update, table_->NewUpdateSchema());
   update->AddColumn("col1", int32(), "First column")

src/iceberg/update/update_schema.cc

@@ -300,18 +300,33 @@ std::vector<SchemaField> ApplyChangesVisitor::MoveFields(
 /// other conversions delegate to `CastTo`, which reports narrowing via AboveMax/BelowMin
 /// sentinels that callers reject.
 ///
+/// The fast path only fires for a literal that actually holds a `Decimal` value: a typed
+/// null default (`Literal::Null(decimal(...))`) or a sentinel carries decimal type
+/// metadata but no `Decimal` payload, so those fall through to `CastTo` and are handled
+/// by the same null/sentinel rejection the callers already apply, rather than being
+/// force-relabeled.
+///
 /// \pre `target_type` is non-null; every caller passes a resolved field type. `value` is
 /// the caller's dereferenced default, so a missing default must be filtered out before
 /// this is reached.
 Result<Literal> CastDefaultToType(const Literal& value,
                                   const std::shared_ptr<PrimitiveType>& target_type) {
-  if (value.type()->type_id() == TypeId::kDecimal &&
-      target_type->type_id() == TypeId::kDecimal) {
+  if (target_type->type_id() == TypeId::kDecimal &&
+      std::holds_alternative<Decimal>(value.value())) {
     const auto& source_type = internal::checked_cast<const DecimalType&>(*value.type());
     const auto& decimal_type = internal::checked_cast<const DecimalType&>(*target_type);
     if (source_type.scale() == decimal_type.scale()) {
-      return Literal::Decimal(std::get<Decimal>(value.value()).value(),
-                              decimal_type.precision(), decimal_type.scale());
+      const auto& decimal_value = std::get<Decimal>(value.value());
+      // Relabeling keeps the unscaled value but adopts the target precision, so reject a
+      // value that does not fit it. Otherwise the widened literal passes schema
+      // validation yet serializes to metadata the JSON parser later rejects for exceeding
+      // precision.
+      if (!decimal_value.FitsInPrecision(decimal_type.precision())) {
+        return InvalidArgument("Cannot cast default value to {}: {}", *target_type,
+                               value);
+      }
+      return Literal::Decimal(decimal_value.value(), decimal_type.precision(),
+                              decimal_type.scale());
     }
   }
   return value.CastTo(target_type);