Standardize scalar function array construction

Uses `ScalarFnFactoryExt` for tensor and geo scalar functions instead of maintaining per-function constructors. `L2Denorm` keeps its checked constructor because it validates the normalized-row invariant.

Signed-off-by: "Connor Tsui" <connor.tsui20@gmail.com>

Author: connortsui20

vortex-geo/benches/envelope.rs

@@ -25,6 +25,8 @@ use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
+use vortex_array::scalar_fn::EmptyOptions;
 use vortex_geo::scalar_fn::envelope::GeoEnvelope;
 use vortex_geo::test_harness::MultiPolygonRings;
 use vortex_geo::test_harness::geo_session;
@@ -58,9 +60,9 @@ fn coin(i: usize) -> bool {
 
 /// Execute the envelope of `column` to completion.
 fn envelope(column: &ArrayRef, ctx: &mut ExecutionCtx) -> ArrayRef {
-    GeoEnvelope::try_new_array(column.clone())
+    GeoEnvelope
+        .try_new_array(column.len(), EmptyOptions, [column.clone()])
         .unwrap()
-        .into_array()
         .execute::<Canonical>(ctx)
         .unwrap()
         .into_array()

vortex-geo/src/scalar_fn/contains.rs

@@ -6,7 +6,6 @@
 use geo::Contains;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
-use vortex_array::arrays::ScalarFnArray;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::expr::Expression;
@@ -17,7 +16,6 @@ use vortex_array::scalar_fn::EmptyOptions;
 use vortex_array::scalar_fn::ExecutionArgs;
 use vortex_array::scalar_fn::ScalarFnId;
 use vortex_array::scalar_fn::ScalarFnVTable;
-use vortex_array::scalar_fn::TypedScalarFnInstance;
 use vortex_error::VortexResult;
 use vortex_session::VortexSession;
 use vortex_session::registry::CachedId;
@@ -31,17 +29,6 @@ use crate::scalar_fn::execute::execute_null_propagating;
 #[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
 pub struct GeoContains;
 
-impl GeoContains {
-    /// A lazy `ScalarFnArray` computing per-row whether operand `a` contains operand `b`;
-    /// either may be constant. The output length is taken from `a`.
-    pub fn try_new_array(a: ArrayRef, b: ArrayRef) -> VortexResult<ScalarFnArray> {
-        ScalarFnArray::try_new(
-            TypedScalarFnInstance::new(GeoContains, EmptyOptions).erased(),
-            vec![a, b],
-        )
-    }
-}
-
 impl ScalarFnVTable for GeoContains {
     type Options = EmptyOptions;
 
@@ -127,6 +114,7 @@ mod tests {
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::ConstantArray;
+    use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
@@ -177,7 +165,7 @@ mod tests {
     ) -> VortexResult<()> {
         let session = vortex_array::array_session();
         let mut ctx = session.create_execution_ctx();
-        let contains = GeoContains::try_new_array(a, b)?.into_array();
+        let contains = GeoContains.try_new_array(a.len(), EmptyOptions, [a, b])?;
         assert_arrays_eq!(contains, BoolArray::from_iter(expected), &mut ctx);
         Ok(())
     }
@@ -298,7 +286,8 @@ mod tests {
 
         let container = geometry_constant(&Geometry::Polygon(rect_polygon(0.0, 0.0, 4.0, 4.0)), 3)?;
         let points = nullable_point_column(vec![Some((2.0, 2.0)), None, Some((10.0, 10.0))])?;
-        let contains = GeoContains::try_new_array(container, points)?.into_array();
+        let contains =
+            GeoContains.try_new_array(container.len(), EmptyOptions, [container, points])?;
 
         let expected = BoolArray::new(
             BitBuffer::from_iter([true, false, false]),
@@ -318,7 +307,8 @@ mod tests {
         let point_dtype = point_column(vec![0.0], vec![0.0])?.dtype().as_nullable();
         let null_const = ConstantArray::new(Scalar::null(point_dtype), 2).into_array();
         let points = point_column(vec![2.0, 10.0], vec![2.0, 10.0])?;
-        let contains = GeoContains::try_new_array(null_const, points)?.into_array();
+        let contains =
+            GeoContains.try_new_array(null_const.len(), EmptyOptions, [null_const, points])?;
 
         let expected =
             BoolArray::new(BitBuffer::from_iter([false, false]), Validity::AllInvalid).into_array();
@@ -346,7 +336,8 @@ mod tests {
             None,
             Some((4.0, 4.0)),
         ])?;
-        let contains = GeoContains::try_new_array(container, contained)?.into_array();
+        let contains =
+            GeoContains.try_new_array(container.len(), EmptyOptions, [container, contained])?;
 
         let expected = BoolArray::new(
             BitBuffer::from_iter([true, false, false, false]),
@@ -365,7 +356,8 @@ mod tests {
 
         let container = geometry_constant(&Geometry::Polygon(rect_polygon(0.0, 0.0, 4.0, 4.0)), 2)?;
         let points = nullable_point_column(vec![None, None])?;
-        let contains = GeoContains::try_new_array(container, points)?.into_array();
+        let contains =
+            GeoContains.try_new_array(container.len(), EmptyOptions, [container, points])?;
 
         let expected =
             BoolArray::new(BitBuffer::from_iter([false, false]), Validity::AllInvalid).into_array();
@@ -382,7 +374,8 @@ mod tests {
 
         let container = nullable_point_column(vec![Some((1.0, 1.0)), None])?;
         let contained = nullable_point_column(vec![None, Some((2.0, 2.0))])?;
-        let contains = GeoContains::try_new_array(container, contained)?.into_array();
+        let contains =
+            GeoContains.try_new_array(container.len(), EmptyOptions, [container, contained])?;
 
         let expected =
             BoolArray::new(BitBuffer::from_iter([false, false]), Validity::AllInvalid).into_array();

vortex-geo/src/scalar_fn/distance.rs

@@ -7,7 +7,6 @@ use geo::Distance;
 use geo::Euclidean;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
-use vortex_array::arrays::ScalarFnArray;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
@@ -19,7 +18,6 @@ use vortex_array::scalar_fn::EmptyOptions;
 use vortex_array::scalar_fn::ExecutionArgs;
 use vortex_array::scalar_fn::ScalarFnId;
 use vortex_array::scalar_fn::ScalarFnVTable;
-use vortex_array::scalar_fn::TypedScalarFnInstance;
 use vortex_error::VortexResult;
 use vortex_session::VortexSession;
 use vortex_session::registry::CachedId;
@@ -32,17 +30,6 @@ use crate::scalar_fn::execute::execute_null_propagating;
 #[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
 pub struct GeoDistance;
 
-impl GeoDistance {
-    /// A lazy `ScalarFnArray` computing the per-row distance between operands `a` and `b`; either may
-    /// be constant. The output length is taken from `a`.
-    pub fn try_new_array(a: ArrayRef, b: ArrayRef) -> VortexResult<ScalarFnArray> {
-        ScalarFnArray::try_new(
-            TypedScalarFnInstance::new(GeoDistance, EmptyOptions).erased(),
-            vec![a, b],
-        )
-    }
-}
-
 impl ScalarFnVTable for GeoDistance {
     type Options = EmptyOptions;
 
@@ -115,6 +102,7 @@ mod tests {
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::ConstantArray;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
@@ -159,7 +147,7 @@ mod tests {
 
         let a = point_column(vec![0.0, 3.0, 0.0, 3.0], vec![0.0, 0.0, 4.0, 4.0])?;
         let b = point_constant(0.0, 0.0, 4, &mut ctx)?;
-        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+        let distance = GeoDistance.try_new_array(a.len(), EmptyOptions, [a, b])?;
 
         assert_eq!(distances(distance, &mut ctx)?, vec![0.0, 3.0, 4.0, 5.0]);
         Ok(())
@@ -173,7 +161,7 @@ mod tests {
 
         let a = point_column(vec![0.0, 1.0], vec![0.0, 1.0])?;
         let b = point_column(vec![3.0, 1.0], vec![4.0, 1.0])?;
-        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+        let distance = GeoDistance.try_new_array(a.len(), EmptyOptions, [a, b])?;
 
         assert_eq!(distances(distance, &mut ctx)?, vec![5.0, 0.0]);
         Ok(())
@@ -190,7 +178,7 @@ mod tests {
         let single = polygon_column(vec![vec![ring]])?.execute_scalar(0, &mut ctx)?;
         let square = ConstantArray::new(single, 2).into_array();
         let points = point_column(vec![7.0, 2.0], vec![2.0, 2.0])?;
-        let distance = GeoDistance::try_new_array(points, square)?.into_array();
+        let distance = GeoDistance.try_new_array(points.len(), EmptyOptions, [points, square])?;
 
         assert_eq!(distances(distance, &mut ctx)?, vec![3.0, 0.0]);
         Ok(())
@@ -204,7 +192,7 @@ mod tests {
 
         let a = point_constant(0.0, 0.0, 4, &mut ctx)?;
         let b = point_column(vec![0.0, 3.0, 0.0, 3.0], vec![0.0, 0.0, 4.0, 4.0])?;
-        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+        let distance = GeoDistance.try_new_array(a.len(), EmptyOptions, [a, b])?;
 
         assert_eq!(distances(distance, &mut ctx)?, vec![0.0, 3.0, 4.0, 5.0]);
         Ok(())
@@ -218,7 +206,7 @@ mod tests {
 
         let a = point_constant(0.0, 0.0, 3, &mut ctx)?;
         let b = point_constant(3.0, 4.0, 3, &mut ctx)?;
-        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+        let distance = GeoDistance.try_new_array(a.len(), EmptyOptions, [a, b])?;
 
         assert_eq!(distances(distance, &mut ctx)?, vec![5.0, 5.0, 5.0]);
         Ok(())
@@ -245,7 +233,7 @@ mod tests {
 
         let a = nullable_point_column(vec![Some((0.0, 0.0)), None, Some((3.0, 4.0))])?;
         let b = point_constant(0.0, 0.0, 3, &mut ctx)?;
-        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+        let distance = GeoDistance.try_new_array(a.len(), EmptyOptions, [a, b])?;
 
         let expected = PrimitiveArray::new(
             vec![0.0f64, 0.0, 5.0],
@@ -264,7 +252,7 @@ mod tests {
 
         let a = nullable_point_column(vec![Some((0.0, 0.0)), None, Some((0.0, 0.0))])?;
         let b = nullable_point_column(vec![Some((3.0, 4.0)), Some((1.0, 1.0)), None])?;
-        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+        let distance = GeoDistance.try_new_array(a.len(), EmptyOptions, [a, b])?;
 
         let expected = PrimitiveArray::new(
             vec![5.0f64, 0.0, 0.0],
@@ -284,7 +272,8 @@ mod tests {
         let point_dtype = point_column(vec![0.0], vec![0.0])?.dtype().as_nullable();
         let null_const = ConstantArray::new(Scalar::null(point_dtype), 3).into_array();
         let b = point_column(vec![0.0, 3.0, 0.0], vec![0.0, 0.0, 4.0])?;
-        let distance = GeoDistance::try_new_array(null_const, b)?.into_array();
+        let distance =
+            GeoDistance.try_new_array(null_const.len(), EmptyOptions, [null_const, b])?;
 
         let expected = PrimitiveArray::new(vec![0.0f64; 3], Validity::AllInvalid).into_array();
         assert_arrays_eq!(distance, expected, &mut ctx);
@@ -299,7 +288,7 @@ mod tests {
 
         let a = nullable_point_column(vec![None, None])?;
         let b = point_constant(0.0, 0.0, 2, &mut ctx)?;
-        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+        let distance = GeoDistance.try_new_array(a.len(), EmptyOptions, [a, b])?;
 
         let expected = PrimitiveArray::new(vec![0.0f64; 2], Validity::AllInvalid).into_array();
         assert_arrays_eq!(distance, expected, &mut ctx);
@@ -315,7 +304,7 @@ mod tests {
 
         let a = nullable_point_column(vec![Some((0.0, 0.0)), None])?;
         let b = nullable_point_column(vec![None, Some((1.0, 1.0))])?;
-        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+        let distance = GeoDistance.try_new_array(a.len(), EmptyOptions, [a, b])?;
 
         let expected = PrimitiveArray::new(vec![0.0f64; 2], Validity::AllInvalid).into_array();
         assert_arrays_eq!(distance, expected, &mut ctx);
@@ -332,8 +321,8 @@ mod tests {
 
         let a = point_column(vec![], vec![])?;
         let b = point_column(vec![], vec![])?;
-        let result = GeoDistance::try_new_array(a, b)?
-            .into_array()
+        let result = GeoDistance
+            .try_new_array(a.len(), EmptyOptions, [a, b])?
             .execute::<Canonical>(&mut ctx)?
             .into_array();
 

vortex-geo/src/scalar_fn/envelope.rs

@@ -10,7 +10,6 @@ use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::ScalarFnArray;
 use vortex_array::arrays::StructArray;
 use vortex_array::arrays::extension::ExtensionArrayExt;
 use vortex_array::arrays::struct_::StructArrayExt;
@@ -25,7 +24,6 @@ use vortex_array::scalar_fn::EmptyOptions;
 use vortex_array::scalar_fn::ExecutionArgs;
 use vortex_array::scalar_fn::ScalarFnId;
 use vortex_array::scalar_fn::ScalarFnVTable;
-use vortex_array::scalar_fn::TypedScalarFnInstance;
 use vortex_array::validity::Validity;
 use vortex_buffer::BitBuffer;
 use vortex_buffer::BufferMut;
@@ -53,17 +51,6 @@ use crate::extension::validate_geometry_operands;
 #[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
 pub struct GeoEnvelope;
 
-impl GeoEnvelope {
-    /// A lazy `ScalarFnArray` computing the per-row bounding box of geometry operand `a`, which may
-    /// be constant. The output length is taken from `a`.
-    pub fn try_new_array(a: ArrayRef) -> VortexResult<ScalarFnArray> {
-        ScalarFnArray::try_new(
-            TypedScalarFnInstance::new(GeoEnvelope, EmptyOptions).erased(),
-            vec![a],
-        )
-    }
-}
-
 /// The output dtype: a nullable native 2-D box ([`Rect`], `geoarrow.box`) column. Nullable
 /// because rows without a box — null or empty geometries — are null. Metadata is defaulted.
 fn output_box_dtype() -> VortexResult<ExtDType<Rect>> {
@@ -231,6 +218,7 @@ mod tests {
     use vortex_array::arrays::ExtensionArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::StructArray;
+    use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
@@ -259,7 +247,7 @@ mod tests {
 
     /// Execute a `GeoEnvelope` over `array`, returning the lazy box column.
     fn boxes(array: ArrayRef) -> VortexResult<ArrayRef> {
-        Ok(GeoEnvelope::try_new_array(array)?.into_array())
+        GeoEnvelope.try_new_array(array.len(), EmptyOptions, [array])
     }
 
     /// A point's box is degenerate: both corners are the point itself.