Fuzzing Crash: Sum operation returns null for valid DecimalArray ChunkedArray

Fuzzing Crash Report

Analysis

Crash Location: fuzz/src/array/mod.rs:587 in assert_scalar_eq (called during Sum action validation)

Error Message:

Scalar mismatch: expected decimal256(22337414285953441061567344838540486740290084953887815750718056913398681145773, precision=76, scale=75), got null in step 1

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:705:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:587:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Root Cause:

The fuzzer discovered a bug where the sum operation on a ChunkedArray containing DecimalArrays returns a null scalar instead of the expected decimal value. The issue occurs with:

Array type: ChunkedArray with 2 chunks of DecimalArrays
Decimal dtype: Decimal(precision=76, scale=75, Nullable)
Values type: I256 (decimal256)
Operation: Sum operation (step 1)
Expected result: decimal256(22337414285953441061567344838540486740290084953887815750718056913398681145773, precision=76, scale=75)
Actual result: null

The ChunkedArray contains:

First chunk: DecimalArray with 4 elements (I256 values, AllValid)
Second chunk: DecimalArray with 3 elements (I256 values, AllValid)

All values are valid (no nulls), so the sum operation should return a valid decimal value. However, the sum operation is incorrectly returning null, suggesting a bug in either:

The sum implementation for DecimalArray
The sum implementation for ChunkedArray when dealing with decimal chunks
Scalar value construction or type handling for large decimal256 values
Overflow or precision handling during decimal summation

Debug Output

Output of `std::fmt::Debug`:

	FuzzArrayAction {
	    array: ChunkedArray {
	        dtype: Decimal(
	            DecimalDType {
	                precision: 76,
	                scale: 75,
	            },
	            Nullable,
	        ),
	        len: 7,
	        chunk_offsets: PrimitiveArray {
	            dtype: Primitive(
	                U64,
	                NonNullable,
	            ),
	            buffer: Buffer<u8> {
	                length: 24,
	                alignment: Alignment(
	                    8,
	                ),
	                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
	            },
	            validity: NonNullable,
	            stats_set: ArrayStats {
	                inner: RwLock {
	                    data: StatsSet {
	                        values: [],
	                    },
	                },
	            },
	        },
	        chunks: [
	            DecimalArray {
	                dtype: Decimal(
	                    DecimalDType {
	                        precision: 76,
	                        scale: 75,
	                    },
	                    Nullable,
	                ),
	                values: Buffer<u8> {
	                    length: 128,
	                    alignment: Alignment(
	                        16,
	                    ),
	                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
	                },
	                values_type: I256,
	                validity: AllValid,
	                stats_set: ArrayStats {
	                    inner: RwLock {
	                        data: StatsSet {
	                            values: [],
	                        },
	                    },
	                },
	            },
	            DecimalArray {
	                dtype: Decimal(
	                    DecimalDType {
	                        precision: 76,
	                        scale: 75,
	                    },
	                    Nullable,
	                ),
	                values: Buffer<u8> {
	                    length: 96,
	                    alignment: Alignment(
	                        16,
	                    ),
	                    as_slice: [77, 71, 71, 71, 178, 71, 71, 255, 255, 79, 152, 30, 160, 222, 241, 221, ...],
	                },
	                values_type: I256,
	                validity: AllValid,
	                stats_set: ArrayStats {
	                    inner: RwLock {
	                        data: StatsSet {
	                            values: [],
	                        },
	                    },
	                },
	            },
	        ],
	        stats_set: ArrayStats {
	            inner: RwLock {
	                data: StatsSet {
	                    values: [],
	                },
	            },
	        },
	    },
	    actions: [
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    22337414285953441061567344838540486740290084953887815750718056913398681145773,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    22337414285953441061567344838540486740290084953887815750718056913398681145773,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    22337414285953441061567344838540486740290084953887815750718056913398681145773,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    22337414285953441061567344838540486740290084953887815750718056913398681145773,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	    ],
	}

Summary

Target: array_ops
Crash File: crash-8e17520b7a4059d336d944b96e615c0028bdc415
Branch: develop
Commit: 265f29a
Crash Artifact: (artifact URL not available)

Reproduction

Download the crash artifact (if available)
Reproduce locally:

# The artifact contains array_ops/crash-8e17520b7a4059d336d944b96e615c0028bdc415
cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-8e17520b7a4059d336d944b96e615c0028bdc415 -- -rss_limit_mb=0

Get full backtrace:

RUST_BACKTRACE=full cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-8e17520b7a4059d336d944b96e615c0028bdc415 -- -rss_limit_mb=0

Auto-created by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:587 in assert_scalar_eq (called during Sum action validation)

Error Message:

Scalar mismatch: expected decimal256(27693971604943987757262947649678417179695216937688450016519895924314886270445, precision=76, scale=75), got null in step 1

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:705:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:587:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:587 in assert_scalar_eq
Same error pattern: Sum operation returns null instead of expected decimal256 value
Same data type: Decimal(precision=76, scale=75, Nullable) with I256 values
Same array structure: ChunkedArray with 2 chunks of DecimalArrays, all valid elements
Same operation: Sum at step 1

Differences:

Number of elements: 12 total (4 + 8 elements) vs 7 total (4 + 3 elements) in original
Different decimal value expected: 27693971604943987757262947649678417179695216937688450016519895924314886270445 vs 22337414285953441061567344838540486740290084953887815750718056913398681145773
Note: These differences indicate the same root cause manifesting with different input data

Debug Output

