Skip to main content

vortex_array/arrays/constant/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::array::ArrayView;
8use crate::array::OperationsVTable;
9use crate::array::ProbeState;
10use crate::arrays::Constant;
11use crate::scalar::Scalar;
12
13impl OperationsVTable<Constant> for Constant {
14    type ProbeState = ();
15
16    fn probe_scalar(
17        state: &mut ProbeState<'_, Constant>,
18        _index: usize,
19        _ctx: &mut ExecutionCtx,
20    ) -> VortexResult<Scalar> {
21        Ok(state.array().scalar.clone())
22    }
23
24    fn scalar_at(
25        array: ArrayView<'_, Constant>,
26        index: usize,
27        ctx: &mut ExecutionCtx,
28    ) -> VortexResult<Scalar> {
29        Self::probe_scalar(&mut ProbeState::once(array), index, ctx)
30    }
31}
32
33#[cfg(test)]
34mod tests {
35    use std::sync::LazyLock;
36
37    use vortex_error::VortexResult;
38    use vortex_session::VortexSession;
39
40    use crate::IntoArray;
41    use crate::VortexSessionExecute;
42    use crate::arrays::ConstantArray;
43    use crate::dtype::DType;
44    use crate::dtype::Nullability;
45    use crate::dtype::PType;
46    use crate::dtype::UnionVariants;
47    use crate::scalar::Scalar;
48
49    static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
50
51    #[test]
52    fn scalar_at_preserves_union_scalar() -> VortexResult<()> {
53        let variants = UnionVariants::try_new(
54            ["int", "string"].into(),
55            vec![
56                DType::Primitive(PType::I32, Nullability::Nullable),
57                DType::Utf8(Nullability::NonNullable),
58            ],
59            vec![5, 9],
60        )?;
61
62        let scalar = Scalar::union(
63            variants.clone(),
64            5,
65            Scalar::primitive(42_i32, Nullability::Nullable),
66            Nullability::Nullable,
67        )?;
68        let array = ConstantArray::new(scalar.clone(), 3).into_array();
69        let mut ctx = SESSION.create_execution_ctx();
70
71        let actual = array.execute_scalar(1, &mut ctx)?;
72        assert_eq!(actual.dtype(), scalar.dtype());
73        assert_eq!(actual, scalar);
74
75        let null = Scalar::null(DType::Union(variants, Nullability::Nullable));
76        let array = ConstantArray::new(null.clone(), 3).into_array();
77
78        let actual = array.execute_scalar(1, &mut ctx)?;
79        assert_eq!(actual.dtype(), null.dtype());
80        assert_eq!(actual, null);
81
82        Ok(())
83    }
84}