Skip to main content

vortex_array/arrays/chunked/compute/
zip.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4use itertools::Itertools;
5use vortex_error::VortexResult;
6
7use crate::ArrayRef;
8use crate::ExecutionCtx;
9use crate::IntoArray;
10use crate::array::ArrayView;
11use crate::arrays::Chunked;
12use crate::arrays::ChunkedArray;
13use crate::arrays::chunked::ChunkedArrayExt;
14use crate::arrays::chunked::paired_chunks::PairedChunksExt;
15use crate::builtins::ArrayBuiltins;
16use crate::scalar_fn::fns::zip::ZipKernel;
17
18// Push down the zip call to the chunks. Without this rule
19// the default implementation canonicalises the chunked array
20// then zips once.
21impl ZipKernel for Chunked {
22    fn zip(
23        if_true: ArrayView<'_, Chunked>,
24        if_false: &ArrayRef,
25        mask: &ArrayRef,
26        _ctx: &mut ExecutionCtx,
27    ) -> VortexResult<Option<ArrayRef>> {
28        let Some(if_false) = if_false.as_opt::<Chunked>() else {
29            return Ok(None);
30        };
31        let dtype = if_true
32            .dtype()
33            .union_nullability(if_false.dtype().nullability());
34        let chunks = if_true.paired_chunks(&if_false).map(|pair| {
35            let pair = pair?;
36            mask.slice(pair.pos)?.zip(pair.left, pair.right)
37        });
38        chunks.process_results(|chunks| {
39            // SAFETY: chunks originate from zipping slices of inputs that share dtype/nullability.
40            Some(unsafe {
41                ChunkedArray::new_unchecked_sized(
42                    chunks,
43                    dtype,
44                    if_true.nchunks() + if_false.nchunks(),
45                )
46                .into_array()
47            })
48        })
49    }
50}
51
52#[cfg(test)]
53mod tests {
54    use std::sync::LazyLock;
55
56    use vortex_buffer::buffer;
57    use vortex_mask::Mask;
58    use vortex_session::VortexSession;
59
60    use crate::ArrayRef;
61    use crate::IntoArray;
62    use crate::VortexSessionExecute;
63    use crate::arrays::Chunked;
64    use crate::arrays::ChunkedArray;
65    use crate::arrays::PrimitiveArray;
66    use crate::arrays::chunked::ChunkedArrayExt;
67    use crate::builtins::ArrayBuiltins;
68    use crate::dtype::DType;
69    use crate::dtype::Nullability;
70    use crate::dtype::PType;
71
72    static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
73
74    #[test]
75    fn test_chunked_zip_aligns_across_boundaries() {
76        let mut ctx = SESSION.create_execution_ctx();
77        let if_true = ChunkedArray::try_new(
78            vec![
79                buffer![1i32, 2].into_array(),
80                buffer![3i32].into_array(),
81                buffer![4i32, 5].into_array(),
82            ],
83            DType::Primitive(PType::I32, Nullability::NonNullable),
84        )
85        .unwrap();
86
87        let if_false = ChunkedArray::try_new(
88            vec![
89                buffer![10i32].into_array(),
90                buffer![11i32, 12].into_array(),
91                buffer![13i32, 14].into_array(),
92            ],
93            DType::Primitive(PType::I32, Nullability::NonNullable),
94        )
95        .unwrap();
96
97        let mask = Mask::from_iter([true, false, true, false, true]);
98
99        let zipped = &mask
100            .into_array()
101            .zip(if_true.into_array(), if_false.into_array())
102            .unwrap();
103        // One step of execution will push down the zip.
104        let zipped = zipped
105            .clone()
106            .execute::<ArrayRef>(&mut SESSION.create_execution_ctx())
107            .unwrap();
108        let zipped = zipped
109            .as_opt::<Chunked>()
110            .expect("zip should keep chunked encoding");
111
112        assert_eq!(zipped.nchunks(), 4);
113        let mut values: Vec<i32> = Vec::new();
114        for chunk in zipped.chunks() {
115            let primitive = chunk.execute::<PrimitiveArray>(&mut ctx).unwrap();
116            values.extend_from_slice(primitive.as_slice::<i32>());
117        }
118        assert_eq!(values, vec![1, 11, 3, 13, 5]);
119    }
120}