Function round_integer

datafusion/spark/src/function/math/round.rs:236–276

Round an integer value to the given scale using HALF_UP rounding mode. Only meaningful when `scale` is negative — a non-negative scale leaves the integer unchanged because integers have no fractional part. This matches Spark's `RoundBase` behaviour for `ByteType`, `ShortType`, `IntegerType`, and `LongType`, which round to the nearest power-of-ten boundary and return the same integer type. In AN

(value: i64, scale: i32, enable_ansi_mode: bool)

/// round_integer(42,  -10, false) →    Ok(0)   // factor overflows → 0
/// ```
fn round_integer(value: i64, scale: i32, enable_ansi_mode: bool) -> Result<i64> {
    if scale >= 0 {
        return Ok(value);
    }
    let abs_scale = (-scale) as u32;
    let Some(factor) = 10_i64.checked_pow(abs_scale) else {
        return Ok(0);
    };
    let remainder = value % factor;
    let threshold = factor / 2;
    let result = if remainder >= threshold {
        if enable_ansi_mode {
            value
                .checked_sub(remainder)
                .and_then(|v| v.checked_add(factor))
                .ok_or_else(|| {
                    (exec_err!("Int64 overflow on round({value}, {scale})")
                        as Result<(), _>)
                        .unwrap_err()
                })?
        } else {
            value.wrapping_sub(remainder).wrapping_add(factor)
        }
    } else if remainder <= -threshold {
        if enable_ansi_mode {
            value
                .checked_sub(remainder)
                .and_then(|v| v.checked_sub(factor))
                .ok_or_else(|| {
                    (exec_err!("Int64 overflow on round({value}, {scale})")
                        as Result<(), _>)
                        .unwrap_err()
                })?
        } else {
            value.wrapping_sub(remainder).wrapping_sub(factor)
        }
    } else {
        value - remainder
    };
    Ok(result)
}

// ---------------------------------------------------------------------------
// Decimal rounding using ArrowNativeTypeOp (HALF_UP)