vortex_array/arrays/scalar_fn/vtable/
operations.rs1use vortex_error::VortexResult;
5
6use crate::ExecutionCtx;
7use crate::IntoArray;
8use crate::ProbeState;
9use crate::array::ArrayView;
10use crate::array::OperationsVTable;
11use crate::arrays::ConstantArray;
12use crate::arrays::scalar_fn::ScalarFnArrayExt;
13use crate::arrays::scalar_fn::vtable::ScalarFn;
14use crate::columnar::Columnar;
15use crate::scalar::Scalar;
16use crate::scalar_fn::VecExecutionArgs;
17
18impl OperationsVTable<ScalarFn> for ScalarFn {
19 type ProbeState = ();
20
21 fn probe_scalar(
23 state: &mut ProbeState<'_, ScalarFn>,
24 index: usize,
25 ctx: &mut ExecutionCtx,
26 ) -> VortexResult<Scalar> {
27 Self::scalar_at(state.array(), index, ctx)
28 }
29
30 fn scalar_at(
31 array: ArrayView<'_, ScalarFn>,
32 index: usize,
33 ctx: &mut ExecutionCtx,
34 ) -> VortexResult<Scalar> {
35 let inputs: Vec<_> = array
36 .children()
37 .iter()
38 .map(|child| Ok(ConstantArray::new(child.execute_scalar(index, ctx)?, 1).into_array()))
39 .collect::<VortexResult<_>>()?;
40
41 let args = VecExecutionArgs::new(inputs, 1);
42 let result = array.scalar_fn().execute(&args, ctx)?;
43
44 let scalar = match result.execute::<Columnar>(ctx)? {
45 Columnar::Canonical(arr) => {
46 tracing::info!(
47 "Scalar function {} returned non-constant array from execution over all scalar inputs",
48 array.scalar_fn(),
49 );
50 arr.into_array().execute_scalar(0, ctx)?
51 }
52 Columnar::Constant(constant) => constant.scalar().clone(),
53 };
54
55 debug_assert_eq!(
56 scalar.dtype(),
57 array.dtype(),
58 "Scalar function {} returned dtype {:?} but expected {:?}",
59 array.scalar_fn(),
60 scalar.dtype(),
61 array.dtype()
62 );
63
64 Ok(scalar)
65 }
66}
67
68#[cfg(test)]
69mod tests {
70 use std::sync::LazyLock;
71
72 use vortex_buffer::buffer;
73 use vortex_error::VortexResult;
74 use vortex_session::VortexSession;
75
76 use crate::ArrayRef;
77 use crate::ArraySlots;
78 use crate::IntoArray;
79 use crate::VortexSessionExecute;
80 use crate::array::Array;
81 use crate::array::ArrayParts;
82 use crate::arrays::BoolArray;
83 use crate::arrays::ConstantArray;
84 use crate::arrays::PrimitiveArray;
85 use crate::arrays::ScalarFnArray;
86 use crate::arrays::scalar_fn::ScalarFnArrayExt;
87 use crate::arrays::scalar_fn::array::ScalarFnData;
88 use crate::arrays::scalar_fn::vtable::ScalarFn;
89 use crate::assert_arrays_eq;
90 use crate::dtype::DType;
91 use crate::dtype::Nullability;
92 use crate::dtype::PType;
93 use crate::scalar::Scalar;
94 use crate::scalar_fn::TypedScalarFnInstance;
95 use crate::scalar_fn::fns::binary::Binary;
96 use crate::scalar_fn::fns::list_contains::PreparedSet;
97 use crate::scalar_fn::fns::list_contains::PreparedSetData;
98 use crate::scalar_fn::fns::literal::Literal;
99 use crate::scalar_fn::fns::operators::Operator;
100 use crate::validity::Validity;
101
102 static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
103
104 #[test]
105 fn test_scalar_fn_add() -> VortexResult<()> {
106 let mut ctx = SESSION.create_execution_ctx();
107 let lhs = buffer![1i32, 2, 3].into_array();
108 let rhs = buffer![10i32, 20, 30].into_array();
109
110 let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
111 let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
112
113 assert_eq!(scalar_fn_array.len(), 3);
114
115 let expected = buffer![11i32, 22, 33].into_array();
116 assert_arrays_eq!(scalar_fn_array, expected, &mut ctx);
117
118 Ok(())
119 }
120
121 #[test]
122 fn test_scalar_fn_inferred_len_rejects_mismatched_children() {
123 let lhs = buffer![1i32, 2, 3].into_array();
124 let rhs = buffer![10i32, 20].into_array();
125
126 let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
127 let err = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])
128 .expect_err("ScalarFnArray::try_new must reject mismatched child lengths");
129
130 assert!(
131 err.to_string()
132 .contains("ScalarFnArray must have children equal to the array length")
133 );
134 }
135
136 #[test]
137 fn rejects_wrong_arity() {
138 let child = buffer![1i32, 2, 3].into_array();
139 let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
140
141 let Err(err) = ScalarFnArray::try_new(scalar_fn.clone(), vec![child.clone()]) else {
142 panic!("Binary must reject one child");
143 };
144 assert!(
145 err.to_string()
146 .contains("ScalarFnArray requires 2 children, got 1")
147 );
148
149 let Err(err) = ScalarFnArray::try_new(scalar_fn, vec![child.clone(), child.clone(), child])
150 else {
151 panic!("Binary must reject three children");
152 };
153 assert!(
154 err.to_string()
155 .contains("ScalarFnArray requires 2 children, got 3")
156 );
157 }
158
159 #[test]
160 fn rejects_missing_child_slot() {
161 let lhs = buffer![1i32, 2, 3].into_array();
162 let dtype = lhs.dtype().clone();
163 let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
164 let vtable = ScalarFn { id: scalar_fn.id() };
165 let data = ScalarFnData { scalar_fn };
166 let slots = [Some(lhs), None].into_iter().collect::<ArraySlots>();
167
168 let Err(err) =
169 Array::<ScalarFn>::try_from_parts(ArrayParts::new(vtable, dtype, 3, data, slots))
170 else {
171 panic!("ScalarFnArray must reject missing child slots");
172 };
173
174 assert!(
175 err.to_string()
176 .contains("ScalarFnArray requires every child slot to be present")
177 );
178 }
179
180 #[test]
181 fn test_scalar_fn_without_children_requires_explicit_len() -> VortexResult<()> {
182 let list = Scalar::list(
183 DType::Primitive(PType::I32, Nullability::NonNullable),
184 vec![Scalar::from(1i32)],
185 Nullability::NonNullable,
186 );
187 let scalar_fn =
188 TypedScalarFnInstance::new(PreparedSet, PreparedSetData::try_new(list.clone())?)
189 .erased();
190
191 let Err(err) = ScalarFnArray::try_new(scalar_fn.clone(), vec![]) else {
192 panic!("ScalarFnArray::try_new should reject zero children");
193 };
194 assert!(
195 err.to_string()
196 .contains("ScalarFnArray length cannot be inferred without children")
197 );
198
199 let scalar_fn_array = ScalarFnArray::try_new_with_len(scalar_fn, vec![], 3)?;
200 assert_eq!(scalar_fn_array.len(), 3);
201 assert_eq!(scalar_fn_array.child_count(), 0);
202 assert_arrays_eq!(
203 scalar_fn_array,
204 ConstantArray::new(list, 3),
205 &mut SESSION.create_execution_ctx()
206 );
207
208 Ok(())
209 }
210
211 #[test]
212 fn rejects_literal() {
213 let scalar_fn = TypedScalarFnInstance::new(Literal, Scalar::from(1i32)).erased();
214
215 let Err(err) = ScalarFnArray::try_new_with_len(scalar_fn.clone(), vec![], 3) else {
216 panic!("ScalarFnArray::try_new_with_len must reject a literal");
217 };
218 assert!(
219 err.to_string()
220 .contains("ScalarFnArray cannot wrap a literal")
221 );
222
223 let vtable = ScalarFn { id: scalar_fn.id() };
224 let data = ScalarFnData { scalar_fn };
225 let parts = ArrayParts::new(vtable, PType::I32.into(), 3, data, ArraySlots::new());
226
227 let Err(err) = Array::<ScalarFn>::try_from_parts(parts) else {
228 panic!("ScalarFnArray must reject a literal from parts");
229 };
230 assert!(
231 err.to_string()
232 .contains("ScalarFnArray cannot wrap a literal")
233 );
234 }
235
236 #[test]
237 fn test_scalar_fn_mul() -> VortexResult<()> {
238 let mut ctx = SESSION.create_execution_ctx();
239 let lhs = buffer![2i32, 3, 4].into_array();
240 let rhs = buffer![5i32, 6, 7].into_array();
241
242 let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Mul).erased();
243 let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
244
245 let expected = buffer![10i32, 18, 28].into_array();
246 assert_arrays_eq!(scalar_fn_array, expected, &mut ctx);
247
248 Ok(())
249 }
250
251 #[test]
252 fn test_scalar_fn_with_nullable() -> VortexResult<()> {
253 let mut ctx = SESSION.create_execution_ctx();
254 let lhs = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::AllValid).into_array();
255 let rhs = PrimitiveArray::new(
256 buffer![10i32, 20, 30],
257 Validity::from_iter([true, false, true]),
258 )
259 .into_array();
260
261 let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
262 let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
263
264 let expected = PrimitiveArray::new(
265 buffer![11i32, 0, 33],
266 Validity::from_iter([true, false, true]),
267 )
268 .into_array();
269 assert_arrays_eq!(scalar_fn_array, expected, &mut ctx);
270
271 Ok(())
272 }
273
274 #[test]
275 fn test_scalar_fn_comparison() -> VortexResult<()> {
276 let mut ctx = SESSION.create_execution_ctx();
277 let lhs = buffer![1i32, 5, 3].into_array();
278 let rhs = buffer![2i32, 5, 1].into_array();
279
280 let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Eq).erased();
281 let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
282
283 let expected = BoolArray::from_iter([false, true, false]).into_array();
284 assert_arrays_eq!(scalar_fn_array, expected, &mut ctx);
285
286 Ok(())
287 }
288
289 fn scalar_nested_add() -> VortexResult<ArrayRef> {
291 let lhs_n = PrimitiveArray::from_option_iter((0..10i64).map(|i| (i % 4 != 0).then_some(i)));
292 let rhs_r = PrimitiveArray::from_iter(0..10i64);
293
294 let scalar_fn_n = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
295 let args_n = vec![lhs_n.into_array(), rhs_r.into_array()];
296
297 let lhs = ScalarFnArray::try_new(scalar_fn_n, args_n)?.into_array();
298 let rhs = PrimitiveArray::from_iter(0..10i64);
299
300 let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Mul).erased();
301 let args = vec![lhs, rhs.into_array()];
302
303 Ok(ScalarFnArray::try_new(scalar_fn, args)?.into_array())
304 }
305
306 #[test]
307 fn scalar_fn_probe() -> VortexResult<()> {
308 let ctx = &mut SESSION.create_execution_ctx();
309 let array = scalar_nested_add()?;
310 let mut probe = array.probe();
311
312 assert!(!probe.execute_is_valid(0, ctx)?);
313 assert!(probe.execute_scalar(0, ctx)?.is_null());
314 assert!(probe.execute_is_valid(9, ctx)?);
315 assert_eq!(probe.execute_scalar(9, ctx)?, Scalar::from(Some(162i64)));
316
317 Ok(())
318 }
319
320 #[test]
321 fn scalar_fn_repeated_probe() -> VortexResult<()> {
322 let ctx = &mut SESSION.create_execution_ctx();
323 let array = scalar_nested_add()?;
324 let mut probe = array.repeated_probe();
325
326 assert!(!probe.execute_is_valid(0, ctx)?);
327 assert!(probe.execute_scalar(0, ctx)?.is_null());
328 assert!(probe.execute_is_valid(9, ctx)?);
329 assert_eq!(probe.execute_scalar(9, ctx)?, Scalar::from(Some(162i64)));
330
331 Ok(())
332 }
333
334 #[test]
335 fn scalar_fn_all_valid() -> VortexResult<()> {
336 let ctx = &mut SESSION.create_execution_ctx();
337 let array = scalar_nested_add()?;
338 assert!(!array.all_valid(ctx)?);
339 assert!(!array.all_invalid(ctx)?);
340 assert_eq!(array.valid_count(ctx)?, 7);
341 assert_eq!(array.invalid_count(ctx)?, 3);
342 Ok(())
343 }
344}