Output of `std::fmt::Debug`:

	FuzzArrayAction {
	    array: ChunkedArray {
	        dtype: Decimal(
	            DecimalDType {
	                precision: 76,
	                scale: 75,
	            },
	            Nullable,
	        ),
	        len: 12,
	        chunk_offsets: PrimitiveArray {
	            dtype: Primitive(
	                U64,
	                NonNullable,
	            ),
	            buffer: Buffer<u8> {
	                length: 24,
	                alignment: Alignment(
	                    8,
	                ),
	                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
	            },
	            validity: NonNullable,
	            stats_set: ArrayStats {
	                inner: RwLock {
	                    data: StatsSet {
	                        values: [],
	                    },
	                },
	            },
	        },
	        chunks: [
	            DecimalArray {
	                dtype: Decimal(
	                    DecimalDType {
	                        precision: 76,
	                        scale: 75,
	                    },
	                    Nullable,
	                ),
	                values: Buffer<u8> {
	                    length: 128,
	                    alignment: Alignment(
	                        16,
	                    ),
	                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
	                },
	                values_type: I256,
	                validity: AllValid,
	                stats_set: ArrayStats {
	                    inner: RwLock {
	                        data: StatsSet {
	                            values: [],
	                        },
	                    },
	                },
	            },
	            DecimalArray {
	                dtype: Decimal(
	                    DecimalDType {
	                        precision: 76,
	                        scale: 75,
	                    },
	                    Nullable,
	                ),
	                values: Buffer<u8> {
	                    length: 256,
	                    alignment: Alignment(
	                        16,
	                    ),
	                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 225, ...],
	                },
	                values_type: I256,
	                validity: AllValid,
	                stats_set: ArrayStats {
	                    inner: RwLock {
	                        data: StatsSet {
	                            values: [],
	                        },
	                    },
	                },
	            },
	        ],
	        stats_set: ArrayStats {
	            inner: RwLock {
	                data: StatsSet {
	                    values: [],
	                },
	            },
	        },
	    },
	    actions: [
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    27693971604943987757262947649678417179695216937688450016519895924314886270445,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    27693971604943987757262947649678417179695216937688450016519895924314886270445,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    27693971604943987757262947649678417179695216937688450016519895924314886270445,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	    ],
	}

Occurrence Details

Crash File: crash-c6fd16b0c85012370d501e9aaea9db730cb873fb
Branch: develop
Commit: 265f29a
Crash Artifact: (artifact URL not available)

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-c6fd16b0c85012370d501e9aaea9db730cb873fb -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:705 in assert_scalar_eq

Error Message:

Scalar mismatch: expected decimal256(20838483337615333622867048918413809811831720253113501127311878661340024727345, precision=76, scale=75), got null in step 1

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:705:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:587:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same crash location (fuzz/src/array/mod.rs:587 calling assert_scalar_eq)
Same error pattern: Sum returns null instead of expected decimal256 value
Same array structure: ChunkedArray with 7 elements across 2 chunks (4 + 3 elements)
Same decimal type: Decimal(precision=76, scale=75, Nullable) with I256 values
Same validity: AllValid for both chunks (no null values)
Same operation sequence: Sum operation in step 1

Differences:

Different decimal value: 20838483337615333622867048918413809811831720253113501127311878661340024727345 vs 22337414285953441061567344838540486740290084953887815750718056913398681145773
Different input buffers (different underlying decimal values in chunks)
Note: These differences indicate the same root cause manifesting with different input data

Debug Output

Output of `std::fmt::Debug`:

	FuzzArrayAction {
	    array: ChunkedArray {
	        dtype: Decimal(
	            DecimalDType {
	                precision: 76,
	                scale: 75,
	            },
	            Nullable,
	        ),
	        len: 7,
	        chunk_offsets: PrimitiveArray {
	            dtype: Primitive(
	                U64,
	                NonNullable,
	            ),
	            buffer: Buffer<u8> {
	                length: 24,
	                alignment: Alignment(
	                    8,
	                ),
	                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
	            },
	            validity: NonNullable,
	            stats_set: ArrayStats {
	                inner: RwLock {
	                    data: StatsSet {
	                        values: [],
	                    },
	                },
	            },
	        },
	        chunks: [
	            DecimalArray {
	                dtype: Decimal(
	                    DecimalDType {
	                        precision: 76,
	                        scale: 75,
	                    },
	                    Nullable,
	                ),
	                values: Buffer<u8> {
	                    length: 128,
	                    alignment: Alignment(
	                        16,
	                    ),
	                    as_slice: [73, 69, 69, 65, 71, 255, 255, 1, 97, 143, 236, 228, 101, 118, 200, 187, ...],
	                },
	                values_type: I256,
	                validity: AllValid,
	                stats_set: ArrayStats {
	                    inner: RwLock {
	                        data: StatsSet {
	                            values: [],
	                        },
	                    },
	                },
	            },
	            DecimalArray {
	                dtype: Decimal(
	                    DecimalDType {
	                        precision: 76,
	                        scale: 75,
	                    },
	                    Nullable,
	                ),
	                values: Buffer<u8> {
	                    length: 96,
	                    alignment: Alignment(
	                        16,
	                    ),
	                    as_slice: [5, 0, 0, 0, 0, 0, 0, 0, 0, 80, 152, 30, 160, 222, 241, 221, ...],
	                },
	                values_type: I256,
	                validity: AllValid,
	                stats_set: ArrayStats {
	                    inner: RwLock {
	                        data: StatsSet {
	                            values: [],
	                        },
	                    },
	                },
	            },
	        ],
	        stats_set: ArrayStats {
	            inner: RwLock {
	                data: StatsSet {
	                    values: [],
	                },
	            },
	        },
	    },
	    actions: [
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    20838483337615333622867048918413809811831720253113501127311878661340024727345,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    20838483337615333622867048918413809811831720253113501127311878661340024727345,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    20838483337615333622867048918413809811831720253113501127311878661340024727345,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    20838483337615333622867048918413809811831720253113501127311878661340024727345,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	    ],
	}

Occurrence Details

Crash File: crash-3f1561ed9ad830675dcde992e392e1ff19934e38
Branch: develop
Commit: 265f29a
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12448349321/artifacts/2489076668

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-3f1561ed9ad830675dcde992e392e1ff19934e38 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq (called from fuzz/src/array/mod.rs:600 during Sum action validation)

Error Message:

