Function round_decimal

datafusion/spark/src/function/math/round.rs:317–370

Round a decimal value represented as its unscaled integer using HALF_UP rounding mode (ties round away from zero). This matches Spark's `RoundBase` behaviour for `DecimalType`, which calls `BigDecimal.setScale(scale, RoundingMode.HALF_UP)`. Decimals are stored as `(unscaled_value, precision, scale)` where the real value equals `unscaled_value * 10^(-scale)`. This function operates on the unscal

(
    value: V,
    input_scale: i8,
    decimal_places: i32,
)

/// round_decimal(2345_i128, 3, 2) → Ok(2350)
/// ```
fn round_decimal<V: ArrowNativeTypeOp>(
    value: V,
    input_scale: i8,
    decimal_places: i32,
) -> Result<V> {
    let diff = i64::from(input_scale) - i64::from(decimal_places);
    if diff <= 0 {
        // Nothing to round – the requested precision is finer than (or equal to) the
        // stored scale.
        return Ok(value);
    }

    let diff = diff as u32;

    let one = V::ONE;
    let two = V::from_usize(2).ok_or_else(|| {
        (exec_err!("Internal error: could not create constant 2") as Result<(), _>)
            .unwrap_err()
    })?;
    let ten = V::from_usize(10).ok_or_else(|| {
        (exec_err!("Internal error: could not create constant 10") as Result<(), _>)
            .unwrap_err()
    })?;

    let Ok(factor) = ten.pow_checked(diff) else {
        // 10^diff overflows the decimal type — the rounding position is beyond
        // the representable range, so any value rounds to 0.
        // This matches Spark's BigDecimal.setScale behavior where rounding to a
        // scale far beyond the number's magnitude yields 0.
        return Ok(V::ZERO);
    };

    let mut quotient = value.div_wrapping(factor);
    let remainder = value.mod_wrapping(factor);

    // HALF_UP: round away from zero when remainder is exactly half
    let threshold = factor.div_wrapping(two);
    if remainder >= threshold {
        quotient = quotient.add_checked(one).map_err(|_| {
            (exec_err!("Overflow while rounding decimal") as Result<(), _>).unwrap_err()
        })?;
    } else if remainder <= threshold.neg_wrapping() {
        quotient = quotient.sub_checked(one).map_err(|_| {
            (exec_err!("Overflow while rounding decimal") as Result<(), _>).unwrap_err()
        })?;
    }

    // Re-scale the quotient back to `input_scale` so the returned unscaled integer is
    // at the original scale. `factor` is already `10^diff` which is exactly the shift
    // we need.
    quotient.mul_checked(factor).map_err(|_| {
        (exec_err!("Overflow while rounding decimal") as Result<(), _>).unwrap_err()
    })
}

// ---------------------------------------------------------------------------
// Macros for array dispatch