Skip to main content

vortex_array/arrays/chunked/vtable/
operations.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4use vortex_error::VortexResult;
5use vortex_error::vortex_err;
6
7use crate::ExecutionCtx;
8use crate::array::ArrayView;
9use crate::array::OperationsVTable;
10use crate::array::ProbeState;
11use crate::arrays::Chunked;
12use crate::arrays::chunked::ChunkedArrayExt;
13use crate::arrays::chunked::ChunkedSlots;
14use crate::scalar::Scalar;
15
16impl OperationsVTable<Chunked> for Chunked {
17    type ProbeState = ();
18
19    fn probe_scalar(
20        state: &mut ProbeState<'_, Chunked>,
21        index: usize,
22        ctx: &mut ExecutionCtx,
23    ) -> VortexResult<Scalar> {
24        let (chunk_index, chunk_offset) = state.array().find_chunk_idx(index)?;
25        let slot = ChunkedSlots::CHUNKS_OFFSET + chunk_index;
26        state
27            .slot(slot)?
28            .ok_or_else(|| vortex_err!("Chunked chunk slot {slot} is missing"))?
29            .execute_scalar(chunk_offset, ctx)
30    }
31
32    fn scalar_at(
33        array: ArrayView<'_, Chunked>,
34        index: usize,
35        ctx: &mut ExecutionCtx,
36    ) -> VortexResult<Scalar> {
37        Self::probe_scalar(&mut ProbeState::once(array), index, ctx)
38    }
39}
40
41#[cfg(test)]
42mod tests {
43    use std::ops::Range;
44    use std::sync::LazyLock;
45
46    use rstest::rstest;
47    use vortex_buffer::Buffer;
48    use vortex_buffer::buffer;
49    use vortex_session::VortexSession;
50
51    use crate::IntoArray;
52    use crate::VortexSessionExecute;
53    use crate::arrays::ChunkedArray;
54    use crate::arrays::PrimitiveArray;
55    use crate::assert_arrays_eq;
56    use crate::dtype::DType;
57    use crate::dtype::Nullability;
58    use crate::dtype::PType;
59    use crate::scalar::Scalar;
60
61    static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
62
63    fn chunked_array() -> ChunkedArray {
64        ChunkedArray::try_new(
65            vec![
66                buffer![1u64, 2, 3].into_array(),
67                buffer![4u64, 5, 6].into_array(),
68                buffer![7u64, 8, 9].into_array(),
69            ],
70            DType::Primitive(PType::U64, Nullability::NonNullable),
71        )
72        .unwrap()
73    }
74
75    #[rstest]
76    #[case::middle(2..5, &[3u64, 4, 5])]
77    #[case::begin(1..3, &[2u64, 3])]
78    #[case::aligned(3..6, &[4u64, 5, 6])]
79    #[case::many_aligned(0..6, &[1u64, 2, 3, 4, 5, 6])]
80    #[case::end(7..8, &[8u64])]
81    #[case::exactly_end(6..9, &[7u64, 8, 9])]
82    fn slice(#[case] range: Range<usize>, #[case] expected: &[u64]) {
83        let mut ctx = SESSION.create_execution_ctx();
84        assert_arrays_eq!(
85            chunked_array().slice(range).unwrap(),
86            PrimitiveArray::from_iter(expected.iter().copied()),
87            &mut ctx
88        );
89    }
90
91    #[test]
92    fn slice_empty() {
93        let chunked = ChunkedArray::try_new(vec![], PType::U32.into()).unwrap();
94        let sliced = chunked.slice(0..0).unwrap();
95
96        assert_arrays_eq!(
97            sliced,
98            PrimitiveArray::empty::<u32>(Nullability::NonNullable),
99            &mut SESSION.create_execution_ctx()
100        );
101    }
102
103    #[test]
104    fn scalar_at_empty_children_both_sides() {
105        let mut ctx = SESSION.create_execution_ctx();
106        let array = ChunkedArray::try_new(
107            vec![
108                Buffer::<u64>::empty().into_array(),
109                Buffer::<u64>::empty().into_array(),
110                buffer![1u64, 2].into_array(),
111                Buffer::<u64>::empty().into_array(),
112                Buffer::<u64>::empty().into_array(),
113            ],
114            DType::Primitive(PType::U64, Nullability::NonNullable),
115        )
116        .unwrap();
117        for (index, value) in [1u64, 2].into_iter().enumerate() {
118            assert_eq!(
119                array.execute_scalar(index, &mut ctx).unwrap(),
120                Scalar::from(value)
121            );
122        }
123        assert_arrays_eq!(array, PrimitiveArray::from_iter([1u64, 2]), &mut ctx);
124    }
125
126    #[test]
127    fn scalar_at_empty_children_trailing() {
128        let mut ctx = SESSION.create_execution_ctx();
129        let array = ChunkedArray::try_new(
130            vec![
131                buffer![1u64, 2].into_array(),
132                Buffer::<u64>::empty().into_array(),
133                Buffer::<u64>::empty().into_array(),
134                buffer![3u64, 4].into_array(),
135            ],
136            DType::Primitive(PType::U64, Nullability::NonNullable),
137        )
138        .unwrap();
139        for (index, value) in [1u64, 2, 3, 4].into_iter().enumerate() {
140            assert_eq!(
141                array.execute_scalar(index, &mut ctx).unwrap(),
142                Scalar::from(value)
143            );
144        }
145        assert_arrays_eq!(array, PrimitiveArray::from_iter([1u64, 2, 3, 4]), &mut ctx);
146    }
147
148    #[test]
149    fn scalar_at_empty_children_leading() {
150        let mut ctx = SESSION.create_execution_ctx();
151        let array = ChunkedArray::try_new(
152            vec![
153                Buffer::<u64>::empty().into_array(),
154                Buffer::<u64>::empty().into_array(),
155                buffer![1u64, 2].into_array(),
156                buffer![3u64, 4].into_array(),
157            ],
158            DType::Primitive(PType::U64, Nullability::NonNullable),
159        )
160        .unwrap();
161        for (index, value) in [1u64, 2, 3, 4].into_iter().enumerate() {
162            assert_eq!(
163                array.execute_scalar(index, &mut ctx).unwrap(),
164                Scalar::from(value)
165            );
166        }
167        assert_arrays_eq!(array, PrimitiveArray::from_iter([1u64, 2, 3, 4]), &mut ctx);
168    }
169}