test(parquet): test slice for all null chunk

Author: kszucs

parquet/src/arrow/arrow_writer/levels.rs

@@ -818,7 +818,10 @@ impl ArrayLevels {
 
         // Select the non-null indices for this chunk.
         let nni = &self.non_null_indices[chunk.value_offset..chunk.value_offset + chunk.num_values];
-        // Compute the array range spanned by the non-null indices
+        // Compute the array range spanned by the non-null indices.
+        // When nni is empty (all-null chunk), start=0, end=0 → zero-length
+        // array slice; write_batch_internal will process only the def/rep
+        // levels and write no values.
         let start = nni.first().copied().unwrap_or(0);
         let end = nni.last().map_or(0, |&i| i + 1);
         // Shift indices to be relative to the sliced array.
@@ -2270,4 +2273,30 @@ mod tests {
         assert_eq!(chunk2.non_null_indices, vec![0, 1]);
         assert_eq!(chunk2.array.len(), 2);
     }
+
+    #[test]
+    fn test_slice_for_chunk_all_null() {
+        // All-null chunk: num_values=0 → empty nni slice → zero-length array.
+        let array: ArrayRef = Arc::new(Int32Array::from(vec![Some(1), None, None, Some(4)]));
+        let logical_nulls = array.logical_nulls();
+        let levels = ArrayLevels {
+            def_levels: Some(vec![1, 0, 0, 1]),
+            rep_levels: None,
+            non_null_indices: vec![0, 3],
+            max_def_level: 1,
+            max_rep_level: 0,
+            array,
+            logical_nulls,
+        };
+        // Chunk covering only the two null rows (levels 1..3), zero non-null values.
+        let sliced = levels.slice_for_chunk(&CdcChunk {
+            level_offset: 1,
+            num_levels: 2,
+            value_offset: 1,
+            num_values: 0,
+        });
+        assert_eq!(sliced.def_levels, Some(vec![0, 0]));
+        assert_eq!(sliced.non_null_indices, Vec::<usize>::new());
+        assert_eq!(sliced.array.len(), 0);
+    }
 }

parquet/src/column/chunker/cdc.rs

@@ -328,6 +328,9 @@ impl ContentDefinedChunker {
                 let def_level = def_levels[offset];
                 self.roll_level(def_level);
                 if def_level == self.max_def_level {
+                    // For non-nested data, the leaf array has one slot per
+                    // level (nulls are array elements), so `offset` (the
+                    // level index) is the correct array index for hashing.
                     roll_value(self, offset);
                 }
                 // Check boundary before incrementing value_offset so that
@@ -690,17 +693,23 @@ mod tests {
 
         let num_levels = 20;
         // def_level=1 means non-null, def_level=0 means null
+        // Pattern: null at indices 0, 3, 6, 9, 12, 15, 18 → 7 nulls, 13 non-null
         let def_levels: Vec<i16> = (0..num_levels)
             .map(|i| if i % 3 == 0 { 0 } else { 1 })
             .collect();
+        let expected_non_null: usize = def_levels.iter().filter(|&&d| d == 1).count();
 
         let chunks = chunker.calculate(Some(&def_levels), None, num_levels, |c, i| {
             c.roll_fixed::<4>(&(i as i32).to_le_bytes());
         });
 
         assert!(!chunks.is_empty());
-        let total: usize = chunks.iter().map(|c| c.num_levels).sum();
-        assert_eq!(total, num_levels);
+        let total_levels: usize = chunks.iter().map(|c| c.num_levels).sum();
+        let total_values: usize = chunks.iter().map(|c| c.num_values).sum();
+        assert_eq!(total_levels, num_levels);
+        assert_eq!(total_values, expected_non_null);
+        // With nulls present, total_values < total_levels
+        assert!(total_values < total_levels);
     }
 }