reject decimal default with mismatched scale

Guard the decimal default fast path in CastDefaultToType with a same-scale
check. Decimal stores only the unscaled value, so rebuilding a decimal(9,3)
default as decimal(18,2) would reinterpret 1234 from 1.234 to 12.34. Only
same-scale precision widening is accepted; a differing scale falls through to
CastTo and is rejected, matching Java's requirement that a decimal default's
scale match the column type.

Author: huan233usc

src/iceberg/test/update_schema_test.cc

@@ -396,6 +396,28 @@ TEST_F(UpdateSchemaDefaultValueTest, UpdateColumnDefaultWiderPrecisionDecimal) {
   EXPECT_EQ(*field.write_default(), Literal::Decimal(1234, 18, 2));
 }
 
+TEST_F(UpdateSchemaDefaultValueTest, AddColumnWithDifferentScaleDecimalDefaultFails) {
+  // A decimal default whose scale differs from the column is rejected, not silently
+  // reinterpreted: the unscaled value only keeps its meaning at the same scale.
+  ICEBERG_UNWRAP_OR_FAIL(auto update, table_->NewUpdateSchema());
+  update->AddColumn("new_col", decimal(18, 2), "A decimal column",
+                    Literal::Decimal(1234, 9, 3));
+
+  auto result = update->Apply();
+  EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+  EXPECT_THAT(result, HasErrorMessage("Cannot cast default value"));
+}
+
+TEST_F(UpdateSchemaDefaultValueTest, UpdateColumnDefaultDifferentScaleDecimalFails) {
+  ICEBERG_UNWRAP_OR_FAIL(auto update, table_->NewUpdateSchema());
+  update->AddColumn("new_col", decimal(18, 2), "A decimal column")
+      .UpdateColumnDefault("new_col", Literal::Decimal(1234, 9, 3));
+
+  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

@@ -292,17 +292,23 @@ std::vector<SchemaField> ApplyChangesVisitor::MoveFields(
 /// \brief Cast a default value literal to a target primitive type.
 ///
 /// `Literal::CastTo` only returns a value for identical decimal types, but schema
-/// evolution permits widening a decimal to a larger precision at the same scale. Such a
+/// evolution permits widening a decimal to a larger precision at the SAME scale. Such a
 /// promotion leaves the unscaled value unchanged, so the literal is rebuilt with the
-/// target type instead of going through `CastTo`. All other conversions delegate to
-/// `CastTo`, which reports narrowing via AboveMax/BelowMin sentinels that callers reject.
+/// target type instead of going through `CastTo`. A scale change is NOT handled here: the
+/// unscaled value only keeps its meaning at the same scale (a decimal default must match
+/// the column scale), so differing scales fall through to `CastTo` and are rejected. All
+/// other conversions delegate to `CastTo`, which reports narrowing via AboveMax/BelowMin
+/// sentinels that callers reject.
 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) {
+    const auto& source_type = internal::checked_cast<const DecimalType&>(*value.type());
     const auto& decimal_type = internal::checked_cast<const DecimalType&>(*target_type);
-    return Literal::Decimal(std::get<Decimal>(value.value()).value(),
-                            decimal_type.precision(), decimal_type.scale());
+    if (source_type.scale() == decimal_type.scale()) {
+      return Literal::Decimal(std::get<Decimal>(value.value()).value(),
+                              decimal_type.precision(), decimal_type.scale());
+    }
   }
   return value.CastTo(target_type);
 }