Fuzzing Crash: Sum operation returns null for valid DecimalArray ChunkedArray

[github-actions]

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:

1. First chunk: DecimalArray with 4 elements (I256 values, AllValid)
2. 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:

1. The sum implementation for DecimalArray
2. The sum implementation for ChunkedArray when dealing with decimal chunks
3. Scalar value construction or type handling for large decimal256 values
4. 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

1. Download the crash artifact (if available)

2. 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

3. 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

[github-actions]

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

[github-actions]

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

[github-actions]

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

[github-actions]

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:

1. Step 0: Mask operation applies mask [248, 15] leaving 3 valid values
2. Step 1: First Sum succeeds
3. 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

[github-actions]

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

[github-actions]

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

[github-actions]

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

[github-actions]

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

[github-actions]

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

[github-actions]

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

[github-actions]

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

[github-actions]

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