handle negative and out-of-range decimal scales in numeric casts

Author: huan233usc

src/iceberg/expression/literal.cc

@@ -104,69 +104,83 @@ Literal LiteralCaster::AboveMaxLiteral(std::shared_ptr<PrimitiveType> type) {
   return Literal(Literal::AboveMax{}, std::move(type));
 }
 
+namespace {
+
+// Rescale `unscaled` (interpreted at `from_scale`) to `to_scale` using HALF_UP rounding
+// (round half away from zero), matching Java's BigDecimal.setScale(scale, HALF_UP).
+// Unlike Decimal::Rescale, which only truncates and rejects any dropped remainder, this
+// rounds, and it supports the full negative..positive scale range Iceberg decimals allow.
+Result<Decimal> RescaleHalfUp(const Decimal& unscaled, int32_t from_scale,
+                              int32_t to_scale, bool negative) {
+  const int32_t delta = to_scale - from_scale;
+  if (delta == 0) {
+    return unscaled;
+  }
+  if (delta > 0) {
+    // Growing the scale multiplies by 10^delta and is exact; Rescale rejects overflow.
+    if (delta > Decimal::kMaxScale) {
+      return InvalidArgument("scale change {} exceeds the maximum {}", delta,
+                             Decimal::kMaxScale);
+    }
+    return unscaled.Rescale(from_scale, to_scale);
+  }
+  // Shrinking the scale drops `drop` digits with HALF_UP rounding. A drop larger than the
+  // digits any decimal can hold rounds everything away, so the result is zero (e.g.
+  // 1e-100 to decimal(9, 2)); this also keeps the divisor within the powers-of-ten table.
+  const int32_t drop = -delta;
+  if (drop > Decimal::kMaxScale) {
+    return Decimal(0);
+  }
+  ICEBERG_ASSIGN_OR_RAISE(auto divisor, Decimal(1).Rescale(0, drop));
+  ICEBERG_ASSIGN_OR_RAISE(auto divmod, unscaled.Divide(divisor));
+  Decimal quotient = divmod.first;
+  Decimal remainder = Decimal::Abs(divmod.second);
+  if (remainder * Decimal(2) >= divisor) {
+    quotient += negative ? Decimal(-1) : Decimal(1);
+  }
+  return quotient;
+}
+
+}  // namespace
+
 Result<Literal> LiteralCaster::CastIntegerToDecimal(
     int64_t value, const std::shared_ptr<PrimitiveType>& target_type) {
   const auto& decimal_type = internal::checked_cast<const DecimalType&>(*target_type);
-  const int32_t scale = decimal_type.scale();
-  // DecimalType does not bound its scale, but Rescale indexes a powers-of-ten table sized
-  // for [0, kMaxScale]; reject an out-of-range scale here rather than reading past it.
-  if (scale < 0 || scale > Decimal::kMaxScale) {
-    return InvalidArgument("Cannot cast {} as a {} value", value,
-                           target_type->ToString());
-  }
-  // An integer has scale 0, so scaling it to the target scale multiplies the unscaled
-  // value by 10^scale; Rescale rejects a target scale that would overflow the value.
-  ICEBERG_ASSIGN_OR_RAISE(auto decimal, Decimal(value).Rescale(0, scale));
-  if (!decimal.FitsInPrecision(decimal_type.precision())) {
+  // An integer has scale 0; rescale it to the target scale, rounding HALF_UP when the
+  // target scale is negative (matching Java's numeric-to-decimal default handling).
+  ICEBERG_ASSIGN_OR_RAISE(auto unscaled, RescaleHalfUp(Decimal(value), /*from_scale=*/0,
+                                                       decimal_type.scale(), value < 0));
+  if (!unscaled.FitsInPrecision(decimal_type.precision())) {
     return InvalidArgument("Cannot cast {} as a {} value", value,
                            target_type->ToString());
   }
-  return Literal::Decimal(decimal.value(), decimal_type.precision(),
+  return Literal::Decimal(unscaled.value(), decimal_type.precision(),
                           decimal_type.scale());
 }
 
 Result<Literal> LiteralCaster::CastRealToDecimal(
     double value, const std::shared_ptr<PrimitiveType>& target_type) {
   const auto& decimal_type = internal::checked_cast<const DecimalType&>(*target_type);
-  const int32_t target_scale = decimal_type.scale();
-  if (target_scale < 0 || target_scale > Decimal::kMaxScale) {
-    return InvalidArgument("Cannot cast {} as a {} value", value,
-                           target_type->ToString());
-  }
   if (!std::isfinite(value)) {
     return InvalidArgument("Cannot cast {} as a {} value", value,
                            target_type->ToString());
   }
 
   // Parse the shortest round-tripping decimal representation of the value (matching
   // Java's BigDecimal.valueOf(double), which goes through Double.toString) into a
-  // full-precision decimal, then round to the target scale below.
+  // full-precision decimal, then round to the target scale.
   int32_t parsed_scale = 0;
   ICEBERG_ASSIGN_OR_RAISE(
       auto parsed, Decimal::FromString(std::format("{}", value), nullptr, &parsed_scale));
 
-  Decimal unscaled = parsed;
-  if (parsed_scale > target_scale) {
-    // Drop excess fractional digits with HALF_UP rounding (round half away from zero, as
-    // Java does), since Rescale itself only truncates and rejects any dropped remainder.
-    const int32_t drop = parsed_scale - target_scale;
-    ICEBERG_ASSIGN_OR_RAISE(auto divisor, Decimal(1).Rescale(0, drop));
-    ICEBERG_ASSIGN_OR_RAISE(auto divmod, parsed.Divide(divisor));
-    Decimal quotient = divmod.first;
-    Decimal remainder = Decimal::Abs(divmod.second);
-    if (remainder * Decimal(2) >= divisor) {
-      quotient += (value < 0) ? Decimal(-1) : Decimal(1);
-    }
-    unscaled = quotient;
-  } else if (parsed_scale < target_scale) {
-    ICEBERG_ASSIGN_OR_RAISE(unscaled, parsed.Rescale(parsed_scale, target_scale));
-  }
-
+  ICEBERG_ASSIGN_OR_RAISE(auto unscaled, RescaleHalfUp(parsed, parsed_scale,
+                                                       decimal_type.scale(), value < 0));
   if (!unscaled.FitsInPrecision(decimal_type.precision())) {
     return InvalidArgument("Cannot cast {} as a {} value", value,
                            target_type->ToString());
   }
-  return Literal::Decimal(unscaled.value(), decimal_type.precision(), target_scale);
+  return Literal::Decimal(unscaled.value(), decimal_type.precision(),
+                          decimal_type.scale());
 }
 
 Result<Literal> LiteralCaster::CastFromInt(

src/iceberg/test/literal_test.cc

@@ -171,6 +171,12 @@ TEST(LiteralTest, IntegerCastToDecimal) {
   // (DecimalType does not bound its scale on construction).
   EXPECT_THAT(Literal::Int(1).CastTo(std::make_shared<DecimalType>(9, 40)),
               IsError(ErrorKind::kInvalidArgument));
+
+  // Negative scale: decimal(9, -2) scales by 10^2, so 149 rounds HALF_UP to 100 (unscaled
+  // value 1 at scale -2), matching Java's setScale(-2, HALF_UP).
+  auto neg_scale = Literal::Int(149).CastTo(decimal(9, -2));
+  ASSERT_THAT(neg_scale, IsOk());
+  EXPECT_EQ(*neg_scale, Literal::Decimal(1, 9, -2));
 }
 
 TEST(LiteralTest, RealCastToDecimal) {
@@ -206,6 +212,18 @@ TEST(LiteralTest, RealCastToDecimal) {
   EXPECT_THAT(
       Literal::Double(std::numeric_limits<double>::quiet_NaN()).CastTo(decimal(4, 2)),
       IsError(ErrorKind::kInvalidArgument));
+
+  // A magnitude far smaller than the target scale rounds to zero rather than indexing
+  // past the powers-of-ten table (Java rounds 1e-100 to 0.00).
+  auto tiny = Literal::Double(1e-100).CastTo(decimal(9, 2));
+  ASSERT_THAT(tiny, IsOk());
+  EXPECT_EQ(*tiny, Literal::Decimal(0, 9, 2));
+
+  // Negative scale: decimal(9, -2) scales by 10^2, so 149 rounds HALF_UP to 100 (unscaled
+  // value 1 at scale -2), matching Java's setScale(-2, HALF_UP).
+  auto neg_scale = Literal::Double(149.0).CastTo(decimal(9, -2));
+  ASSERT_THAT(neg_scale, IsOk());
+  EXPECT_EQ(*neg_scale, Literal::Decimal(1, 9, -2));
 }
 
 // Error cases for casts