Fuzzing Crash: Decimal Sum Overflow in ChunkedArray

Fuzzing Crash Report

Analysis

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

Error Message:

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

Stack Trace:

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

Root Cause:

The fuzzer discovered a case where summing decimal values in a ChunkedArray results in an i256 overflow. When this happens, the sum implementation correctly returns null (as documented in vortex-array/src/compute/sum.rs:44 and tested in vortex-array/src/arrays/decimal/compute/sum.rs:363-377). However, the fuzzer's expectation logic doesn't account for this overflow behavior, causing a mismatch between the expected decimal value and the actual null result.

The issue occurs when:

A ChunkedArray contains DecimalArray chunks with very large i256 values
Multiple Sum operations are performed sequentially
The accumulated sum exceeds i256::MAX, causing CheckedAdd to return None
The sum function correctly returns Scalar::null() on overflow
The fuzzer expects the computed sum but gets null instead

This is a test infrastructure issue rather than a bug in the sum implementation. The fuzzer should either:

Detect when overflow would occur and adjust expectations
Verify that null is returned when overflow happens
Generate input values that won't overflow

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 12,
        chunks: [
            DecimalArray { ... values_type: I256, validity: AllValid ... },
            DecimalArray { ... values_type: I256, validity: AllValid ... }
        ]
    },
    actions: [
        (Sum, Scalar { value: decimal256(27897708223554751832957193840191214563962497566384571035819434488814200889077, precision=76, scale=75) }),
        (Sum, Scalar { value: decimal256(27897708223554751832957193840191214563962497566384571035819434488814200889077, precision=76, scale=75) }),
        (Sum, Scalar { value: decimal256(27897708223554751832957193840191214563962497566384571035819434488814200889077, precision=76, scale=75) }),
        (Sum, Scalar { value: decimal256(27897708223554751832957193840191214563962497566384571035819434488814200889077, precision=76, scale=75) })
    ]
}

Summary

Target: array_ops
Crash File: crash-0171cbd8eede2afdec81571443c1aa8ff4e52032
Branch: develop
Commit: 265f29a
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20425809503/artifacts/4941338081

Reproduction

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

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

Get full backtrace:

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

Auto-created by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

Stack Trace:

   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs: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 crash location: fuzz/src/array/mod.rs:705:13 in assert_scalar_eq
Same error pattern: Sum operation on decimal256 ChunkedArray returns null instead of expected value
Same component: Decimal sum operations with i256 overflow behavior
Same root cause: Fuzzer expectations don't account for i256 overflow returning null

Differences:

Current crash occurs at step 2 (after Mask operation, then Sum), while original was at step 1
Different decimal value expected: 10335731459288881875449326843340756734051447447459996202947475384727173595149 vs original 27897708223554751832957193840191214563962497566384571035819434488814200889077
Operation sequence includes Mask before Sum operations

Debug Output

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

Occurrence Details

Crash File: crash-5cfde2ab95fefd556db99b91e278d1a8287db26f
Branch: develop
Commit: 265f29a
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20425809503/artifacts/4941338081

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-5cfde2ab95fefd556db99b91e278d1a8287db26f -- -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, but affecting Primitive I64 arrays instead of Decimal arrays.

Crash Details

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

Error Message:

Scalar mismatch: expected 7988861491824505383i64, 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 symptom: Sum operation returns null when a non-null value is expected
Same root cause: Likely i64 overflow in ChunkedArray sum operation
Same pattern: Overflow causes sum to return null instead of the expected value

Differences:

Data type: Primitive I64 (NonNullable) vs Decimal256 (Nullable)
Step: Occurs at step 2 vs step 1
Operation sequence:
1. Step 0: Sum on ChunkedArray → returns null (likely overflow)
2. Step 1: Slice(2..5) → produces array with expected sum = 7988861491824505383
3. Step 2: Sum on sliced array → returns null instead of expected value

The debug output shows a ChunkedArray with 5 I64 elements split into 2 chunks. The first sum returns null (suggesting overflow), but after slicing to range 2..5, the fuzzer expects the sum of those 3 elements to be valid. However, the sum still returns null, which could indicate:

