Fuzzing Crash: Sum operation returns null for decimal256 array

Fuzzing Crash Report

Analysis

Crash Location: fuzz/fuzz_targets/array_ops.rs:109 (in assert_scalar_eq call)

Error Message:

called `Result::unwrap()` on an `Err` value: Scalar mismatch: expected decimal256(11889627148328415379143820023197151235308090443334808325992488287690709109156, precision=76, scale=75), got null in step 1

Stack Trace:

   0: std::backtrace_rs::backtrace::libunwind::trace
   1: std::backtrace_rs::backtrace::trace_unsynchronized
   2: <std::backtrace::Backtrace>::create
   3: assert_scalar_eq at ./fuzz/fuzz_targets/array_ops.rs:203:13
   4: __libfuzzer_sys_run at ./fuzz/fuzz_targets/array_ops.rs:109:17
   5: rust_fuzzer_test_input

Root Cause:

The fuzzer discovered a bug where the sum() operation on a ChunkedArray containing DecimalArrays returns null instead of the expected decimal sum value.

The issue occurs with:

Array type: ChunkedArray containing DecimalArrays
Decimal dtype: Decimal(precision=76, scale=75, Nullable)
Values type: I256 (decimal256)
Array length: 7 elements across 2 chunks (4 + 3 elements)
Operation: Sum
Expected result: A decimal256 scalar with value 11889627148328415379143820023197151235308090443334808325992488287690709109156
Actual result: null scalar

The debug output shows:

Chunk 1: DecimalArray with 4 elements, all valid (validity: AllValid)
Chunk 2: DecimalArray with 3 elements, all valid (validity: AllValid)

Since all elements are valid (non-null), the sum operation should produce a valid decimal value, not null. This suggests a bug in the decimal sum implementation, possibly:

