Add test for casting `Decimal128` (`i128::MIN` and `i128::MAX`) to `f64` with overflow handling

[kosiew]

Description

There is an existing test for casting Decimal256 values (i256::MIN and i256::MAX) to f64, checking for correct overflow behavior in #7887

We should add (or confirm the existence of) an equivalent test for Decimal128, specifically testing casting i128::MAX and i128::MIN to f64 with the following expectations:

Positive overflow results in positive infinity.

Negative overflow results in negative infinity.

This will ensure consistency in overflow handling and protect against future regressions.

Acceptance Criteria

Test for Decimal128 to f64 casting with i128::MAX and i128::MIN is added or verified.

The test asserts .is_infinite() and checks the correct sign of the result.

The test style matches existing Decimal256 casting tests.

Context

PR follow up action

[alamb]

f64 test:

I wrote a test for f64 like this

    #[test]
    fn test_cast_decimal128_to_f64_overflow() {
        // Test positive overflow (positive infinity)
        let array = vec![Some(i128::MAX)];
        let array = create_decimal128_array(array, 25, 2).unwrap();
        let array = Arc::new(array) as ArrayRef;

        let result = cast(&array, &DataType::Float64).unwrap();
        let result = result.as_primitive::<Float64Type>();
        assert!(result.value(0).is_infinite());
        assert!(result.value(0) > 0.0); // Positive infinity

        // Test negative overflow (negative infinity)
        let array = vec![Some(i128::MIN)];
        let array = create_decimal128_array(array, 25, 2).unwrap();
        let array = Arc::new(array) as ArrayRef;

        let result = cast(&array, &DataType::Float64).unwrap();
        let result = result.as_primitive::<Float64Type>();
        assert!(result.value(0).is_infinite());
        assert!(result.value(0) < 0.0); // Negative infinity
    }

And it fails like this

assertion failed: result.value(0).is_infinite()
thread 'cast::tests::test_cast_decimal128_to_f64_overflow' panicked at arrow-cast/src/cast/mod.rs:8655:9:
assertion failed: result.value(0).is_infinite()
stack backtrace:
   0: __rustc::rust_begin_unwind
             at /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/std/src/panicking.rs:697:5
   1: core::panicking::panic_fmt
             at /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/core/src/panicking.rs:75:14
   2: core::panicking::panic
             at /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/core/src/panicking.rs:145:5
   3: arrow_cast::cast::tests::test_cast_decimal128_to_f64_overflow
             at ./src/cast/mod.rs:8655:9
   4: arrow_cast::cast::tests::test_cast_decimal128_to_f64_overflow::{{closure}}
             at ./src/cast/mod.rs:8647:46
   5: core::ops::function::FnOnce::call_once
             at /Users/andrewlamb/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs:250:5
   6: core::ops::function::FnOnce::call_once
             at /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/core/src/ops/function.rs:250:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

f32 test

I wrote a test for f32 like this:

    #[test]
    fn test_cast_decimal128_to_f32_overflow() {
        // Test positive overflow (positive infinity)
        let array = vec![Some(i128::MAX)];
        let array = create_decimal128_array(array, 25, 2).unwrap();
        let array = Arc::new(array) as ArrayRef;

        let result = cast(&array, &DataType::Float32).unwrap();
        let result = result.as_primitive::<Float32Type>();
        assert!(result.value(0).is_infinite());
        assert!(result.value(0) > 0.0); // Positive infinity

        // Test negative overflow (negative infinity)
        let array = vec![Some(i128::MIN)];
        let array = create_decimal128_array(array, 25, 2).unwrap();
        let array = Arc::new(array) as ArrayRef;

        let result = cast(&array, &DataType::Float32).unwrap();
        let result = result.as_primitive::<Float32Type>();
        assert!(result.value(0).is_infinite());
        assert!(result.value(0) < 0.0); // Negative infinity
    }

And it fails like this

assertion failed: result.value(0).is_infinite()
thread 'cast::tests::test_cast_decimal128_to_f32_overflow' panicked at arrow-cast/src/cast/mod.rs:8655:9:
assertion failed: result.value(0).is_infinite()
stack backtrace:
   0: __rustc::rust_begin_unwind
             at /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/std/src/panicking.rs:697:5
   1: core::panicking::panic_fmt
             at /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/core/src/panicking.rs:75:14
   2: core::panicking::panic
             at /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/core/src/panicking.rs:145:5
   3: arrow_cast::cast::tests::test_cast_decimal128_to_f32_overflow
             at ./src/cast/mod.rs:8655:9
   4: arrow_cast::cast::tests::test_cast_decimal128_to_f32_overflow::{{closure}}
             at ./src/cast/mod.rs:8647:46
   5: core::ops::function::FnOnce::call_once
             at /Users/andrewlamb/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/function.rs:250:5
   6: core::ops::function::FnOnce::call_once
             at /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/core/src/ops/function.rs:250:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

[alamb]

SO in other words I am not sure if I did something wrong with the tests or if there is some problem in the code that needs to be addressed

[scovich]

I don't think I understand why any decimal 256 value should map to float INF, let alone a decimal 128 value? Shouldn't we just convert the values to the nearest representable float? Similar to how converting from decimal to int truncates/rounds the decimal part? Or is the conversion defined to fail if it would be lossy?

[alamb]

I don't think I understand why any decimal 256 value should map to float INF, let alone a decimal 128 value? Shouldn't we just convert the values to the nearest representable float? Similar to how converting from decimal to int truncates/rounds the decimal part? Or is the conversion defined to fail if it would be lossy?

I am not an expert in this area so I am not sure

The cast kernels have options on what to do on a failure: either return an error or convert to null.

Not sure about this one