Skip to main content

vortex_array/arrays/scalar_fn/vtable/
operations.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4use 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    /// The evaluated scalar carries the row's nullness, so no separate validity check is needed.
22    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    /// Mul(Add(a1, a2), a3)
290    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}