Incorrect handling of chunked decimal arrays in the sum operation
Loss of validity information when summing across chunks
Overflow detection incorrectly returning null
Decimal256 (I256) specific handling issues

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,
        },
        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,
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 96,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [157, 151, 151, 151, 151, 151, 151, 151, 163, 79, 152, 30, 160, 222, 241, 221, ...],
                },
                values_type: I256,
                validity: AllValid,
            },
        ],
    },
    actions: [
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    11889627148328415379143820023197151235308090443334808325992488287690709109156,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Summary

Target: array_ops
Crash File: crash-53ca215f3a66dba3da06d3ff49a29e324e83d8bd
Branch: develop
Commit: 91a62f3
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/19791355227/artifacts/4714910600

Reproduction

Download the crash artifact:
- Direct download: https://github.com/vortex-data/vortex/actions/runs/19791355227/artifacts/4714910600
- Or find operations-fuzzing-crash-artifacts at: https://github.com/vortex-data/vortex/actions/runs/19791355227
- Extract the zip file
Reproduce locally:

# The artifact contains array_ops/crash-53ca215f3a66dba3da06d3ff49a29e324e83d8bd
cargo +nightly fuzz run --sanitizer=none array_ops array_ops/crash-53ca215f3a66dba3da06d3ff49a29e324e83d8bd

Get full backtrace:

RUST_BACKTRACE=full cargo +nightly fuzz run --sanitizer=none array_ops array_ops/crash-53ca215f3a66dba3da06d3ff49a29e324e83d8bd

Auto-created by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

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

Similarities to Original Issue:

Same operation: Sum on decimal256 ChunkedArray
Same error pattern: Expected decimal value, got null
Same dtype: Decimal(precision=76, scale=75, Nullable) with I256 values
Same crash location: assertion failure in assert_scalar_eq
Both arrays have AllValid validity (no null elements)

Differences:

Empty chunk present: This crash involves a ChunkedArray with an empty second chunk (0 elements)
- Total length: 4 elements
- Chunk 1: 4 elements (buffer length: 128 bytes)
- Chunk 2: 0 elements (buffer length: 0 bytes, empty)
Original issue had 2 non-empty chunks (4 + 3 elements = 7 total)
Different decimal values involved

Analysis: The presence of an empty chunk may be triggering the same underlying bug, or could indicate that empty chunks specifically cause the Sum operation to return null incorrectly. Both cases suggest the decimal sum implementation has issues with ChunkedArrays.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 4,
        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: [6, 96, 2, 2, 2, 2, 2, 2, 2, 146, 238, 230, 112, 70, 25, 140, ...],
                },
                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: 0,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            ScalarAt(
                [
                    3,
                ],
            ),
            ScalarVec(
                [
                    Scalar {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        value: ScalarValue(
                            Decimal(
                                I256(
                                    i256(
                                        -9999999999952506221404376170704860497319129020718929660273716835152798685208,
                                    ),
                                ),
                            ),
                        ),
                    },
                ],
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    -29432100517455555454729501651297021776585684374334598343400066219768416548366,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-b193ad5142630a4d57e48b9dae3ac0630761fd30
Branch: develop
Commit: ee1e4b2
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12729667055/artifacts/2496370738

Reproduction

cargo +nightly fuzz run --sanitizer=none array_ops array_ops/crash-b193ad5142630a4d57e48b9dae3ac0630761fd30

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/fuzz_targets/array_ops.rs:18 (panic handler) → fuzz/src/array/mod.rs:701 (assert_scalar_eq)

Error Message:

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

Stack Trace:

#15 0xaaec92c5883c in core::panicking::panic_fmt
#16 0xaaec8b10fefc in panic_display<vortex_error::VortexError>
#17 0xaaec8b10fefc in array_ops::_::__libfuzzer_sys_run /home/runner/_work/vortex/vortex/fuzz/fuzz_targets/array_ops.rs:18:13
#18 0xaaec8b11d074 in rust_fuzzer_test_input

Similarities to Original Issue:

Exact same operation: Sum on ChunkedArray with DecimalArrays
Exact same error pattern: Expected decimal256 value, got null in step 1
Same decimal dtype: Decimal(precision=76, scale=75, Nullable)
Same values_type: I256 (decimal256)
Same root cause: Sum operation incorrectly returns null instead of valid decimal value
Both arrays have all-valid elements (AllValid validity)

Differences:

Different expected decimal value (11359687... vs 11889627...)
Different array length: 7 elements (4+3 chunks) vs 7 elements (4+3 chunks) - same structure!
Different crash file

Note: These differences are purely due to different fuzzer-generated input data. The root cause is identical.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 7,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 96,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [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(
                                    11359687958775047519338640557464605161938775744050392960465678194893939170764,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    11359687958775047519338640557464605161938775744050392960465678194893939170764,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    11359687958775047519338640557464605161938775744050392960465678194893939170764,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    11359687958775047519338640557464605161938775744050392960465678194893939170764,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-2781aa34129bc6bd450b5f5197c1be667098b0a1
Branch: develop
Commit: 47d6ba79e5fb8af11ba8f2aa5e5e8dcd79ced9ca
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/19857334863/artifacts/4794794267

Reproduction

cargo +nightly fuzz run --sanitizer=none array_ops array_ops/crash-2781aa34129bc6bd450b5f5197c1be667098b0a1

Auto-detected by fuzzing workflow with Claude analysis

This is almost certainly has the same root problem as #5744 (comment).

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 call)

Error Message:

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

Stack Trace:

   0: std::backtrace_rs::backtrace::libunwind::trace
   1: std::backtrace_rs::backtrace::trace_unsynchronized
   2: <std::backtrace::Backtrace>::create
   3: assert_scalar_eq at ./fuzz/src/array/mod.rs: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

Similarities to Original Issue:

Same target: array_ops
Same root cause: Sum operation on decimal256 ChunkedArray returns null instead of expected value
Same dtype: Decimal(precision=76, scale=75, Nullable) with I256 values
Same array structure: ChunkedArray containing DecimalArrays with AllValid validity
Same error pattern: "Scalar mismatch: expected decimal256(...), got null"

Differences:

This crash occurs on step 2 (after a previous Sum and MinMax operation)
The expected sum value is different (but this is just different input data)
Array length is 7 elements across 2 chunks (4 + 3 elements) - same structure as original

Additional Context:
The debug output shows the fuzzer runs multiple operations in sequence:

Step 0: Sum operation (expected the same decimal value)
Step 1: MinMax operation (succeeded)
Step 2: Sum operation again (crashes with null result)

This suggests the bug may be consistently present in the Sum operation for decimal256 ChunkedArrays, regardless of prior operations.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 7,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: Buffer<u8> {
                length: 24,
                alignment: Alignment(
                    8,
                ),
                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 128,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [3, 0, 0, 0, 0, 0, 0, 0, 0, 144, 236, 228, 101, 118, 200, 187, ...],
                },
                values_type: I256,
                validity: AllValid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            DecimalArray {
                dtype: Decimal(
                    DecimalDType {
                        precision: 76,
                        scale: 75,
                    },
                    Nullable,
                ),
                values: Buffer<u8> {
                    length: 96,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [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(
                                    25330529168272520362554200733737626795256207284823971088936184717372777235965,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            MinMax,
            MinMax(
                Some(
                    MinMaxResult {
                        min: Scalar {
                            dtype: Decimal(
                                DecimalDType {
                                    precision: 76,
                                    scale: 75,
                                },
                                NonNullable,
                            ),
                            value: ScalarValue(
                                Decimal(
                                    I256(
                                        i256(
                                            -2381470002964947782798731926685554307953789217640275362069113072534334607885,
                                        ),
                                    ),
                                ),
                            ),
                        },
                        max: Scalar {
                            dtype: Decimal(
                                DecimalDType {
                                    precision: 76,
                                    scale: 75,
                                },
                                NonNullable,
                            ),
                            value: ScalarValue(
                                Decimal(
                                    I256(
                                        i256(
                                            5792089237316195423570985008687907853269984665640564039457584007913129639941,
                                        ),
                                    ),
                                ),
                            ),
                        },
                    },
                ),
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    25330529168272520362554200733737626795256207284823971088936184717372777235965,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    25330529168272520362554200733737626795256207284823971088936184717372777235965,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-c1ea8eff6747b5fb3f13e6e42c48e18a1609ae0d
Branch: develop
Commit: baafc71
Crash Artifact: (Not set in environment)

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:705 (assert_scalar_eq) called from fuzz/src/array/mod.rs:587 (Sum operation)

Error Message:

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

Stack Trace:

   0: std::backtrace_rs::backtrace::libunwind::trace
   1: std::backtrace_rs::backtrace::trace_unsynchronized
   2: <std::backtrace::Backtrace>::create
   3: assert_scalar_eq at ./fuzz/src/array/mod.rs: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

Similarities to Original Issue:

Exact same operation: Sum on ChunkedArray with DecimalArrays
Exact same error pattern: Expected decimal256 value, got null
Same decimal dtype: Decimal(precision=76, scale=75, Nullable)
Same values_type: I256 (decimal256)
Same crash location: assert_scalar_eq at line 705
Both arrays have AllValid validity (no null elements)
Same root cause: Sum operation incorrectly returns null instead of valid decimal value

Differences:

Different array length: 12 elements (4 + 8 chunks) vs original 7 elements (4 + 3 chunks)
This crash occurs in step 3 after multiple prior operations (ScalarAt operations followed by Sum)
Different expected decimal values (but this is just different fuzzer-generated input)

Note: These differences are purely due to different fuzzer-generated input data and operation sequences. The root cause appears identical.

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: [
        (
            ScalarAt(
                [
                    11,
                ],
            ),
            ScalarVec(
                [
                    Scalar {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        value: ScalarValue(
                            Decimal(
                                I256(
                                    i256(
                                        5792089237316195423570985008687907853269984665640564039457584007913129592653,
                                    ),
                                ),
                            ),
                        ),
                    },
                ],
            ),
        ),
        (
            ScalarAt(
                [
                    11,
                    7,
                ],
            ),
            ScalarVec(
                [
                    Scalar {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        value: ScalarValue(
                            Decimal(
                                I256(
                                    i256(
                                        5792089237316195423570985008687907853269984665640564039457584007913129592653,
                                    ),
                                ),
                            ),
                        ),
                    },
                    Scalar {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        value: ScalarValue(
                            Decimal(
                                I256(
                                    i256(
                                        5792089237316195423570889227716603735216337268951367145133607836717993164806,
                                    ),
                                ),
                            ),
                        ),
                    },
                ],
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    13740018606642251263557861694826498365053167868296656633263861521691209221102,
                                ),
                            ),
                        ),
                    },
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    13740018606642251263557861694826498365053167868296656633263861521691209221102,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-a9e1233784edc1e141075fdb2cf11a0a048b20df
Branch: develop
Commit: baafc71
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12970367014/artifacts/2608026334

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

Scalar mismatch: expected decimal256(21592403684146250951879619252296564309900615620034076936466975048541093999562, 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

Similarities to Original Issue:

Same operation: Sum on ChunkedArray containing DecimalArrays
Same error pattern: Expected decimal256 value but got null
Same decimal configuration: precision=76, scale=75, I256 values
Same crash location: assert_scalar_eq in fuzz/src/array/mod.rs
Same step: step 1 (first action in sequence)

Differences:

Array length: 5 elements across 2 chunks (4 + 1) vs 7 elements across 2 chunks (4 + 3)
Expected decimal value differs
This test case has 4 consecutive Sum operations (all with same expected result), vs 1 Sum operation
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: 5,
        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: 32,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [228, 223, 223, 223, 223, 223, 223, 223, 223, 79, 162, 225, 98, 10, 189, 172, ...],
                },
                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(
                                    21592403684146250951879619252296564309900615620034076936466975048541093999562,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    21592403684146250951879619252296564309900615620034076936466975048541093999562,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    21592403684146250951879619252296564309900615620034076936466975048541093999562,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    21592403684146250951879619252296564309900615620034076936466975048541093999562,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-35c8868faa4059721cc61d52636e364c9fa3585b
Branch: develop
Commit: 746a8da
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs//artifacts/

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

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

Crash Details

Crash Location: `fuzz/src/array/mod.rs:587` (in Sum action, calling `assert_scalar_eq`)

Error Message:
```
Scalar mismatch: expected -7i64, got null in step 2
```

Stack Trace:
```
0: std::backtrace_rs::backtrace::libunwind::trace
1: std::backtrace_rs::backtrace::trace_unsynchronized
2: std::backtrace::Backtrace::create
3: <vortex_fuzz::error::VortexFuzzError as core::fmt::Display>::fmt
4: vortex_error::vortex_panic
5: run_fuzz_action (fuzz/src/array/mod.rs)
```

Similarities to Original Issue:

Both involve Sum operation on ChunkedArray returning null instead of expected value
Both have nullable dtype (original: Decimal256, this: I64)
Both arrays have AllValid validity (no actual nulls in the data)
Same root cause: Sum on ChunkedArray incorrectly returns null

Differences:

Original crash: decimal256 values, step 1
This crash: i64 primitive values, step 2
This crash has a Mask operation before the failing Sum

This strongly suggests the same underlying bug in the Sum implementation for ChunkedArray, affecting multiple data types (not just decimal256).

Debug Output

```
FuzzArrayAction {
array: ChunkedArray {
dtype: Primitive(
I64,
Nullable,
),
len: 175,
chunk_offsets: PrimitiveArray {
dtype: Primitive(
U64,
NonNullable,
),
buffer: Buffer {
length: 24,
alignment: Alignment(
8,
),
as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 175, 0, 0, 0, 0, 0, 0, 0, ...],
},
validity: NonNullable,
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [],
},
},
},
},
chunks: [
PrimitiveArray {
dtype: Primitive(
I64,
Nullable,
),
buffer: Buffer {
length: 1400,
alignment: Alignment(
8,
),
as_slice: [4, 0, 0, 8, 0, 0, 244, 97, 255, 255, 255, 255, 255, 255, 255, 255, ...],
},
validity: AllValid,
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [],
},
},
},
},
PrimitiveArray {
dtype: Primitive(
I64,
Nullable,
),
buffer: Buffer {
length: 0,
alignment: Alignment(
8,
),
as_slice: [],
},
validity: AllInvalid,
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [],
},
},
},
},
],
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [],
},
},
},
},
actions: [
(
Sum,
Scalar(
Scalar {
dtype: Primitive(
I64,
Nullable,
),
value: ScalarValue(
Null,
),
},
),
),
(
Mask(
Values(
MaskValues {
buffer: BitBuffer {
buffer: Buffer {
length: 22,
alignment: Alignment(
1,
),
as_slice: [255, 255, 255, 29, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, ...],
},
offset: 0,
len: 175,
},
indices: OnceLock(
,
),
slices: OnceLock(
,
),
true_count: 168,
density: 0.96,
},
),
),
Array(
PrimitiveArray {
dtype: Primitive(
I64,
Nullable,
),
buffer: Buffer {
length: 1400,
alignment: Alignment(
8,
),
as_slice: [4, 0, 0, 8, 0, 0, 244, 97, 255, 255, 255, 255, 255, 255, 255, 255, ...],
},
validity: Array(
BoolArray {
dtype: Bool(
NonNullable,
),
bits: BitBuffer {
buffer: Buffer {
length: 22,
alignment: Alignment(
1,
),
as_slice: [0, 0, 0, 226, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...],
},
offset: 0,
len: 175,
},
validity: NonNullable,
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [
(
Sum,
Exact(
ScalarValue(
Primitive(
U64(
7,
),
),
),
),
),
],
},
},
},
},
),
stats_set: ArrayStats {
inner: RwLock {
data: StatsSet {
values: [
(
Sum,
Exact(
ScalarValue(
Primitive(
I64(
-7,
),
),
),
),
),
],
},
},
},
},
),
),
(
Sum,
Scalar(
Scalar {
dtype: Primitive(
I64,
Nullable,
),
value: ScalarValue(
Primitive(
I64(
-7,
),
),
),
},
),
),
(
Sum,
Scalar(
Scalar {
dtype: Primitive(
I64,
Nullable,
),
value: ScalarValue(
Primitive(
I64(
-7,
),
),
),
},
),
),
],
}
```

Occurrence Details

Crash File: `crash-0fffb8cb324640b5d243ed27f0884800eaa59e49`
Branch: develop
Commit: 9159495
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12875992175/artifacts/2601695827

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

Scalar mismatch: expected decimal256(24143789081785949798232482830828738446946713832031698375288075488148091234558, 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

Similarities to Original Issue:

Same root cause: Sum operation on ChunkedArray containing DecimalArrays with I256 values (precision=76, scale=75) returns null instead of the expected decimal sum
Same error pattern: "expected decimal256(..., precision=76, scale=75), got null in step 1"
Same crash location: assert_scalar_eq in fuzz/src/array/mod.rs
Both arrays are ChunkedArrays with 2 chunks, DecimalArrays with AllValid validity
Both use decimal256 (I256) with precision=76, scale=75

Differences:

This crash has 5 elements (4 + 1 in chunks) vs original 7 elements (4 + 3)
This crash has 4 Sum operations in sequence vs original 1 Sum operation
Different expected sum values (but same type and precision/scale)
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: 5,
        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: 32,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [228, 223, 223, 223, 223, 223, 223, 223, 223, 79, 162, 225, 98, 10, 189, 160, ...],
                },
                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(
                                    24143789081785949798232482830828738446946713832031698375288075488148091234558,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    24143789081785949798232482830828738446946713832031698375288075488148091234558,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    24143789081785949798232482830828738446946713832031698375288075488148091234558,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    24143789081785949798232482830828738446946713832031698375288075488148091234558,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-aff805a79fba3c7708e5fdb76f5ba2a0532b55a1
Branch: develop
Commit: 1e0f608
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20397854025/artifacts/4933037849

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/fuzz_targets/array_ops.rs:18 (assertion in fuzzer validation)

Error Message:

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

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:18:13
   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 on ChunkedArray with DecimalArrays returns null instead of expected decimal value
Same data type: decimal256 (I256) with precision=76, scale=75
Same array structure: ChunkedArray with 2 DecimalArray chunks (4 elements + 8 elements)
Same operation: Sum returning null when a valid decimal result is expected

Differences:

This crash occurs in step 2 (after Mask operation + first Sum) vs step 1
Actions sequence includes a Mask operation before the Sum operations
Different specific decimal values involved

These differences likely indicate the same root cause manifesting under different operation sequences. The Mask operation may be affecting the array state in a way that triggers the same underlying sum bug.

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: [
	        (
	            Mask(
	                Values(
	                    MaskValues {
	                        buffer: BitBuffer {
	                            buffer: Buffer<u8> {
	                                length: 2,
	                                alignment: Alignment(
	                                    1,
	                                ),
	                                as_slice: [192, 15],
	                            },
	                            offset: 0,
	                            len: 12,
	                        },
	                        indices: OnceLock(
	                            <uninit>,
	                        ),
	                        slices: OnceLock(
	                            <uninit>,
	                        ),
	                        true_count: 6,
	                        density: 0.5,
	                    },
	                ),
	            ),
	            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: [63, 240],
	                                },
	                                offset: 0,
	                                len: 12,
	                            },
	                            validity: NonNullable,
	                            stats_set: ArrayStats {
	                                inner: RwLock {
	                                    data: StatsSet {
	                                        values: [
	                                            (
	                                                Sum,
	                                                Exact(
	                                                    ScalarValue(
	                                                        Primitive(
	                                                            U64(
	                                                                6,
	                                                            ),
	                                                        ),
	                                                    ),
	                                                ),
	                                            ),
	                                        ],
	                                    },
	                                },
	                            },
	                        },
	                    ),
	                    stats_set: ArrayStats {
	                        inner: RwLock {
	                            data: StatsSet {
	                                values: [],
	                            },
	                        },
	                    },
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    24160060270585782036605178961170385710085969337796866018654196664850545330016,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	        (
	            Sum,
	            Scalar(
	                Scalar {
	                    dtype: Decimal(
	                        DecimalDType {
	                            precision: 76,
	                            scale: 75,
	                        },
	                        Nullable,
	                    ),
	                    value: ScalarValue(
	                        Decimal(
	                            I256(
	                                i256(
	                                    24160060270585782036605178961170385710085969337796866018654196664850545330016,
	                                ),
	                            ),
	                        ),
	                    ),
	                },
	            ),
	        ),
	    ],
	}

Occurrence Details

Crash File: crash-8995d88a12427f3d5dc0b83bbf4406a149558691
Branch: develop
Commit: 265f29a
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20447659158/artifacts/4948863827

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/fuzz_targets/array_ops.rs:18 (vortex_panic call)

Error Message:

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

Stack Trace:

   #15: core::panicking::panic_fmt
   #16: panic_display<vortex_error::VortexError>
   #17: array_ops::_::__libfuzzer_sys_run at array_ops.rs:18:13
   #18: rust_fuzzer_test_input

Similarities to Original Issue:

Same error pattern: decimal sum operation returning null instead of expected decimal value
Same array structure: ChunkedArray containing DecimalArray chunks
Same decimal type: Decimal(precision=76, scale=75, Nullable) with I256 values
Same operation: Sum
All chunks have AllValid validity (no null elements)

Differences:

Step 2 instead of step 1 (multiple sequential sum operations)
Different expected decimal value (but same magnitude range)
12 elements total (4 + 8) vs 7 elements (4 + 3) in original

These differences suggest the same root cause manifesting in different scenarios - likely the decimal sum implementation has issues handling ChunkedArrays with all-valid DecimalArray chunks, possibly related to:

Incorrect null propagation in chunked decimal sum
Lost validity information when summing across chunks
Overflow handling (though values appear valid for i256)

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,
        },
        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,
            },
            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,
            },
        ],
    },
    actions: [
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 2,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [240, 15],
                            },
                            offset: 0,
                            len: 12,
                        },
                        true_count: 8,
                        density: 0.6666666666666666,
                    },
                ),
            ),
            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(...),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    16127815716597428876288067280880971414950452166312617506031188393993173419866,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-83fbc72197d0cf5aaeb63bd484a7792ae9149270
