vortex_array/arrays/constant/compute/
take.rs1use 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 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}