Scalar mismatch: expected decimal256(10790247240375674034382602666023497427965362021233909778780660640748465315007, precision=76, scale=75), got null in step 1

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60
   7: {closure#0}
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:62:9

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: Sum operation returns null instead of expected decimal256 value
Same array structure: ChunkedArray with DecimalArray chunks
Same dtype: Decimal(precision=76, scale=75, Nullable)
Same values type: I256 (decimal256)
Same validity: AllValid (no null values in the array)
Same operation: Sum (step 1)

Differences:

Different expected decimal value (10790247... vs 22337414...)
Different crash file hash
Crash occurs in line 721 vs 705 (slight code change/renumbering)

Note: These differences appear superficial - the root cause is identical: sum operation incorrectly returning null for valid decimal ChunkedArrays.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 7,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [101, 19, 19, 19, 19, 19, 19, 19, 19, 163, 255, 247, 120, 137, 219, 206, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 96,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [25, 19, 19, 19, 19, 19, 19, 19, 19, 99, 171, 49, 179, 18, 40, 25, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10790247240375674034382602666023497427965362021233909778780660640748465315007,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10790247240375674034382602666023497427965362021233909778780660640748465315007,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10790247240375674034382602666023497427965362021233909778780660640748465315007,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            ScalarAt(
                [
                    1,
                    0,
                ],
            ),
            ScalarVec(
                [
                    Scalar {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        value: ScalarValue(
                            Decimal(
                                I256(
                                    i256(
                                        -5741578351051015783107385374964763107126605340420323525087069563313122454570,
                                    ),
                                ),
                            ),
                        ),
                    },
                    Scalar {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        value: ScalarValue(
                            Decimal(
                                I256(
                                    i256(
                                        -1248447015343508973064123766978835732768971325862225980788357083119273962651,
                                    ),
                                ),
                            ),
                        ),
                    },
                ],
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-0bac3630a917c5455df15725244ebb0f5ed8c36d
Branch: develop
Commit: c7b0ef9
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12493848318/artifacts/2528043893

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-0bac3630a917c5455df15725244ebb0f5ed8c36d -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/fuzz_targets/array_ops.rs:18 → fuzz/src/array/mod.rs:721 in assert_scalar_eq

Error Message:

Scalar mismatch: expected decimal256(10323363529835433185142243760835556304440655060181866870240624141318125256717, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11

Similarities to Original Issue:

Same root cause: Sum operation on ChunkedArray with DecimalArrays returns null instead of expected decimal value
Same array structure: ChunkedArray with 2 DecimalArray chunks
Same decimal dtype: Decimal(precision=76, scale=75, Nullable)
Same values type: I256 (decimal256)
Same operation: Sum action
Same failure mode: Expected decimal value, got null scalar

Differences:

This crash has a Mask operation (step 0) before the Sum operations
The failing Sum is at step 2 instead of step 1
After masking, array has 3 valid values out of 12 (validity BoolArray shows)
Note: These differences may indicate the same root cause manifesting differently

The sequence is:

Step 0: Mask operation applies mask [248, 15] leaving 3 valid values
Step 1: First Sum succeeds
Step 2: Second Sum fails, returns null instead of expected decimal value

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 231, 224, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [248, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 9,
                        density: 0.75,
                    },
                ),
            ),
            Array(
                DecimalArray {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    values: Buffer<u8> {
                        length: 384,
                        alignment: Alignment(
                            16,
                        ),
                        as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                    },
                    values_type: I256,
                    validity: Array(
                        BoolArray {
                            dtype: Bool(
                                NonNullable,
                            ),
                            bits: BitBuffer {
                                buffer: Buffer<u8> {
                                    length: 2,
                                    alignment: Alignment(
                                        1,
                                    ),
                                    as_slice: [7, 240],
                                },
                                offset: 0,
                                len: 12,
                            },
                            validity: NonNullable,
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [
                                            (
                                                Sum,
                                                Exact(
                                                    ScalarValue(
                                                        Primitive(
                                                            U64(
                                                                3,
                                                            ),
                                                        ),
                                                    ),
                                                ),
                                            ),
                                        ],
                                    },
                                },
                            },
                        },
                    ),
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10323363529835433185142243760835556304440655060181866870240624141318125256717,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10323363529835433185142243760835556304440655060181866870240624141318125256717,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-654fe1bfa35b9e071b0b031bd7e9d729e02d2414
Branch: develop
Commit: c7b0ef9
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12554043632/artifacts/2441832313

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-654fe1bfa35b9e071b0b031bd7e9d729e02d2414 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq (called during Sum action validation)

Error Message:

Scalar mismatch: expected decimal256(19114636092132069678636608587413648682675527307658925074242750454127538598414, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: Sum operation returns null instead of expected decimal256 value
Same array structure: ChunkedArray with DecimalArray chunks (I256, precision=76, scale=75)
Same validity: All chunks have AllValid validity (no nulls in input)

Differences:

Different step number (step 2 vs step 1)
Different expected decimal value (different magnitude)
Note: These differences may indicate the same root cause manifesting differently depending on the specific decimal values and number of previous sum operations

Debug Output

Output of `std::fmt::Debug`:

	FuzzArrayAction {
	    array: ChunkedArray {
	        dtype: Decimal(
	            DecimalDType {
	                precision: 76,
	                scale: 75,
	            },
	            Nullable,
	        ),
	        len: 7,
	        chunk_offsets: PrimitiveArray {
	            dtype: Primitive(
	                U64,
	                NonNullable,
	            ),
	            buffer: Buffer<u8> {
	                length: 24,
	                alignment: Alignment(
	                    8,
	                ),
	                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
	            },
	            validity: NonNullable,
	            stats_set: ArrayStats {
	                inner: RwLock {
	                    data: StatsSet {
	                        values: [],
	                    },
	                },
	            },
	        },
	        chunks: [
	            DecimalArray {
	                dtype: Decimal(
	                    DecimalDType {
	                        precision: 76,
	                        scale: 75,
	                    },
	                    Nullable,
	                ),
	                values: Buffer<u8> {
	                    length: 128,
	                    alignment: Alignment(
	                        16,
	                    ),
	                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
	                },
	                values_type: I256,
	                validity: AllValid,
	                stats_set: ArrayStats {
	                    inner: RwLock {
	                        data: StatsSet {
	                            values: [],
	                        },
	                    },
	                },
	            },
	            DecimalArray {
	                dtype: Decimal(
	                    DecimalDType {
	                        precision: 76,
	                        scale: 75,
	                    },
	                    Nullable,
	                ),
	                values: Buffer<u8> {
	                    length: 96,
	                    alignment: Alignment(
	                        16,
	                    ),
	                    as_slice: [157, 151, 151, 151, 151, 163, 255, 255, 255, 79, 152, 30, 160, 222, 241, 221, ...],
	                },
	                values_type: I256,
	                validity: AllValid,
	                stats_set: ArrayStats {
	                    inner: RwLock {
	                        data: StatsSet {
	                            values: [],
	                        },
	                    },
	                },
	            },
	        ],
	        stats_set: ArrayStats {
	            inner: RwLock {
	                data: StatsSet {
	                    values: [],
	                },
	            },
	        },
	    },
	    actions: [
	        (
	            ScalarAt(
	                [
	                    1,
	                ],
	            ),
	            ScalarVec(
	                [
	                    Scalar {
	                        dtype: Decimal(
	                            DecimalDType {
	                                precision: 76,
	                                scale: 75,
	                            },
	                            Nullable,
	                        ),
	                        value: ScalarValue(
	                            Decimal(
	                                I256(
	                                    i256(
	                                        5792089237316195423570985008687907853269984665640564039457584007913129639941,
	                                    ),
	                                ),
	                            ),
	                        ),
	                    },
	                ],
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    19114636092132069678636608587413648682675527307658925074242750454127538598414,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    19114636092132069678636608587413648682675527307658925074242750454127538598414,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    19114636092132069678636608587413648682675527307658925074242750454127538598414,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	    ],
	}

Occurrence Details

Crash File: crash-0e0c3b32724807d4ec9bab609793285630887210
Branch: develop
Commit: 5d50f72
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20548780110/artifacts/4977560214

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-0e0c3b32724807d4ec9bab609793285630887210 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:721:13 in assert_scalar_eq (called during Sum action validation)

Error Message:

Scalar mismatch: expected decimal256(10335731459288881875449326843340756734051447447459996202947475384727173595149, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same root cause: Sum operation on ChunkedArray with DecimalArrays returns null instead of expected decimal value
Same error pattern: "expected decimal256(...), got null in step X"
Same crash location: assert_scalar_eq in fuzz/src/array/mod.rs
Same array structure: ChunkedArray with 2 DecimalArray chunks, I256 values, AllValid validity
Same decimal type: Decimal(precision=76, scale=75, Nullable)

Differences:

Occurs at step 2 instead of step 1 (previous mask operation before sum)
Array length 12 (4 + 8 elements) vs 7 (4 + 3 elements)
Expected value is different (different test case)
Includes a Mask action before the failing Sum operation

Note: These differences indicate the same root cause manifesting differently. The mask operation in step 1 doesn't affect the underlying bug - the sum operation still incorrectly returns null for valid decimal arrays.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 225, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [248, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 9,
                        density: 0.75,
                    },
                ),
            ),
            Array(...),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734051447447459996202947475384727173595149,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-6e35d1932d046c46dbad153517e50bceb7b2c53f
Branch: develop
Commit: 5d50f72
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/13126072992/artifacts/2518360697

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-6e35d1932d046c46dbad153517e50bceb7b2c53f -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the `array_ops` target.

Crash Details

Crash Location: `fuzz/fuzz_targets/array_ops.rs:18` → `fuzz/src/array/mod.rs:assert_scalar_eq`

Error Message:
```
Scalar mismatch: expected decimal256(10335731459288881875449326843340756734051447447459996202947475384727173595149, precision=76, scale=75), got null in step 2
```

Stack Trace:
```
3: assert_scalar_eq
at ./fuzz/src/array/mod.rs:721:13
4: run_fuzz_action
at ./fuzz/src/array/mod.rs:600:17
5: __libfuzzer_sys_run
at ./fuzz/fuzz_targets/array_ops.rs:14:11
```

Similarities to Original Issue:

Same crash location: `assert_scalar_eq` in `fuzz/src/array/mod.rs`
Same error pattern: Sum operation on ChunkedArray with DecimalArrays returns null instead of expected decimal256 value
Same array structure: ChunkedArray with 2 DecimalArray chunks, all values marked as AllValid
Same dtype: Decimal(precision=76, scale=75, Nullable) with I256 values_type
Same operation: Sum action

Differences:

Different step number: step 2 (vs step 1 in original)
Different decimal value: 10335731459288881875449326843340756734051447447459996202947475384727173595149
Different array length: 12 elements (4 in first chunk, 8 in second chunk)
Note: These differences likely indicate the same root cause manifesting with different inputs

Debug Output

```
FuzzArrayAction {
array: ChunkedArray {
dtype: Decimal(
DecimalDType {
precision: 76,
scale: 75,
},
Nullable,
),
len: 12,
chunk_offsets: PrimitiveArray {
dtype: Primitive(
U64,
NonNullable,
),
buffer: Buffer {
length: 24,
alignment: Alignment(
8,
),
as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
},
validity: NonNullable,
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [],
},
},
},
},
chunks: [
DecimalArray {
dtype: Decimal(
DecimalDType {
precision: 76,
scale: 75,
},
Nullable,
),
values: Buffer {
length: 128,
alignment: Alignment(
16,
),
as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
},
values_type: I256,
validity: AllValid,
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [],
},
},
},
},
DecimalArray {
dtype: Decimal(
DecimalDType {
precision: 76,
scale: 75,
},
Nullable,
),
values: Buffer {
length: 256,
alignment: Alignment(
16,
),
as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 225, ...],
},
values_type: I256,
validity: AllValid,
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [],
},
},
},
},
],
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [],
},
},
},
},
actions: [
(
Mask(
Values(
MaskValues {
buffer: BitBuffer {
buffer: Buffer {
length: 2,
alignment: Alignment(
1,
),
as_slice: [248, 15],
},
offset: 0,
len: 12,
},
indices: OnceLock(
,
),
slices: OnceLock(
,
),
true_count: 9,
density: 0.75,
},
),
),
Array(
DecimalArray {
dtype: Decimal(
DecimalDType {
precision: 76,
scale: 75,
},
Nullable,
),
values: Buffer {
length: 384,
alignment: Alignment(
16,
),
as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
},
values_type: I256,
validity: Array(
BoolArray {
dtype: Bool(
NonNullable,
),
bits: BitBuffer {
buffer: Buffer {
length: 2,
alignment: Alignment(
1,
),
as_slice: [7, 240],
},
offset: 0,
len: 12,
},
validity: NonNullable,
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [
(
Sum,
Exact(
ScalarValue(
Primitive(
U64(
3,
),
),
),
),
),
],
},
},
},
},
),
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [],
},
},
},
},
),
),
(
Sum,
Scalar(
Scalar {
dtype: Decimal(
DecimalDType {
precision: 76,
scale: 75,
},
Nullable,
),
value: ScalarValue(
Decimal(
I256(
i256(
10335731459288881875449326843340756734051447447459996202947475384727173595149,
),
),
),
),
},
),
),
(
Sum,
Scalar(
Scalar {
dtype: Decimal(
DecimalDType {
precision: 76,
scale: 75,
},
Nullable,
),
value: ScalarValue(
Decimal(
I256(
i256(
10335731459288881875449326843340756734051447447459996202947475384727173595149,
),
),
),
),
},
),
),
(
Sum,
Scalar(
Scalar {
dtype: Decimal(
DecimalDType {
precision: 76,
scale: 75,
},
Nullable,
),
value: ScalarValue(
Decimal(
I256(
i256(
10335731459288881875449326843340756734051447447459996202947475384727173595149,
),
),
),
),
},
),
),
],
}
```

Occurrence Details

Crash File: `crash-96f6272afa3073215ceed0026466efed91cc2fec`
Branch: develop
Commit: 5d50f72
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12544823734/artifacts/2562821838

Reproduction

```bash
cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-96f6272afa3073215ceed0026466efed91cc2fec -- -rss_limit_mb=0
```

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq (called from run_fuzz_action at line 600)

Error Message:

Scalar mismatch: expected decimal256(16127820696605077299020311852028664520357855662223888807197561387850679094432, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same error pattern: Sum operation returns null instead of expected decimal value
Same array structure: ChunkedArray containing DecimalArrays
Same decimal type: Decimal(precision=76, scale=75, Nullable) with I256 values
Same crash location: assert_scalar_eq in fuzz/src/array/mod.rs
All values are valid (AllValid validity) across both chunks

Differences:

This crash occurs at step 2 instead of step 1
Different specific decimal value (expected different numeric value)
Array has 12 elements total (4 + 8 across 2 chunks) vs 7 elements in original
Note: These differences indicate the same root cause manifesting with different fuzz inputs

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 86, 230, 224, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [128, 127, ...],
                            },
                            offset: 0,
                            length: 12,
                        },
                    },
                ),
            ),
            ChunkedArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                len: 12,
                chunk_offsets: PrimitiveArray {
                    dtype: Primitive(
                        U64,
                        NonNullable,
                    ),
                    buffer: Buffer<u8> {
                        length: 24,
                        alignment: Alignment(
                            8,
                        ),
                        as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
                    },
                    validity: NonNullable,
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
                chunks: [
                    DecimalArray {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        values: Buffer<u8> {
                            length: 128,
                            alignment: Alignment(
                                16,
                            ),
                            as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                        },
                        values_type: I256,
                        validity: AllInvalid,
                        stats_set: ArrayStats {
                            inner: RwLock {
                                data: StatsSet {
                                    values: [],
                                },
                            },
                        },
                    },
                    DecimalArray {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        values: Buffer<u8> {
                            length: 256,
                            alignment: Alignment(
                                16,
                            ),
                            as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 86, 230, 224, ...],
                        },
                        values_type: I256,
                        validity: AllInvalid,
                        stats_set: ArrayStats {
                            inner: RwLock {
                                data: StatsSet {
                                    values: [],
                                },
                            },
                        },
                    },
                ],
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ),
        (
            FillNull(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    0,
                                ),
                            ),
                        ),
                    ),
                },
            ),
            ChunkedArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                len: 12,
                chunk_offsets: PrimitiveArray {
                    dtype: Primitive(
                        U64,
                        NonNullable,
                    ),
                    buffer: Buffer<u8> {
                        length: 24,
                        alignment: Alignment(
                            8,
                        ),
                        as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
                    },
                    validity: NonNullable,
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
                chunks: [
                    DecimalArray {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        values: Buffer<u8> {
                            length: 128,
                            alignment: Alignment(
                                16,
                            ),
                            as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...],
                        },
                        values_type: I256,
                        validity: AllValid,
                        stats_set: ArrayStats {
                            inner: RwLock {
                                data: StatsSet {
                                    values: [],
                                },
                            },
                        },
                    },
                    DecimalArray {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        values: Buffer<u8> {
                            length: 256,
                            alignment: Alignment(
                                16,
                            ),
                            as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...],
                        },
                        values_type: I256,
                        validity: AllValid,
                        stats_set: ArrayStats {
                            inner: RwLock {
                                data: StatsSet {
                                    values: [],
                                },
                            },
                        },
                    },
                ],
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    16127820696605077299020311852028664520357855662223888807197561387850679094432,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-0da036cfc5fd676adfb7b171288653ccfe781dc6
Branch: develop
Commit: 27acf01
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20564823413/artifacts/4981641927

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-0da036cfc5fd676adfb7b171288653ccfe781dc6 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:721:assert_scalar_eq