Branch: develop
Commit: 0b20606370d8cbf1e67b33b32b6b0f8d3cb3ed4f
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12840088024/artifacts/2554168494

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:assert_scalar_eq (line 708-725, called from run_fuzz_action line 600)

Error Message:

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

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:708: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

Similarities to Original Issue:

Same operation: Sum on ChunkedArray containing DecimalArrays
Same data type: decimal256 (I256) with precision=76, scale=75
Same symptom: Expected valid decimal scalar, got null instead
Same crash location: assert_scalar_eq called from Sum action in run_fuzz_action
Both arrays have all valid elements (AllValid validity)
Both are ChunkedArray with DecimalArray chunks

Differences:

Different decimal value expected: 19175742123380526396665589903927030405549308669851265837758445301729318804788 vs original 11889627148328415379143820023197151235308090443334808325992488287690709109156
Different chunk sizes: This crash has 7 elements in 2 chunks (4 + 3), original also had similar structure
Different buffer byte patterns

Note: These differences are superficial - same root cause manifesting with different fuzz-generated input data.

Debug Output

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

Occurrence Details

Crash File: crash-2edd1f83f79a4c8e6da34f99d15fa3eb24d99d35
Branch: develop
Commit: 0b20606632a9ff9d9745db4e27ee3affd27f8eba
Crash Artifact: (Environment variable not set - check workflow run)

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Closing in favor of #5820

Potential Regression Detected

A very similar crash was detected in the array_ops target on commit a30298b (Jan 16, 2026), which is AFTER this issue was closed (Jan 15, 2026).

Crash Details

Crash Location: fuzz/src/array/mod.rs:740 (assert_scalar_eq function)

Error Message:

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

Stack Trace:

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

Similarities to Original Issue:

Same error pattern: Sum operation on decimal256 ChunkedArray returns null instead of expected value
Same decimal type: precision=76, scale=75, I256 storage
Same operation: Sum
All array elements have AllValid validity (no nulls in input)
ChunkedArray structure (this one has 2 chunks with 4+1 elements vs original 4+3 elements)

Differences:

Different chunk sizes (4+1 vs 4+3 elements)
Different expected sum value
Crash occurred on commit a30298b which is after the issue was marked as completed

Occurrence Details

Crash File: crash-343129ee219a1621211668756ba60d4fd349a615
Branch: develop
Commit: a30298b (Fix: masked dtype mismatch Fix: masked array dtype mismatch #6008)
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs//artifacts/

Reproduction

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

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 5,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: BufferHandle(
                Host(
                    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: 32,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [226, 223, 223, 231, 223, 223, 223, 223, 223, 143, 246, 167, 40, 162, 147, 138, ...],
                },
                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(
                                    14261002900472964024607240519423154712485225806419118102990954211006644636255,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    14261002900472964024607240519423154712485225806419118102990954211006644636255,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    14261002900472964024607240519423154712485225806419118102990954211006644636255,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    14261002900472964024607240519423154712485225806419118102990954211006644636255,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Auto-detected by fuzzing workflow with Claude analysis

Recommendation: This appears to be either a regression of the fix that closed this issue, or the fix didn't fully address all cases. The fuzzer is performing multiple Sum operations sequentially (step 1 is the second sum), which may indicate the issue manifests after the first sum operation.

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 vortex_panic! call within error handler)

Error Message:

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

Stack Trace:

   0: std::backtrace_rs::backtrace::libunwind::trace
   1: std::backtrace_rs::backtrace::trace_unsynchronized
   2: <std::backtrace::Backtrace>::create
   3: assert_scalar_eq at ./fuzz/src/array/mod.rs:735
   4: run_fuzz_action at ./fuzz/src/array/mod.rs:619
   5: __libfuzzer_sys_run at ./fuzz/fuzz_targets/array_ops.rs:14
   6: rust_fuzzer_test_input

Similarities to Original Issue:

Same array type: ChunkedArray containing DecimalArrays
Same decimal dtype: Decimal(precision=76, scale=75, Nullable) with I256 values
Same bug: Sum operation returns null instead of expected decimal256 value
Same error pattern: "Scalar mismatch: expected decimal256(...), got null in step X"

Differences:

This crash occurs at step 2 (after a Mask operation), while the original was at step 1
The array in this case has 12 elements across 2 chunks (4 + 8 elements) vs. 7 elements (4 + 3 chunks) in the original
After the Mask operation, the array has mixed validity (some nulls introduced by the mask)
Note: These differences may indicate the same root cause manifesting differently - the Sum operation is incorrectly returning null regardless of whether it's called directly or after other operations

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: BufferHandle(
                Host(
                    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,
        },
        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,
            },
            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,
            },
        ],
    },
    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,
                        },
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    10335731459288881875449326843340756734051447447459996202947475384727173595149,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-558ab62c7f3c335269d786e18eb474706eab3871
Branch: develop
Commit: fa5eeda
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/19853933109/artifacts/4772063856

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Regression Detected - Same Crash Occurred Again