The overflow flag/state is being propagated incorrectly after slicing
The sliced array still contains values that overflow when summed
A bug in how ChunkedArray handles sum after slicing

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Primitive(
            I64,
            NonNullable,
        ),
        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, 2, 0, 0, 0, 0, 0, 0, 0, ...],
            },
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            PrimitiveArray {
                dtype: Primitive(
                    I64,
                    NonNullable,
                ),
                buffer: Buffer<u8> {
                    length: 16,
                    alignment: Alignment(
                        8,
                    ),
                    as_slice: [59, 126, 145, 145, 200, 220, 255, 255, 255, 38, 233, 255, 255, 255, 255, 59],
                },
                validity: NonNullable,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            PrimitiveArray {
                dtype: Primitive(
                    I64,
                    NonNullable,
                ),
                buffer: Buffer<u8> {
                    length: 24,
                    alignment: Alignment(
                        8,
                    ),
                    as_slice: [40, 255, 255, 255, 255, 255, 8, 255, 255, 255, 255, 51, 51, 35, 213, 51, ...],
                },
                validity: NonNullable,
                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,
                    ),
                },
            ),
        ),
        (
            Slice(
                2..5,
            ),
            Array(
                PrimitiveArray {
                    dtype: Primitive(
                        I64,
                        NonNullable,
                    ),
                    buffer: Buffer<u8> {
                        length: 24,
                        alignment: Alignment(
                            8,
                        ),
                        as_slice: [40, 255, 255, 255, 255, 255, 8, 255, 255, 255, 255, 51, 51, 35, 213, 51, ...],
                    },
                    validity: NonNullable,
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [
                                    (
                                        Sum,
                                        Exact(
                                            ScalarValue(
                                                Primitive(
                                                    I64(
                                                        7988861491824505383,
                                                    ),
                                                ),
                                            ),
                                        ),
                                    ),
                                ],
                            },
                        },
                    },
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Primitive(
                        I64,
                        Nullable,
                    ),
                    value: ScalarValue(
                        Primitive(
                            I64(
                                7988861491824505383,
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Primitive(
                        I64,
                        Nullable,
                    ),
                    value: ScalarValue(
                        Primitive(
                            I64(
                                7988861491824505383,
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-491d2a05d019c49e609745380763afd4d7b80602
Branch: develop
Commit: adf2182
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20460350217/artifacts/4952799950

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

Stack Trace:

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

Similarities to Original Issue:

Same crash location (fuzz/src/array/mod.rs:assert_scalar_eq)
Same error pattern: decimal256 sum overflow returning null instead of expected value
Same decimal dtype: precision=76, scale=75
Same array structure: ChunkedArray with 2 DecimalArray chunks (I256 values)
Same root cause: i256 overflow in decimal sum operations

Differences:

This crash occurs at step 2 (after a Mask operation), original at step 1
This crash involves a Mask action before the Sum operations
Different specific expected decimal value (but both are large i256 values that overflow)
Note: These differences may indicate the same root cause manifesting differently

Debug Output

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

Occurrence Details

Crash File: crash-0d8aeb14963da4afc4401079e49875e553965561
Branch: develop
Commit: c7b0ef9
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20472062659/artifacts/4956871043

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

Stack Trace:

   3: panic_display<vortex_error::VortexError>
             at /rustc/2ca7bcd03b87b52f7055a59b817443b0ac4a530d/library/core/src/panicking.rs:259:5
   4: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:18:13
   5: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60
   6: {closure#0}
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:62:9

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: expected decimal256 value, got null in step 1
Same root cause: ChunkedArray with DecimalArrays, sum operation returning null due to overflow
Same dtype: Decimal(precision=76, scale=75, Nullable) with I256 values
Same operation: Sum operation with multiple sequential sum actions

Differences:

Different expected decimal256 value (22293243137361037825589853430162995613510975026770896406683255121564598573485 vs 27897708223554751832957193840191214563962497566384571035819434488814200889077)
Different ChunkedArray structure: 2 chunks (4 elements + 3 elements) vs original
Note: These differences indicate the same root cause manifesting with different input values

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: [77, 71, 178, 71, 71, 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(
                                    22293243137361037825589853430162995613510975026770896406683255121564598573485,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    22293243137361037825589853430162995613510975026770896406683255121564598573485,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    22293243137361037825589853430162995613510975026770896406683255121564598573485,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    22293243137361037825589853430162995613510975026770896406683255121564598573485,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-c58ca683ff935e7aceca1e9f8a9494249978e61d
Branch: develop
Commit: c7b0ef9
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20427329551/artifacts/4941349569

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

Stack Trace:

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

Similarities to Original Issue:

Same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: "expected decimal256(..., precision=76, scale=75), got null in step 1"
Same operation: Sum on ChunkedArray with DecimalArray chunks (I256 values)
Same dtype configuration: Decimal(precision=76, scale=75, Nullable)
Same behavior: Sum operation returning null instead of expected decimal value

Differences:

Different expected value (18218662456529446802057177914973717224954237115062068378763971204891294369066 vs 27897708223554751832957193840191214563962497566384571035819434488814200889077)
Different array length: 10 elements vs 12 elements in original
Different number of chunks: 2 chunks (4 + 6 elements) vs 2 chunks in original
Note: These differences may indicate the same root cause manifesting differently with different input data

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Decimal(
            DecimalDType {
                precision: 76,
                scale: 75,
            },
            Nullable,
        ),
        len: 10,
        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: 192,
                    alignment: Alignment(
                        16,
                    ),
                    as_slice: [1, 0, 0, 0, 0, 0, 0, 0, 0, 208, 64, 171, 43, 14, 159, 153, ...],
                },
                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(
                                    18218662456529446802057177914973717224954237115062068378763971204891294369066,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    18218662456529446802057177914973717224954237115062068378763971204891294369066,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-3e2479dda749a0e47d12bb8a6d6d684abc78fed3
Branch: develop
Commit: c7b0ef9
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12969056518/artifacts/2644875803

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-3e2479dda749a0e47d12bb8a6d6d684abc78fed3 -- -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:13

Error Message:

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

Stack Trace:

   3: panic_display<vortex_error::VortexError>
             at /rustc/e7d44143a12a526488e4f0c0d7ea8e62a4fe9354/library/core/src/panicking.rs:259:5
   4: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:18:13
   5: 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 target: array_ops
Same operation: Sum on ChunkedArray with DecimalArrays (I256 values)
Same error pattern: Expected decimal256 value, got null
Same dtype: Decimal(precision=76, scale=75, Nullable)
Similar manifestation: i256 overflow causing sum to return null

Differences:

Different expected decimal value: 22788677031727905534389020372008541805690046682389818069128268972095001472584 vs 27897708223554751832957193840191214563962497566384571035819434488814200889077
Different array structure: 2 Sum operations followed by 2 ScalarAt operations vs 4 Sum operations
Note: These differences likely indicate the same root cause manifesting with different input values

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: [25, 19, 19, 19, 19, 19, 19, 19, 19, 99, 171, 49, 179, 241, 37, 20, ...],
                },
                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(
                                    22788677031727905534389020372008541805690046682389818069128268972095001472584,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    22788677031727905534389020372008541805690046682389818069128268972095001472584,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            ScalarAt(
                [
                    1,
                ],
            ),
            ScalarVec(
                [
                    Scalar {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        value: ScalarValue(
                            Decimal(
                                I256(
                                    i256(
                                        5792089237316195423570985008687907853269984665640564039457584007913129639941,
                                    ),
                                ),
                            ),
                        ),
                    },
                ],
            ),
        ),
        (
            ScalarAt(
                [
                    1,
                ],
            ),
            ScalarVec(
                [
                    Scalar {
                        dtype: Decimal(
                            DecimalDType {
                                precision: 76,
                                scale: 75,
                            },
                            Nullable,
                        ),
                        value: ScalarValue(
                            Decimal(
                                I256(
                                    i256(
                                        5792089237316195423570985008687907853269984665640564039457584007913129639941,
                                    ),
                                ),
                            ),
                        ),
                    },
                ],
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-535804df37d55e2e5e156cb7f0b78c7594f41e61
Branch: develop
Commit: c7b0ef9
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/12967638842/artifacts/2478551652

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

@claude

@claude take a day off for Christmas

@gatesn

Claude finished @gatesn's task in 16s —— View job

Happy Holidays! 🎄

Thank you for the holiday greeting! I'll stand down and not work on this issue today as requested.

Enjoy your Christmas! 🎁

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

Stack Trace:

   0: std::backtrace_rs::backtrace::libunwind::trace
             at /rustc/fabece9e9491d0a3c3655dba488881968b7c5f7a/library/backtrace/src/backtrace/libunwind.rs:117:9
   1: std::backtrace_rs::backtrace::trace_unsynchronized::<<std::backtrace::Backtrace>::create::{closure#0}>
             at /rustc/fabece9e9491d0a3c3655dba488881968b7c5f7a/library/backtrace/src/backtrace/mod.rs:66:14
   2: <std::backtrace::Backtrace>::create
             at /rustc/fabece9e9491d0a3c3655dba488881968b7c5f7a/library/std/src/backtrace.rs:331:13
   3: assert_scalar_eq
             at ./fuzz/src/array/mod.rs:721:13
   4: run_fuzz_action
             at ./fuzz/src/array/mod.rs:600:17
   5: __libfuzzer_sys_run
             at ./fuzz/fuzz_targets/array_ops.rs:14:11
   6: rust_fuzzer_test_input
             at /home/runner/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libfuzzer-sys-0.4.10/src/lib.rs:363:60

Similarities to Original Issue:

Same crash location (fuzz/src/array/mod.rs:assert_scalar_eq)
Same error pattern: "Scalar mismatch: expected decimal256(...), got null"
Same target: array_ops
Same array structure: ChunkedArray with DecimalArray chunks (precision=76, scale=75, I256 values)
Same operation: Sum operation returning null instead of expected decimal value

Differences:

Different decimal value in the error message (24160... vs 27897...)
Different step number: step 2 vs step 1
Note: These differences may indicate the same root cause (overflow) manifesting at different points in the operation sequence

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: [57, 62, 63, 52, 52, 52, 85, 255, 52, 52, 52, 52, 52, 52, 52, 52, ...],
                },
                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(
                                    24160060270585782036605178961170385448068546808674249151855748942389022508896,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    24160060270585782036605178961170385448068546808674249151855748942389022508896,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    24160060270585782036605178961170385448068546808674249151855748942389022508896,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
        (
            Sum,
            Scalar(
                Scalar {
                    dtype: Decimal(
                        DecimalDType {
                            precision: 76,
                            scale: 75,
                        },
                        Nullable,
                    ),
                    value: ScalarValue(
                        Decimal(
                            I256(
                                i256(
                                    24160060270585782036605178961170385448068546808674249151855748942389022508896,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-5c7cd24ed1749c9f852d1a91a1ef9a60be2b560c
Branch: develop
Commit: c7b0ef9e9491d0a3c3655dba488881968b7c5f7a
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20460350217/artifacts/4952799879

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

Stack Trace:

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

Similarities to Original Issue:

Exact same crash location: fuzz/src/array/mod.rs:assert_scalar_eq
Same error pattern: Sum operation returning null instead of expected decimal256 value
Same array structure: ChunkedArray with 2 DecimalArray chunks (I256 values, AllValid)
Same operation: Sum action in step 1

Differences:

Different specific decimal value expected: 22044331436753947869954475935735768584976726038646464418993071515960756371337 vs 27897708223554751832957193840191214563962497566384571035819434488814200889077
Note: These differences indicate the same root cause manifesting with different 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: [75, 87, 71, 211, 211, 211, 211, 211, 211, 99, 192, 184, 57, 74, 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: [25, 19, 19, 19, 52, 54, 59, 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(
                                    22044331436753947869954475935735768584976726038646464418993071515960756371337,
                                ),
                            ),
                        ),
                    ),
                },
            ),
        ),
    ],
}

Occurrence Details

Crash File: crash-6739e47f66cedae0857241e6471e229053a54e99
Branch: develop
Commit: 5d50f72
Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/20556254501/artifacts/4979317597

Reproduction

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

Auto-detected by fuzzing workflow with Claude analysis

Closing in favor of #5820

Fuzzing Crash: Decimal Sum Overflow in ChunkedArray #5811

Description

Fuzzing Crash Report

Analysis

Summary

Reproduction

Activity

github-actions commented on Dec 23, 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 Dec 24, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 24, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 24, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 25, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

gatesn commented on Dec 25, 2025

claude commented on Dec 25, 2025

Happy Holidays! 🎄

github-actions commented on Dec 26, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

github-actions commented on Dec 28, 2025

Related Crash Detected

Crash Details

Occurrence Details

Reproduction

connortsui20 commented on Jan 15, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions