vortex_array/arrays/chunked/vtable/
operations.rs1use 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}