A crash with the exact same root cause was detected in the array_ops target on a newer commit. This appears to be a regression since the issue was closed on 2026-01-15.

Crash Details

Crash Location: fuzz/src/array/mod.rs:740 (in assert_scalar_eq function)

Error Message:

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

Stack Trace:

   0: std::backtrace_rs::backtrace::libunwind::trace
   1: std::backtrace_rs::backtrace::trace_unsynchronized
   2: <std::backtrace::Backtrace>::create
   3: assert_scalar_eq at ./fuzz/src/array/mod.rs:740
   4: run_fuzz_action at ./fuzz/src/array/mod.rs:619
   5: __libfuzzer_sys_run at ./fuzz/fuzz_targets/array_ops.rs:14

Similarities to Original Issue:

Exact same bug: Sum operation returns null instead of expected decimal256 value
Same array type: ChunkedArray containing DecimalArrays
Same decimal dtype: Decimal(precision=76, scale=75, Nullable) with I256 values
Same error pattern: "Scalar mismatch: expected decimal256(...), got null in step 1"
All array elements have AllValid validity (no nulls in input)

Key Difference - This is a Regression:

Commit: 953c00c (2026-01-18) - This is newer than the last crash reported in this issue (fa5eeda from 2026-01-15)
The issue was closed on 2026-01-15, but the same bug is still occurring on the current develop branch
This suggests either the fix was incomplete or a regression was introduced

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 7,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: BufferHandle(
                Host(
                    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: [6, 41, 255, 255, 255, 255, 255, 255, 255, 231, 47, 182, 55, 118, 137, 117, ...],
                },
                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(
                                    12574709691199613818907493031717553936465173677676679689112064059031745224393,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    12574709691199613818907493031717553936465173677676679689112064059031745224393,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-088e500a267b152507e37624cfe58d8cb0d3d83c
Branch: develop
Commit: 953c00c (2026-01-18)
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/21144064931/artifacts/5199893502

Reproduction

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

Recommendation: This issue should be reopened as the bug is still present on the current develop branch. The fix applied earlier may have been incomplete or a regression was introduced.

Auto-detected by fuzzing workflow with Claude analysis

Fuzzing Crash: Sum operation returns null for decimal256 array #5590

Description

Fuzzing Crash Report

Analysis

Summary

Reproduction

Activity

github-actions commented on Dec 7, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 15, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

connortsui20 commented on Dec 17, 2025

github-actions commented on Dec 18, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 18, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 18, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 19, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 21, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 23, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Jan 9, 2026

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Jan 9, 2026

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

connortsui20 commented on Jan 15, 2026

github-actions commented on Jan 17, 2026

Potential Regression Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Jan 18, 2026

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Jan 18, 2026

Regression Detected - Same Crash Occurred Again

Crash Details

Occurrence Details

Reproduction

Metadata

Metadata

Assignees

Labels

Type

Projects