Remove len parameter from ScalarFnArray::try_new

encodings/datetime-parts/src/compute/rules.rs

@@ -133,10 +133,9 @@ impl ArrayParentReduceRule<DateTimeParts> for DTPComparisonPushDownRule {
             }
         }
 
-        let result =
-            ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children, parent.len())?
-                .into_array()
-                .optimize()?;
+        let result = ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?
+            .into_array()
+            .optimize()?;
 
         Ok(Some(result))
     }

encodings/runend/src/rules.rs

@@ -77,8 +77,7 @@ impl ArrayParentReduceRule<RunEnd> for RunEndScalarFnRule {
         }
 
         let new_values =
-            ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children, values_len)?
-                .into_array();
+            ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?.into_array();
 
         Ok(Some(
             unsafe {

vortex-array/src/arrays/chunked/compute/rules.rs

@@ -48,13 +48,9 @@ impl ArrayParentReduceRule<Chunked> for ChunkedUnaryScalarFnPushDownRule {
         let new_chunks: Vec<_> = array
             .iter_chunks()
             .map(|chunk| {
-                ScalarFnArray::try_new(
-                    parent.scalar_fn().clone(),
-                    vec![chunk.clone()],
-                    chunk.len(),
-                )?
-                .into_array()
-                .optimize()
+                ScalarFnArray::try_new(parent.scalar_fn().clone(), vec![chunk.clone()])?
+                    .into_array()
+                    .optimize()
             })
             .try_collect()?;
 
@@ -104,7 +100,7 @@ impl ArrayParentReduceRule<Chunked> for ChunkedConstantScalarFnPushDownRule {
                     })
                     .collect();
 
-                ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children, chunk.len())?
+                ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?
                     .into_array()
                     .optimize()
             })

vortex-array/src/arrays/dict/compute/rules.rs

@@ -126,10 +126,9 @@ impl ArrayParentReduceRule<Dict> for DictionaryScalarFnValuesPushDownRule {
             }
         }
 
-        let new_values =
-            ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children, values_len)?
-                .into_array()
-                .optimize()?;
+        let new_values = ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?
+            .into_array()
+            .optimize()?;
 
         // We can only push down null-sensitive functions when we have all-valid codes.
         // In these cases, we cannot have the codes influence the nullability of the output DType.
@@ -192,13 +191,9 @@ impl ArrayParentReduceRule<Dict> for DictionaryScalarFnCodesPullUpRule {
             }
         }
 
-        let new_values = ScalarFnArray::try_new(
-            parent.scalar_fn().clone(),
-            new_children,
-            array.values().len(),
-        )?
-        .into_array()
-        .optimize()?;
+        let new_values = ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?
+            .into_array()
+            .optimize()?;
 
         let new_dict =
             unsafe { DictArray::new_unchecked(array.codes().clone(), new_values) }.into_array();

vortex-array/src/arrays/fixed_size_list/tests/nested.rs

