Skip to content

Commit 8c2534e

Browse files
authored
GetItem reduction rule produces new_constant instead of new_node(Literal) (#10606)
GetItem redundantly produced ScalarFnArray of Literal where it could directly produce Constant Signed-off-by: Robert Kruszewski <[email protected]>
1 parent 07fe4c5 commit 8c2534e

6 files changed

Lines changed: 88 additions & 31 deletions

File tree

‎vortex-array/src/arrays/scalar_fn/array.rs‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@ use crate::array::TypedArrayRef;
1818
use crate::arrays::ScalarFn;
1919
use crate::dtype::DType;
2020
use crate::scalar_fn::ScalarFnRef;
21+
use crate::scalar_fn::fns::literal::Literal;
2122

2223
// ScalarFnArray has a variable number of slots (one per child)
2324

@@ -104,6 +105,7 @@ impl Array<ScalarFn> {
104105
slots: ArraySlots,
105106
len: usize,
106107
) -> VortexResult<Self> {
108+
Self::validate_not_literal(&scalar_fn)?;
107109
Self::validate_arity(&scalar_fn, slots.len())?;
108110
Self::validate_children_len(&slots, len)?;
109111

@@ -145,6 +147,22 @@ impl Array<ScalarFn> {
145147
Ok(child.len())
146148
}
147149

150+
/// A literal is always a [`ConstantArray`], so a ScalarFnArray must never wrap one.
151+
///
152+
/// This is not a correctness requirement: a ScalarFnArray that wraps a literal executes
153+
/// correctly. The check finds call sites that make a literal node instead of a constant. You
154+
/// can relax it if a valid use for a literal ScalarFnArray occurs.
155+
///
156+
/// [`ConstantArray`]: crate::arrays::ConstantArray
157+
#[inline]
158+
pub(super) fn validate_not_literal(scalar_fn: &ScalarFnRef) -> VortexResult<()> {
159+
vortex_ensure!(
160+
!scalar_fn.is::<Literal>(),
161+
"ScalarFnArray cannot wrap a literal, use ConstantArray instead"
162+
);
163+
Ok(())
164+
}
165+
148166
#[inline]
149167
fn validate_arity(scalar_fn: &ScalarFnRef, child_count: usize) -> VortexResult<()> {
150168
let arity = scalar_fn.signature().arity();

‎vortex-array/src/arrays/scalar_fn/rules.rs‎

Lines changed: 10 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -171,7 +171,7 @@ mod tests {
171171
use crate::scalar::Scalar;
172172
use crate::scalar_fn::TypedScalarFnInstance;
173173
use crate::scalar_fn::fns::binary::Binary;
174-
use crate::scalar_fn::fns::literal::Literal;
174+
use crate::scalar_fn::fns::list_contains::PreparedSet;
175175
use crate::scalar_fn::fns::operators::Operator;
176176
use crate::validity::Validity;
177177

@@ -229,25 +229,23 @@ mod tests {
229229

230230
#[test]
231231
fn test_filter_pushdown_without_children() -> VortexResult<()> {
232-
let array = ScalarFnArray::try_new_with_len(
233-
TypedScalarFnInstance::new(Literal, Scalar::from(7i32)).erased(),
234-
vec![],
235-
3,
236-
)?;
237-
let parent = FilterArray::try_new(
238-
array.clone().into_array(),
239-
Mask::from_iter([true, false, true]),
240-
)?;
232+
let list = Scalar::list(
233+
DType::Primitive(PType::I32, Nullability::NonNullable),
234+
vec![Scalar::from(7i32)],
235+
Nullability::NonNullable,
236+
);
237+
let array = PreparedSet::try_new_array(list.clone(), 3)?;
238+
let parent = FilterArray::try_new(array.clone(), Mask::from_iter([true, false, true]))?;
241239

242240
let result = ScalarFilterPushdownRule
243-
.reduce_parent(array.as_view(), parent.as_view(), 0)?
241+
.reduce_parent(array.as_::<ScalarFn>(), parent.as_view(), 0)?
244242
.ok_or_else(|| vortex_err!("expected filter pushdown"))?;
245243

246244
assert_eq!(result.as_::<ScalarFn>().nchildren(), 0);
247245
assert_eq!(result.len(), 2);
248246
assert_arrays_eq!(
249247
result,
250-
ConstantArray::new(7i32, 2),
248+
ConstantArray::new(list, 2),
251249
&mut array_session().create_execution_ctx()
252250
);
253251
Ok(())

‎vortex-array/src/arrays/scalar_fn/vtable/mod.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -90,6 +90,8 @@ impl VTable for ScalarFn {
9090
"ScalarFnArray data scalar_fn does not match vtable",
9191
);
9292

93+
Array::<ScalarFn>::validate_not_literal(scalar_fn)?;
94+
9395
let missing_children = slots.iter().filter(|slot| slot.is_none()).count();
9496
vortex_ensure_eq!(
9597
missing_children,

‎vortex-array/src/arrays/scalar_fn/vtable/operations.rs‎

Lines changed: 39 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -85,9 +85,14 @@ mod tests {
8585
use crate::arrays::scalar_fn::array::ScalarFnData;
8686
use crate::arrays::scalar_fn::vtable::ScalarFn;
8787
use crate::assert_arrays_eq;
88+
use crate::dtype::DType;
89+
use crate::dtype::Nullability;
90+
use crate::dtype::PType;
8891
use crate::scalar::Scalar;
8992
use crate::scalar_fn::TypedScalarFnInstance;
9093
use crate::scalar_fn::fns::binary::Binary;
94+
use crate::scalar_fn::fns::list_contains::PreparedSet;
95+
use crate::scalar_fn::fns::list_contains::PreparedSetData;
9196
use crate::scalar_fn::fns::literal::Literal;
9297
use crate::scalar_fn::fns::operators::Operator;
9398
use crate::validity::Validity;
@@ -170,7 +175,14 @@ mod tests {
170175

171176
#[test]
172177
fn test_scalar_fn_without_children_requires_explicit_len() -> VortexResult<()> {
173-
let scalar_fn = TypedScalarFnInstance::new(Literal, Scalar::from(1i32)).erased();
178+
let list = Scalar::list(
179+
DType::Primitive(PType::I32, Nullability::NonNullable),
180+
vec![Scalar::from(1i32)],
181+
Nullability::NonNullable,
182+
);
183+
let scalar_fn =
184+
TypedScalarFnInstance::new(PreparedSet, PreparedSetData::try_new(list.clone())?)
185+
.erased();
174186

175187
let Err(err) = ScalarFnArray::try_new(scalar_fn.clone(), vec![]) else {
176188
panic!("ScalarFnArray::try_new should reject zero children");
@@ -185,13 +197,38 @@ mod tests {
185197
assert_eq!(scalar_fn_array.child_count(), 0);
186198
assert_arrays_eq!(
187199
scalar_fn_array,
188-
ConstantArray::new(1i32, 3),
200+
ConstantArray::new(list, 3),
189201
&mut array_session().create_execution_ctx()
190202
);
191203

192204
Ok(())
193205
}
194206

207+
#[test]
208+
fn rejects_literal() {
209+
let scalar_fn = TypedScalarFnInstance::new(Literal, Scalar::from(1i32)).erased();
210+
211+
let Err(err) = ScalarFnArray::try_new_with_len(scalar_fn.clone(), vec![], 3) else {
212+
panic!("ScalarFnArray::try_new_with_len must reject a literal");
213+
};
214+
assert!(
215+
err.to_string()
216+
.contains("ScalarFnArray cannot wrap a literal")
217+
);
218+
219+
let vtable = ScalarFn { id: scalar_fn.id() };
220+
let data = ScalarFnData { scalar_fn };
221+
let parts = ArrayParts::new(vtable, PType::I32.into(), 3, data, ArraySlots::new());
222+
223+
let Err(err) = Array::<ScalarFn>::try_from_parts(parts) else {
224+
panic!("ScalarFnArray must reject a literal from parts");
225+
};
226+
assert!(
227+
err.to_string()
228+
.contains("ScalarFnArray cannot wrap a literal")
229+
);
230+
}
231+
195232
#[test]
196233
fn test_scalar_fn_mul() -> VortexResult<()> {
197234
let mut ctx = array_session().create_execution_ctx();

‎vortex-array/src/scalar_fn/fns/fill_null/mod.rs‎

Lines changed: 17 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -264,7 +264,20 @@ mod tests {
264264
use crate::matcher::Matcher;
265265
use crate::optimizer::rules::ArrayParentReduceRule;
266266
use crate::scalar::Scalar;
267-
use crate::scalar_fn::fns::literal::Literal;
267+
use crate::scalar_fn::fns::binary::Binary;
268+
use crate::scalar_fn::fns::operators::Operator;
269+
270+
/// A fill of `40 + 2` that is not a [`ConstantArray`] until it executes.
271+
fn lazy_fill_42(len: usize) -> VortexResult<ArrayRef> {
272+
Ok(ScalarFnArray::try_new(
273+
Binary.bind(Operator::Add),
274+
vec![
275+
ConstantArray::new(40i32, len).into_array(),
276+
ConstantArray::new(2i32, len).into_array(),
277+
],
278+
)?
279+
.into_array())
280+
}
268281

269282
#[test]
270283
fn dtype() {
@@ -306,15 +319,10 @@ mod tests {
306319
}
307320

308321
#[test]
309-
fn evaluate_lazy_literal_fill() -> VortexResult<()> {
322+
fn evaluate_lazy_constant_fill() -> VortexResult<()> {
310323
let mut ctx = array_session().create_execution_ctx();
311324
let input = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]).into_array();
312-
let fill = ScalarFnArray::try_new_with_len(
313-
Literal.bind(Scalar::from(42i32)),
314-
vec![],
315-
input.len(),
316-
)?
317-
.into_array();
325+
let fill = lazy_fill_42(input.len())?;
318326
assert!(fill.as_constant().is_none());
319327

320328
let result = FillNull::try_new(input, fill)?
@@ -340,12 +348,7 @@ mod tests {
340348
DType::Primitive(PType::I32, Nullability::Nullable),
341349
)?
342350
.into_array();
343-
let fill = ScalarFnArray::try_new_with_len(
344-
Literal.bind(Scalar::from(42i32)),
345-
vec![],
346-
input.len(),
347-
)?
348-
.into_array();
351+
let fill = lazy_fill_42(input.len())?;
349352

350353
let result = FillNull::try_new(input, fill)?
351354
.into_array()

‎vortex-array/src/scalar_fn/fns/get_item.rs‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,6 @@ use crate::scalar_fn::ReduceNode;
3434
use crate::scalar_fn::ScalarFnId;
3535
use crate::scalar_fn::ScalarFnVTable;
3636
use crate::scalar_fn::ScalarFnVTableExt;
37-
use crate::scalar_fn::fns::literal::Literal;
3837
use crate::scalar_fn::fns::mask::Mask;
3938
use crate::scalar_fn::fns::pack::Pack;
4039

@@ -97,10 +96,10 @@ impl GetItem {
9796
}
9897

9998
// A nullable pack intersects its validity into the field, so mask the field with an
100-
// all-true literal to make its dtype nullable.
99+
// all-true constant to make its dtype nullable.
101100
Ok(Some(struct_node.new_node(
102101
Mask.bind(EmptyOptions),
103-
&[field, struct_node.new_node(Literal.bind(true.into()), &[])?],
102+
&[field, struct_node.new_constant(true.into())],
104103
)?))
105104
}
106105
}

0 commit comments

Comments
 (0)