prathapsridharan opened a new issue, #51018:
URL: https://github.com/apache/arrow/issues/51018
### Describe the bug, including details regarding any error messages,
version, and platform.
`pyarrow.compute.indices_nonzero()` segfaults when given a `ChunkedArray`
that has **zero chunks**.
This is not the same thing as an *empty* array. A zero-length `Array` works,
and a `ChunkedArray`
holding one empty chunk works. It is specifically the chunk**less**
`ChunkedArray` that crashes —
which is exactly the shape you get from ordinary operations like filtering a
table down to no rows,
or slicing zero rows out of it. So this is easy to hit from normal code and
hard to reproduce if you
construct "an empty array" the obvious way.
The process dies with SIGSEGV; there is no Python-level exception to catch.
#### Minimal reproducer
```python
import pyarrow as pa
import pyarrow.compute as pc
t = pa.table({"x": pa.array([1, 2, 3])})
empty = t.filter(pc.equal(t["x"], 99)) # matches nothing
mask = pc.equal(empty.column("x"), 1) # ChunkedArray, num_chunks == 0,
len == 0
pc.indices_nonzero(mask) # <- segfault
```
#### What works vs. what crashes
| input | `num_chunks` | result |
|---|---|---|
| `pa.array([], type=pa.bool_())` | n/a (`Array`) | ✅ returns `[]` |
| `pa.chunked_array([pa.array([], type=pa.bool_())])` | 1 | ✅ returns `[]` |
| `pa.chunked_array([], type=pa.bool_())` | **0** | 🔴 **SIGSEGV** |
Every one of these routes to a zero-chunk boolean `ChunkedArray` crashes:
```python
pa.chunked_array([], type=pa.bool_()) # constructed
directly
pc.equal(pa.chunked_array([[1]]).filter(pa.array([False])), 1)
pc.equal(t.filter(pc.equal(t["x"], 99)).column("x"), 1) # table
filtered to no rows
pc.equal(t.slice(0, 0).column("x"), 1) # zero-row slice
pc.equal(pc.list_flatten(empty_list_column), 1) # flatten of an
empty list column
```
#### Expected behaviour
Return an empty index array, consistent with the zero-length and
one-empty-chunk cases.
#### Affected versions
Reproduced on macOS (arm64), CPython 3.12, on every version I tried:
| pyarrow | result |
|---|---|
| 18.1.0 | segfault |
| 21.0.0 | segfault |
| 24.0.0 | segfault |
| 25.0.0 | segfault |
| 25.0.1 (latest release) | segfault |
So it is long-standing rather than a recent regression, and there is no
released version to upgrade to.
#### Scope
It appears specific to this kernel rather than general to zero-chunk
handling. On the identical
input, `unique`, `value_counts`, `sort_indices`, `dictionary_encode`,
`fill_null_forward` and `rank`
all return cleanly; `list_flatten`, `cumulative_sum` and `index_in` raise
ordinary Python exceptions.
`indices_nonzero` was the only one that crashed the process.
#### Possibly related
Zero-chunk `ChunkedArray` has been a crash source before and was fixed for
`Slice`:
- #25043 — `[C++] Slicing a ChunkedArray with zero chunks segfaults`
(ARROW-8911)
- #7262 — the fix for it
This looks like the same class of defect in a different kernel.
### Component(s)
C++, Python
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