@@ -270,7 +270,6 @@ fn test_fsl_of_fsl_with_nulls() {
 
 #[test]
 fn test_deeply_nested_fsl() {
-    let _len = 2;
     let list_size = 2;
 
     // Create a 3-level nested FSL: FSL[FSL[FSL[i32]]].

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

@@ -6,6 +6,7 @@ use std::fmt::Formatter;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 
 use crate::ArrayRef;
@@ -30,19 +31,6 @@ impl Display for ScalarFnData {
 }
 
 impl ScalarFnData {
-    /// Create a new ScalarFnArray from a scalar function and its children.
-    pub fn build(
-        scalar_fn: ScalarFnRef,
-        children: Vec<ArrayRef>,
-        len: usize,
-    ) -> VortexResult<Self> {
-        vortex_ensure!(
-            children.iter().all(|c| c.len() == len),
-            "ScalarFnArray must have children equal to the array length"
-        );
-        Ok(Self { scalar_fn })
-    }
-
     /// Get the scalar function bound to this array.
     #[inline(always)]
     pub fn scalar_fn(&self) -> &ScalarFnRef {
@@ -85,14 +73,26 @@ impl<T: TypedArrayRef<ScalarFn>> ScalarFnArrayExt for T {}
 
 impl Array<ScalarFn> {
     /// Create a new ScalarFnArray from a scalar function and its children.
-    pub fn try_new(
+    pub fn try_new(scalar_fn: ScalarFnRef, children: Vec<ArrayRef>) -> VortexResult<Self> {
+        let len = Self::infer_len(&children)?;
+        Self::try_new_with_len(scalar_fn, children, len)
+    }
+
+    /// Create a new ScalarFnArray from a scalar function, children, and an explicit length.
+    ///
+    /// This is needed for zero-child scalar functions and deserialization paths where there is no
+    /// child array to infer the length from.
+    pub fn try_new_with_len(
         scalar_fn: ScalarFnRef,
         children: Vec<ArrayRef>,
         len: usize,
     ) -> VortexResult<Self> {
+        Self::validate_children_len(&children, len)?;
         let arg_dtypes: Vec<_> = children.iter().map(|c| c.dtype().clone()).collect();
         let dtype = scalar_fn.return_dtype(&arg_dtypes)?;
-        let data = ScalarFnData::build(scalar_fn.clone(), children.clone(), len)?;
+        let data = ScalarFnData {
+            scalar_fn: scalar_fn.clone(),
+        };
         let vtable = ScalarFn { id: scalar_fn.id() };
         Ok(unsafe {
             Array::from_parts_unchecked(
@@ -101,4 +101,19 @@ impl Array<ScalarFn> {
             )
         })
     }
+
+    fn infer_len(children: &[ArrayRef]) -> VortexResult<usize> {
+        let Some(child) = children.first() else {
+            vortex_bail!("ScalarFnArray length cannot be inferred without children");
+        };
+        Ok(child.len())
+    }
+
+    fn validate_children_len(children: &[ArrayRef], len: usize) -> VortexResult<()> {
+        vortex_ensure!(
+            children.iter().all(|c| c.len() == len),
+            "ScalarFnArray must have children equal to the array length"
+        );
+        Ok(())
+    }
 }

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

@@ -82,7 +82,7 @@ impl<V: ScalarFnVTable + ScalarFnArrayVTable> ArrayPlugin for ScalarFnArrayPlugi
         let parts = <V as ScalarFnArrayVTable>::deserialize(
             &self.0, dtype, len, metadata, children, session,
         )?;
-        Ok(ScalarFnArray::try_new(
+        Ok(ScalarFnArray::try_new_with_len(
             TypedScalarFnInstance::new(self.0.clone(), parts.options).erased(),
             parts.children,
             len,

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

@@ -84,7 +84,8 @@ impl ArrayParentReduceRule<ScalarFn> for ScalarFnSliceReduceRule {
             .collect::<VortexResult<_>>()?;
 
         Ok(Some(
-            ScalarFnArray::try_new(array.scalar_fn().clone(), children, range.len())?.into_array(),
+            ScalarFnArray::try_new_with_len(array.scalar_fn().clone(), children, range.len())?
+                .into_array(),
         ))
     }
 }
@@ -142,7 +143,7 @@ impl ReduceCtx for ArrayReduceCtx {
         children: &[ReduceNodeRef],
     ) -> VortexResult<ReduceNodeRef> {
         Ok(Arc::new(
-            ScalarFnArray::try_new(
+            ScalarFnArray::try_new_with_len(
                 scalar_fn,
                 children
                     .iter()
@@ -191,8 +192,7 @@ impl ArrayParentReduceRule<ScalarFn> for ScalarFnUnaryFilterPushDownRule {
                 .try_collect()?;
 
             let new_array =
-                ScalarFnArray::try_new(child.scalar_fn().clone(), new_children, parent.len())?
-                    .into_array();
+                ScalarFnArray::try_new(child.scalar_fn().clone(), new_children)?.into_array();
 
             return Ok(Some(new_array));
         }

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

@@ -65,9 +65,12 @@ mod tests {
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::ScalarFnArray;
+    use crate::arrays::scalar_fn::ScalarFnArrayExt;
     use crate::assert_arrays_eq;
+    use crate::scalar::Scalar;
     use crate::scalar_fn::TypedScalarFnInstance;
     use crate::scalar_fn::fns::binary::Binary;
+    use crate::scalar_fn::fns::literal::Literal;
     use crate::scalar_fn::fns::operators::Operator;
     use crate::validity::Validity;
 
@@ -77,7 +80,9 @@ mod tests {
         let rhs = buffer![10i32, 20, 30].into_array();
 
         let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
-        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
+
+        assert_eq!(scalar_fn_array.len(), 3);
 
         let result = scalar_fn_array
             .into_array()
@@ -89,13 +94,47 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_scalar_fn_inferred_len_rejects_mismatched_children() {
+        let lhs = buffer![1i32, 2, 3].into_array();
+        let rhs = buffer![10i32, 20].into_array();
+
+        let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
+        let err = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])
+            .expect_err("ScalarFnArray::try_new must reject mismatched child lengths");
+
+        assert!(
+            err.to_string()
+                .contains("ScalarFnArray must have children equal to the array length")
+        );
+    }
+
+    #[test]
+    fn test_scalar_fn_without_children_requires_explicit_len() -> VortexResult<()> {
+        let scalar_fn = TypedScalarFnInstance::new(Literal, Scalar::from(1i32)).erased();
+
+        let Err(err) = ScalarFnArray::try_new(scalar_fn.clone(), vec![]) else {
+            panic!("ScalarFnArray::try_new should reject zero children");
+        };
+        assert!(
+            err.to_string()
+                .contains("ScalarFnArray length cannot be inferred without children")
+        );
+
+        let scalar_fn_array = ScalarFnArray::try_new_with_len(scalar_fn, vec![], 3)?;
+        assert_eq!(scalar_fn_array.len(), 3);
+        assert_eq!(scalar_fn_array.child_count(), 0);
+
+        Ok(())
+    }
+
     #[test]
     fn test_scalar_fn_mul() -> VortexResult<()> {
         let lhs = buffer![2i32, 3, 4].into_array();
         let rhs = buffer![5i32, 6, 7].into_array();
 
         let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Mul).erased();
-        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
 
         let result = scalar_fn_array
             .into_array()
@@ -117,7 +156,7 @@ mod tests {
         .into_array();
 
         let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
-        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
 
         let result = scalar_fn_array
             .into_array()
@@ -139,7 +178,7 @@ mod tests {
         let rhs = buffer![2i32, 5, 1].into_array();
 
         let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Eq).erased();
-        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
 
         let result = scalar_fn_array
             .into_array()

vortex-array/src/expression.rs

@@ -35,7 +35,8 @@ impl ArrayRef {
 
         // And wrap the scalar function up in an array.
         let array =
-            ScalarFnArray::try_new(expr.scalar_fn().clone(), children, self.len())?.into_array();
+            ScalarFnArray::try_new_with_len(expr.scalar_fn().clone(), children, self.len())?
+                .into_array();
 
         // Optimize the resulting array's root.
         array.optimize()