Skip to main content

vortex_array/arrays/constant/compute/
take.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4use vortex_error::VortexResult;
5
6use crate::ArrayRef;
7use crate::IntoArray;
8use crate::array::ArrayView;
9use crate::arrays::Constant;
10use crate::arrays::ConstantArray;
11use crate::arrays::MaskedArray;
12use crate::arrays::dict::TakeReduce;
13use crate::arrays::dict::TakeReduceAdaptor;
14use crate::optimizer::rules::ParentRuleSet;
15use crate::scalar::Scalar;
16use crate::validity::Validity;
17
18impl TakeReduce for Constant {
19    fn take(array: ArrayView<'_, Constant>, indices: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
20        let result = match indices.validity()? {
21            Validity::NonNullable | Validity::AllValid => {
22                let scalar = Scalar::try_new(
23                    array
24                        .scalar()
25                        .dtype()
26                        .union_nullability(indices.dtype().nullability()),
27                    array.scalar().value().cloned(),
28                )?;
29                ConstantArray::new(scalar, indices.len()).into_array()
30            }
31            Validity::AllInvalid => ConstantArray::new(
32                Scalar::null(
33                    array
34                        .dtype()
35                        .union_nullability(indices.dtype().nullability()),
36                ),
37                indices.len(),
38            )
39            .into_array(),
40            validity @ Validity::Array(_) => {
41                let arr = ConstantArray::new(array.scalar().clone(), indices.len()).into_array();
42
43                if array.scalar().is_null() {
44                    return Ok(Some(arr));
45                }
46
47                // SAFETY: `arr` repeats a non-null scalar, and the validity comes from the indices,
48                // which have the same length as `arr`.
49                unsafe { MaskedArray::new_unchecked(arr, validity) }.into_array()
50            }
51        };
52        Ok(Some(result))
53    }
54}
55
56impl Constant {
57    pub const TAKE_RULES: ParentRuleSet<Self> =
58        ParentRuleSet::new(&[ParentRuleSet::lift(&TakeReduceAdaptor::<Self>(Self))]);
59}
60
61#[cfg(test)]
62mod tests {
63    use std::f64;
64    use std::sync::LazyLock;
65
66    use rstest::rstest;
67    use vortex_buffer::buffer;
68    use vortex_mask::AllOr;
69    use vortex_session::VortexSession;
70
71    use crate::IntoArray;
72    use crate::VortexSessionExecute;
73    use crate::arrays::ConstantArray;
74    use crate::arrays::PrimitiveArray;
75    use crate::assert_arrays_eq;
76    use crate::compute::conformance::take::test_take_conformance;
77    use crate::dtype::Nullability;
78    use crate::scalar::Scalar;
79    use crate::validity::Validity;
80
81    static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
82
83    #[test]
84    fn take_nullable_indices() {
85        let mut ctx = SESSION.create_execution_ctx();
86        let array = ConstantArray::new(42, 10).into_array();
87        let taken = array
88            .take(
89                PrimitiveArray::new(
90                    buffer![0, 5, 7],
91                    Validity::from_iter(vec![false, true, false]),
92                )
93                .into_array(),
94            )
95            .unwrap();
96        let valid_indices: &[usize] = &[1usize];
97        assert_eq!(
98            &array.dtype().with_nullability(Nullability::Nullable),
99            taken.dtype()
100        );
101        assert_arrays_eq!(
102            taken,
103            PrimitiveArray::new(
104                buffer![42i32, 42, 42],
105                Validity::from_iter([false, true, false])
106            ),
107            &mut ctx
108        );
109        assert_eq!(
110            taken
111                .validity()
112                .unwrap()
113                .execute_mask(taken.len(), &mut ctx)
114                .unwrap()
115                .indices(),
116            AllOr::Some(valid_indices)
117        );
118    }
119
120    #[test]
121    fn take_all_valid_indices() {
122        let mut ctx = SESSION.create_execution_ctx();
123        let array = ConstantArray::new(42, 10).into_array();
124        let taken = array
125            .take(PrimitiveArray::new(buffer![0, 5, 7], Validity::AllValid).into_array())
126            .unwrap();
127        assert_eq!(
128            &array.dtype().with_nullability(Nullability::Nullable),
129            taken.dtype()
130        );
131        assert_arrays_eq!(
132            taken,
133            PrimitiveArray::new(buffer![42i32, 42, 42], Validity::AllValid),
134            &mut ctx
135        );
136        assert_eq!(
137            taken
138                .validity()
139                .unwrap()
140                .execute_mask(taken.len(), &mut ctx)
141                .unwrap()
142                .indices(),
143            AllOr::All
144        );
145    }
146
147    #[rstest]
148    #[case(ConstantArray::new(42i32, 5))]
149    #[case(ConstantArray::new(f64::consts::PI, 10))]
150    #[case(ConstantArray::new(Scalar::from("hello"), 3))]
151    #[case(ConstantArray::new(Scalar::null_native::<i64>(), 5))]
152    #[case(ConstantArray::new(true, 1))]
153    fn test_take_constant_conformance(#[case] array: ConstantArray) {
154        test_take_conformance(&array.into_array(), &mut SESSION.create_execution_ctx());
155    }
156}