Error Message:

Scalar mismatch: expected decimal256(10335731459288881875449326843340756734050377834307138028455998102483354255373, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same error pattern: Sum operation returns null for DecimalArray in ChunkedArray
Same crash location: assert_scalar_eq in fuzz/src/array/mod.rs
Same array type: ChunkedArray containing DecimalArrays with I256 values
Same decimal configuration: precision=76, scale=75, Nullable
Same problem: Expected a valid decimal256 value, got null instead

Differences:

Crash occurs at step 2 instead of step 1
Array has 3 chunks (0→4→12 elements) instead of 2 chunks
Array has mixed validity patterns (some AllValid, one with validity Array)
Preceded by a Mask operation that filters the array before the Sum
Note: These differences may indicate the same root cause manifesting differently

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 250, 186, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 225, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [248, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 9,
                        density: 0.75,
                    },
                ),
            ),
            Array(
                DecimalArray {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    values: Buffer<u8> {
                        length: 384,
                        alignment: Alignment(
                            16,
                        ),
                        as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 250, 186, ...],
                    },
                    values_type: I256,
                    validity: Array(
                        BoolArray {
                            dtype: Bool(
                                NonNullable,
                            ),
                            bits: BitBuffer {
                                buffer: Buffer<u8> {
                                    length: 2,
                                    alignment: Alignment(
                                        1,
                                    ),
                                    as_slice: [7, 240],
                                },
                                offset: 0,
                                len: 12,
                            },
                            validity: NonNullable,
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [
                                            (
                                                Sum,
                                                Exact(
                                                    ScalarValue(
                                                        Primitive(
                                                            U64(
                                                                3,
                                                            ),
                                                        ),
                                                    ),
                                                ),
                                            ),
                                        ],
                                    },
                                },
                            },
                        },
                    ),
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734050377834307138028455998102483354255373,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734050377834307138028455998102483354255373,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-175c32694c2bf3490a0b357fbe3dadfc5d567e52
Branch: develop
Commit: a4368bf
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/19806870935/artifacts/4720903088

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-175c32694c2bf3490a0b357fbe3dadfc5d567e52 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq

Error Message:

Scalar mismatch: expected decimal256(10335731459288881875449326843340756734051447447459996202947475384727173595149, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60
   7: {closure#0}
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:62:9

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: "Scalar mismatch: expected decimal256(...), got null in step N"
Same operation: Sum operation on ChunkedArray with DecimalArray chunks
Same data type: Decimal(precision=76, scale=75, Nullable) with I256 values
Same symptom: Sum returns null instead of expected decimal value
Same array structure: ChunkedArray with 2 DecimalArray chunks

Differences:

Step number: step 2 (vs step 1 in original issue)
Array length: 12 elements (vs 7 in original)
Different specific decimal values
These differences likely indicate the same root cause manifesting at different stages

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 49, 255, 255, 207, 64, 171, 43, 14, 159, 225, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [248, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 9,
                        density: 0.75,
                    },
                ),
            ),
            Array(
                DecimalArray {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    values_type: I256,
                    validity: Array(...),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734051447447459996202947475384727173595149,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734051447447459996202947475384727173595149,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-2d3cc1cd14e9fdcf087af7a7e4f7ab95cf2ba52d
Branch: develop
Commit: a4368bf
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12954669768/artifacts/2440925084

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-2d3cc1cd14e9fdcf087af7a7e4f7ab95cf2ba52d -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/fuzz_targets/array_ops.rs:18 in assert_scalar_eq

Error Message:

Scalar mismatch: expected decimal256(18367971033269586613034193952482477856815984672156301979196612656937415690075, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same crash location: assert_scalar_eq during Sum operation validation
Same array structure: ChunkedArray with DecimalArray chunks
Same dtype: Decimal(precision=76, scale=75, Nullable)
Same values type: I256 (decimal256)
Same validity: All values are AllValid (no nulls in input)
Same bug: Sum operation returns null instead of expected decimal value

Differences:

Different number of elements: 12 total (4 + 8 chunks) vs 7 total (4 + 3 chunks) in original
Occurs at step 2 vs step 1 (after a Mask operation was applied first)
Different expected decimal value

These differences indicate the same root cause manifesting in different scenarios. The bug appears to be in the Sum operation implementation for ChunkedArray containing DecimalArrays with I256 values, not dependent on the specific values or array size.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 225, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [224, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 7,
                        density: 0.5833333333333334,
                    },
                ),
            ),
            Array(
                DecimalArray {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    values: Buffer<u8> {
                        length: 384,
                        alignment: Alignment(
                            16,
                        ),
                        as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                    },
                    values_type: I256,
                    validity: Array(
                        BoolArray {
                            dtype: Bool(
                                NonNullable,
                            ),
                            bits: BitBuffer {
                                buffer: Buffer<u8> {
                                    length: 2,
                                    alignment: Alignment(
                                        1,
                                    ),
                                    as_slice: [31, 240],
                                },
                                offset: 0,
                                len: 12,
                            },
                            validity: NonNullable,
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [
                                            (
                                                Sum,
                                                Exact(
                                                    ScalarValue(
                                                        Primitive(
                                                            U64(
                                                                5,
                                                            ),
                                                        ),
                                                    ),
                                                ),
                                            ),
                                        ],
                                    },
                                },
                            },
                        },
                    ),
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    18367971033269586613034193952482477856815984672156301979196612656937415690075,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    18367971033269586613034193952482477856815984672156301979196612656937415690075,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    18367971033269586613034193952482477856815984672156301979196612656937415690075,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-f7fea21f29de6d3578bd8247fa99ad1f58eab795
Branch: develop
Commit: da5d463
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12991229825/artifacts/2603424172

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-f7fea21f29de6d3578bd8247fa99ad1f58eab795 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq (called from run_fuzz_action)

