Fuzzing Crash: Decimal Sum Overflow in ChunkedArray

[github-actions]

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:

1. A ChunkedArray contains DecimalArray chunks with very large i256 values
2. Multiple Sum operations are performed sequentially
3. The accumulated sum exceeds i256::MAX, causing CheckedAdd to return None
4. The sum function correctly returns Scalar::null() on overflow
5. 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

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

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

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

[github-actions]

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:705: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

[github-actions]

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:

1. The overflow flag/state is being propagated incorrectly after slicing
2. The sliced array still contains values that overflow when summed
3. 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

[github-actions]

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

Stack Trace:

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

Similarities to Original Issue:

• Same crash location (fuzz/src/array/mod.rs:assert_scalar_eq)
• Same error pattern: 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

[github-actions]

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

[github-actions]

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

[github-actions]

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/fuzz_targets/array_ops.rs:18: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

[gatesn]

@claude take a day off for Christmas

[claude]

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! 🎁

---

[github-actions]

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

[github-actions]

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

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

Error Message:

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

[connortsui20]

Closing in favor of #5820