fix: Slicing empty chunked arrays (#1870)

first finding of the new file-targeted fuzzer (which is still WIP).

Author: AdamGS

vortex-array/src/array/chunked/compute/compare.rs

@@ -15,11 +15,11 @@ impl CompareFn<ChunkedArray> for ChunkedEncoding {
         let mut idx = 0;
         let mut compare_chunks = Vec::with_capacity(lhs.nchunks());
 
-        for chunk in lhs.chunks() {
+        for chunk in lhs.chunks().filter(|c| !c.is_empty()) {
             let sliced = slice(rhs, idx, idx + chunk.len())?;
             let cmp_result = compare(&chunk, &sliced, operator)?;
-            compare_chunks.push(cmp_result);
 
+            compare_chunks.push(cmp_result);
             idx += chunk.len();
         }
 
@@ -32,3 +32,24 @@ impl CompareFn<ChunkedArray> for ChunkedEncoding {
         ))
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use crate::array::StructArray;
+    use crate::validity::Validity;
+
+    #[test]
+    fn empty_compare() {
+        let base = StructArray::try_new([].into(), [].into(), 0, Validity::NonNullable)
+            .unwrap()
+            .into_array();
+        let chunked =
+            ChunkedArray::try_new(vec![base.clone(), base.clone()], base.dtype().clone()).unwrap();
+        let chunked_empty = ChunkedArray::try_new(vec![], base.dtype().clone()).unwrap();
+
+        let r = compare(&chunked, &chunked_empty, Operator::Eq).unwrap();
+        assert!(r.is_empty());
+    }
+}

vortex-array/src/array/chunked/compute/slice.rs

@@ -1,15 +1,21 @@
-use vortex_error::VortexResult;
+use vortex_error::{vortex_bail, VortexResult};
 
 use crate::array::chunked::ChunkedArray;
 use crate::array::ChunkedEncoding;
 use crate::compute::{slice, SliceFn};
-use crate::{ArrayDType, ArrayData, IntoArrayData};
+use crate::{ArrayDType, ArrayData, ArrayLen, IntoArrayData};
 
 impl SliceFn<ChunkedArray> for ChunkedEncoding {
     fn slice(&self, array: &ChunkedArray, start: usize, stop: usize) -> VortexResult<ArrayData> {
         let (offset_chunk, offset_in_first_chunk) = array.find_chunk_idx(start);
         let (length_chunk, length_in_last_chunk) = array.find_chunk_idx(stop);
 
+        if array.is_empty() && (start != 0 || stop != 0) {
+            vortex_bail!(ComputeError: "Empty chunked array can't be sliced from {start} to {stop}");
+        } else if array.is_empty() {
+            return Ok(ChunkedArray::try_new(vec![], array.dtype().clone())?.into_array());
+        }
+
         if length_chunk == offset_chunk {
             let chunk = array.chunk(offset_chunk)?;
             return Ok(ChunkedArray::try_new(
@@ -67,44 +73,52 @@ mod tests {
     }
 
     #[test]
-    pub fn slice_middle() {
+    fn slice_middle() {
         assert_equal_slices(
             slice(chunked_array().as_ref(), 2, 5).unwrap(),
             &[3u64, 4, 5],
         )
     }
 
     #[test]
-    pub fn slice_begin() {
+    fn slice_begin() {
         assert_equal_slices(slice(chunked_array().as_ref(), 1, 3).unwrap(), &[2u64, 3]);
     }
 
     #[test]
-    pub fn slice_aligned() {
+    fn slice_aligned() {
         assert_equal_slices(
             slice(chunked_array().as_ref(), 3, 6).unwrap(),
             &[4u64, 5, 6],
         );
     }
 
     #[test]
-    pub fn slice_many_aligned() {
+    fn slice_many_aligned() {
         assert_equal_slices(
             slice(chunked_array().as_ref(), 0, 6).unwrap(),
             &[1u64, 2, 3, 4, 5, 6],
         );
     }
 
     #[test]
-    pub fn slice_end() {
+    fn slice_end() {
         assert_equal_slices(slice(chunked_array().as_ref(), 7, 8).unwrap(), &[8u64]);
     }
 
     #[test]
-    pub fn slice_exactly_end() {
+    fn slice_exactly_end() {
         assert_equal_slices(
             slice(chunked_array().as_ref(), 6, 9).unwrap(),
             &[7u64, 8, 9],
         );
     }
+
+    #[test]
+    fn slice_empty() {
+        let chunked = ChunkedArray::try_new(vec![], PType::U32.into()).unwrap();
+        let sliced = slice(chunked, 0, 0).unwrap();
+
+        assert!(sliced.is_empty());
+    }
 }

vortex-array/src/array/chunked/mod.rs

@@ -128,7 +128,7 @@ impl ChunkedArray {
             self.chunk(c).unwrap_or_else(|e| {
                 vortex_panic!(
                     e,
-                    "ChunkedArray: chunks: chunk {} should exist (nchunks: {})",
+                    "ChunkedArray: chunks: chunk {} should exist (num chunks: {})",
                     c,
                     self.nchunks()
                 )

vortex-array/src/compute/compare.rs

@@ -8,7 +8,7 @@ use vortex_scalar::Scalar;
 
 use crate::arrow::{Datum, FromArrowArray};
 use crate::encoding::Encoding;
-use crate::{ArrayDType, ArrayData};
+use crate::{ArrayDType, ArrayData, Canonical, IntoArrayData};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
 pub enum Operator {
@@ -112,6 +112,13 @@ pub fn compare(
         vortex_bail!("Compare operations only support arrays of the same type");
     }
 
+    let result_dtype =
+        DType::Bool((left.dtype().is_nullable() || right.dtype().is_nullable()).into());
+
+    if left.is_empty() {
+        return Ok(Canonical::empty(&result_dtype)?.into_array());
+    }
+
     // Always try to put constants on the right-hand side so encodings can optimise themselves.
     if left.is_constant() && !right.is_constant() {
         return compare(right, left, operator.swap());
@@ -152,7 +159,7 @@ pub fn compare(
         );
         debug_assert_eq!(
             result.dtype(),
-            &DType::Bool((left.dtype().is_nullable() || right.dtype().is_nullable()).into()),
+            &result_dtype,
             "Compare dtype mismatch {}",
             right.encoding().id()
         );