Error Message:

Scalar mismatch: expected decimal256(10335731459288881875449326843340756734051447447459996202947475384727173595149, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same root cause: Sum operation on ChunkedArray containing DecimalArrays returns null instead of expected decimal value
Same decimal type: Decimal(precision=76, scale=75, Nullable) with I256 values
Same array structure: ChunkedArray with 2 DecimalArray chunks
Same error pattern: Expected decimal256 value but got null

Differences:

This crash occurs at step 2 (after a Mask operation in step 1), while the original issue failed at step 1
Array has 12 elements across 2 chunks (4 + 8) vs 7 elements (4 + 3) in original
The Mask operation was applied first, filtering some elements

These differences suggest the same underlying bug manifests in multiple scenarios - both when summing an unmodified ChunkedArray and when summing after masking operations.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 225, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [248, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 9,
                        density: 0.75,
                    },
                ),
            ),
            Array(...),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734051447447459996202947475384727173595149,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-34f54e50add1794aeae110af0dd1fc72ad012a2e
Branch: develop
Commit: da5d463
Crash Artifact: (Environment variables not available - check workflow artifacts)

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-34f54e50add1794aeae110af0dd1fc72ad012a2e -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq (line 721)

Error Message:

Scalar mismatch: expected decimal256(10335731459288881875449326843340756734051445966844095136375534436577829715981, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: Sum operation on DecimalArray ChunkedArray returns null instead of expected decimal256 value
Same data type: Decimal(precision=76, scale=75, Nullable) with I256 values
Same operation sequence: Multiple Sum operations on ChunkedArray with DecimalArray chunks
All chunks have AllValid validity (no nulls in input data)

Differences:

Step number: This occurs at step 2 vs step 1 in original issue
Expected decimal value: Different large i256 value
Number of chunks: 2 chunks vs original (specific configuration differs)
This crash has a Mask operation before the Sum operations

Note: These differences may indicate the same root cause manifesting differently. The key similarity is that Sum on valid DecimalArray data returns null unexpectedly.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 45, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 231, 224, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [248, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 9,
                        density: 0.75,
                    },
                ),
            ),
            Array(
                DecimalArray {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    values: Buffer<u8> {
                        length: 384,
                        alignment: Alignment(
                            16,
                        ),
                        as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 45, 200, 187, ...],
                    },
                    values_type: I256,
                    validity: Array(
                        BoolArray {
                            dtype: Bool(
                                NonNullable,
                            ),
                            bits: BitBuffer {
                                buffer: Buffer<u8> {
                                    length: 2,
                                    alignment: Alignment(
                                        1,
                                    ),
                                    as_slice: [7, 240],
                                },
                                offset: 0,
                                len: 12,
                            },
                            validity: NonNullable,
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [
                                            (
                                                Sum,
                                                Exact(
                                                    ScalarValue(
                                                        Primitive(
                                                            U64(
                                                                3,
                                                            ),
                                                        ),
                                                    ),
                                                ),
                                            ),
                                        ],
                                    },
                                },
                            },
                        },
                    ),
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734051445966844095136375534436577829715981,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-681f572977a7ca9368045bcb7a1e1da09f744650
Branch: develop
Commit: da5d463
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20614967851/artifacts/4996912015

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-681f572977a7ca9368045bcb7a1e1da09f744650 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/fuzz_targets/array_ops.rs:18 (via assert_scalar_eq in fuzz/src/array/mod.rs)

Error Message:

Scalar mismatch: expected decimal256(10335731459288881875449326843340756734051447447459996202947475384727173595149, precision=76, scale=75), got null in step 2

Stack Trace:

thread '<unnamed>' panicked at fuzz/fuzz_targets/array_ops.rs:18:13
   0: std::backtrace_rs::backtrace::libunwind::trace
   1: std::backtrace_rs::backtrace::trace_unsynchronized
   2: <std::backtrace::Backtrace>::create
   3: assert_scalar_eq at ./fuzz/src/array/mod.rs:717
   4: run_fuzz_action at ./fuzz/src/array/mod.rs:600
   5: __libfuzzer_sys_run at ./fuzz/fuzz_targets/array_ops.rs:14
   6: rust_fuzzer_test_input

Similarities to Original Issue:

Same error pattern: Sum operation returns null instead of expected decimal256 value
Same array type: ChunkedArray containing DecimalArrays with I256 values
Same decimal dtype: Decimal(precision=76, scale=75, Nullable)
Same operation: Sum action failing
Same crash location chain: array_ops.rs → run_fuzz_action → assert_scalar_eq

Differences:

This crash occurs at step 2 (third sum operation) vs step 1 in original
Different specific decimal value expected
Note: These differences may indicate the same root cause manifesting differently - likely overflow occurring at different points in the sum sequence

Debug Output

Output of \`std::fmt::Debug\`:

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [77, 71, 71, 71, 178, 71, 71, 255, 255, 79, 152, 30, 160, 222, 241, 221, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (Sum, Scalar(decimal256(...))),
        (Sum, Scalar(decimal256(...))),
        (Sum, Scalar(decimal256(...))),  // Fails here at step 2
        (Sum, Scalar(decimal256(...)))
    ]
}

Occurrence Details

Crash File: crash-d2b866e252abf09101a67a3ed4133c6e621fbc85
Branch: develop
Commit: da5d463
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12997089820/artifacts/2543071155

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-d2b866e252abf09101a67a3ed4133c6e621fbc85 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq

Error Message:

Scalar mismatch: expected decimal256(-11824961190162970622158057920763475052501768401000039656701461254637579751034, precision=76, scale=75), got null in step 1

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60
   7: {closure#0}
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:62:9

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: Sum operation on ChunkedArray with DecimalArray chunks returns null instead of expected decimal256 value
Same array structure: ChunkedArray with 2 DecimalArray chunks, I256 values, AllValid validity
Same decimal dtype: Decimal(precision=76, scale=75, Nullable)
Same step number: step 1 (first Sum operation)

Differences:

Different decimal value: negative (-11824961190162970622158057920763475052501768401000039656701461254637579751034) vs positive value in original issue
Note: This difference suggests the bug is not specific to the sign of the decimal value

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 7,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [69, 65, 65, 65, 65, 65, 65, 65, 65, 209, 45, 38, 167, 183, 9, 253, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 96,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [65, 255, 255, 255, 255, 255, 255, 255, 255, 79, 152, 30, 160, 222, 241, 221, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    -11824961190162970622158057920763475052501768401000039656701461254637579751034,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    -11824961190162970622158057920763475052501768401000039656701461254637579751034,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Compare(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    -484369410095871754776023429157984272695886261699464068373557017590770876093,
                                ),
                            ),
                        ),
                    ),
                },
                NotEq,
            ),
            Array(
                BoolArray {
                    dtype: Bool(
                        Nullable,
                    ),
                    bits: BitBuffer {
                        buffer: Buffer<u8> {
                            length: 1,
                            alignment: Alignment(
                                1,
                            ),
                            as_slice: [113],
                        },
                        offset: 0,
                        len: 7,
                    },
                    validity: AllValid,
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [
                                    (
                                        Sum,
                                        Exact(
                                            ScalarValue(
                                                Primitive(
                                                    U64(
                                                        4,
                                                    ),
                                                ),
                                            ),
                                        ),
                                    ),
                                ],
                            },
                        },
                    },
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Primitive(
                        U64,
                        Nullable,
                    ),
                    value: ScalarValue(
                        Primitive(
                            U64(
                                4,
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-ca569401090e92561b5889ecdf02f71c0226bdfd
Branch: develop
Commit: da5d463
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12628569881/artifacts/2444926298

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-ca569401090e92561b5889ecdf02f71c0226bdfd -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq

Error Message:

Scalar mismatch: expected decimal256(23921488652874490487261874489124385090914693478669572728384272469692686078214, precision=76, scale=75), got null in step 3

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60
   7: {closure#0}
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:62:9

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: expected decimal256 value, got null
Same data structure: ChunkedArray with DecimalArray chunks (I256 values)
Same operation: Sum returning null instead of expected decimal value
Same array configuration: 2 chunks with 4 + 8 elements (total 12 elements)
Same validity state: AllValid for all chunks

Differences:

Different step number: step 3 vs step 1 (indicates multiple Sum operations performed)
Different expected decimal value (different test case)
Slightly different array length (12 vs 7 elements)
Note: These differences may indicate the same root cause manifesting at different points in the action sequence

This appears to be another instance of the same bug where Sum operations on ChunkedArray containing DecimalArrays with I256 values incorrectly return null. Based on issue #5811's analysis, this may be due to i256 overflow during summation, where the implementation correctly returns null on overflow but the fuzzer expects a wrapped/computed value.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 225, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            SearchSorted(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    5812277761003466975425526534710957170682358738636726681363241434114356102988,
                                ),
                            ),
                        ),
                    ),
                },
                Left,
            ),
            Search(
                Found(
                    10,
                ),
            ),
        ),
        (
            SearchSorted(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    4016119786990500786850544879039602134758273800452633834641571372607096169731,
                                ),
                            ),
                        ),
                    ),
                },
                Left,
            ),
            Search(
                Found(
                    2,
                ),
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    23921488652874490487261874489124385090914693478669572728384272469692686078214,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        ...more actions...
    ],
}

Occurrence Details

Crash File: crash-577fa3dfc7d49419c7393b754beab4246482a3ee
Branch: develop
Commit: da5d463
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12958062659/artifacts/2419899788

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-577fa3dfc7d49419c7393b754beab4246482a3ee -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq (via fuzz/fuzz_targets/array_ops.rs:18)

Error Message:

Scalar mismatch: expected decimal256(10335731459288881875449326843340756734051447447459996202947475384727173595149, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same crash pattern: Sum operation on ChunkedArray with DecimalArrays returns null
Same error pattern: "expected decimal256(...), got null"
Same array structure: ChunkedArray with 2 DecimalArray chunks (4 + 8 elements)
Same values type: I256 (decimal256)
Same decimal type: precision=76, scale=75
All values are valid (AllValid validity)

Differences:

Crash occurs at step 2 (after a Mask operation) instead of step 1
The sequence is: Mask (step 1) → Sum (step 2 - crashes)
Note: These differences may indicate the same root cause manifesting differently

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 225, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [248, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 9,
                        density: 0.75,
                    },
                ),
            ),
            Array(
                DecimalArray {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    values: Buffer<u8> {
                        length: 288,
                        alignment: Alignment(
                            16,
                        ),
                        as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                    },
                    values_type: I256,
                    validity: Validity::Array(
                        BoolArray {
                            dtype: Primitive(
                                Bool,
                                NonNullable,
                            ),
                            buffer: BitBuffer {
                                buffer: Buffer<u8> {
                                    length: 2,
                                    alignment: Alignment(
                                        1,
                                    ),
                                    as_slice: [248, 15],
                                },
                                offset: 0,
                                len: 12,
                            },
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [],
                                    },
                                },
                            },
                        },
                    ),
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734051447447459996202947475384727173595149,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-b81f7911ebda9dcfb5073d2a9ebd06374e8c7503
Branch: develop
Commit: da5d463
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12565316754/artifacts/2508042856

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-b81f7911ebda9dcfb5073d2a9ebd06374e8c7503 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/fuzz_targets/array_ops.rs:18 → fuzz/src/array/mod.rs:600 (assert_scalar_eq during Sum action)

Error Message:

Scalar mismatch: expected decimal256(10335731459288881875449326843340756734051447447459996202947475384727173595149, precision=76, scale=75), got null in step 2

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11

Similarities to Original Issue:

Same error pattern: Sum operation returns null instead of expected decimal256 value
Same array structure: ChunkedArray with 2 chunks (first chunk: 4 elements, second chunk: 8 elements after mask)
Same decimal type: Decimal(precision=76, scale=75, Nullable) with I256 values
Same root cause: Sum operation on DecimalArray chunks incorrectly returns null

Differences:

This crash occurs at step 2 (after a Mask operation), not step 1
The sequence is: Mask operation (step 0) → Sum operation (step 1) → Sum operation (step 2, crashes)
The original array has 12 elements total, masked down to 9 elements
These differences suggest the bug manifests after array transformations (masking), not just on pristine ChunkedArrays

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 256,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 225, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [248, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 9,
                        density: 0.75,
                    },
                ),
            ),
            Array(
                DecimalArray {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    values: Buffer<u8> {
                        length: 384,
                        alignment: Alignment(
                            16,
                        ),
                        as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                    },
                    values_type: I256,
                    validity: Array(
                        BoolArray {
                            dtype: Bool(
                                NonNullable,
                            ),
                            bits: BitBuffer {
                                buffer: Buffer<u8> {
                                    length: 2,
                                    alignment: Alignment(
                                        1,
                                    ),
                                    as_slice: [7, 240],
                                },
                                offset: 0,
                                len: 12,
                            },
                            validity: NonNullable,
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [
                                            (
                                                Sum,
                                                Exact(
                                                    ScalarValue(
                                                        Primitive(
                                                            U64(
                                                                3,
                                                            ),
                                                        ),
                                                    ),
                                                ),
                                            ),
                                        ],
                                    },
                                },
                            },
                        },
                    ),
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734051447447459996202947475384727173595149,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734051447447459996202947475384727173595149,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-b6cb3f5813ba435b245c5da03b3a85e034f128f3
Branch: develop
Commit: da5d463
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/19891826267/artifacts/4735834698

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-b6cb3f5813ba435b245c5da03b3a85e034f128f3 -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq (line 721)

Error Message:

Scalar mismatch: expected decimal256(17156872913354699020179491958876854354850177624110259348811988159774417861597, precision=76, scale=75), got null in step 1

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60
   7: {closure#0}
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:62:9

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: "expected decimal256(...), got null in step 1"
Same array structure: ChunkedArray with 2 chunks, 7 total elements (4+3 split)
Same decimal type: Decimal(precision=76, scale=75, Nullable)
Same values_type: I256
Same validity: AllValid in both chunks
Same operation: Sum operation at step 1

Differences:

Different specific decimal value expected (17156872... vs 22337414...)
Line number in assert_scalar_eq (721 vs 587 reported in original, though this may be due to code changes)

These differences are expected from fuzzing different inputs, but the root cause is clearly the same: sum operation on valid ChunkedArray with DecimalArray chunks incorrectly returns null instead of the computed sum.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 7,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 96,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [243, 237, 255, 255, 255, 255, 255, 255, 255, 79, 152, 30, 160, 222, 241, 221, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    17156872913354699020179491958876854354850177624110259348811988159774417861597,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    17156872913354699020179491958876854354850177624110259348811988159774417861597,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-fbe0a2d61ecaa6f02662f1022dc48dfd003ce83f
Branch: develop
Commit: da5d463
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12542906154/artifacts/2482395664

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-fbe0a2d61ecaa6f02662f1022dc48dfd003ce83f -- -rss_limit_mb=0

Auto-detected by fuzzing workflow with Claude analysis

Fuzzing Crash: Sum operation returns null for valid DecimalArray ChunkedArray #5810

Description

Fuzzing Crash Report

Analysis

Summary

Reproduction

Activity

github-actions commented on Dec 22, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 22, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 25, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 27, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 28, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 28, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 28, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 29, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 29, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 29, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 30, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 30, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 31, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 31, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Jan 1, 2026

Related Crash Detected

Crash Details