fix[scalar_fns]: add correct pre-condition checks for all custom scalar_fn pushdown

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: joseph-isaacs

vortex-array/src/scalar_fn/fns/binary/boolean.rs

@@ -7,6 +7,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 
 use crate::ArrayRef;
+use crate::Canonical;
 use crate::DynArray;
 use crate::IntoArray;
 use crate::arrays::Constant;
@@ -39,6 +40,10 @@ pub(crate) fn execute_boolean(
     rhs: &ArrayRef,
     op: Operator,
 ) -> VortexResult<ArrayRef> {
+    if lhs.is_empty() {
+        let nullable = lhs.dtype().is_nullable() || rhs.dtype().is_nullable();
+        return Ok(Canonical::empty(&DType::Bool(nullable.into())).into_array());
+    }
     if let Some(result) = constant_boolean(lhs, rhs, op)? {
         return Ok(result);
     }

vortex-array/src/scalar_fn/fns/binary/numeric.rs

@@ -4,6 +4,7 @@
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
+use crate::Canonical;
 use crate::IntoArray;
 use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
@@ -20,6 +21,10 @@ pub(crate) fn execute_numeric(
     rhs: &ArrayRef,
     op: NumericOperator,
 ) -> VortexResult<ArrayRef> {
+    if lhs.is_empty() {
+        let nullable = lhs.dtype().is_nullable() || rhs.dtype().is_nullable();
+        return Ok(Canonical::empty(&lhs.dtype().with_nullability(nullable.into())).into_array());
+    }
     if let Some(result) = constant_numeric(lhs, rhs, op)? {
         return Ok(result);
     }

vortex-array/src/scalar_fn/fns/cast/kernel.rs

@@ -4,6 +4,7 @@
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
+use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::scalar_fn::ExactScalarFn;
@@ -60,6 +61,9 @@ where
         if array.dtype() == dtype {
             return Ok(Some(array.clone().into_array()));
         }
+        if array.len() == 0 {
+            return Ok(Some(Canonical::empty(dtype).into_array()));
+        }
         <V as CastReduce>::cast(array, dtype)
     }
 }
@@ -85,6 +89,9 @@ where
         if array.dtype() == dtype {
             return Ok(Some(array.clone().into_array()));
         }
+        if array.len() == 0 {
+            return Ok(Some(Canonical::empty(dtype).into_array()));
+        }
         <V as CastKernel>::cast(array, dtype, ctx)
     }
 }

vortex-array/src/scalar_fn/fns/cast/mod.rs

@@ -15,9 +15,11 @@ use vortex_session::VortexSession;
 
 use crate::AnyColumnar;
 use crate::ArrayRef;
+use crate::Canonical;
 use crate::CanonicalView;
 use crate::ColumnarView;
 use crate::ExecutionCtx;
+use crate::IntoArray;
 use crate::arrays::Bool;
 use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
@@ -113,6 +115,10 @@ impl ScalarFnVTable for Cast {
             return input.execute::<ArrayRef>(ctx)?.cast(target_dtype.clone());
         };
 
+        if columnar.as_ref().is_empty() {
+            return Ok(Canonical::empty(target_dtype).into_array());
+        }
+
         match columnar {
             ColumnarView::Canonical(canonical) => {
                 match cast_canonical(canonical.clone(), target_dtype, ctx)? {

vortex-array/src/scalar_fn/fns/fill_null/kernel.rs

@@ -3,6 +3,7 @@
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -57,6 +58,11 @@ pub(super) fn precondition(
     array: &ArrayRef,
     fill_value: &Scalar,
 ) -> VortexResult<Option<ArrayRef>> {
+    vortex_ensure!(
+        !fill_value.is_null(),
+        "fill_null requires a non-null fill value"
+    );
+
     // If the array has no nulls, fill_null is a no-op (just cast for nullability).
     if !array.dtype().is_nullable() || array.all_valid()? {
         return array.to_array().cast(fill_value.dtype().clone()).map(Some);

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

@@ -105,6 +105,11 @@ impl ScalarFnVTable for FillNull {
             .as_constant()
             .ok_or_else(|| vortex_err!("fill_null fill_value must be a constant/scalar"))?;
 
+        vortex_ensure!(
+            !fill_scalar.is_null(),
+            "fill_null requires a non-null fill value"
+        );
+
         let Some(columnar) = input.as_opt::<AnyColumnar>() else {
             return input.execute::<ArrayRef>(ctx)?.fill_null(fill_scalar);
         };

vortex-array/src/scalar_fn/fns/mask/kernel.rs

@@ -6,11 +6,16 @@ use vortex_error::vortex_err;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
+use crate::IntoArray;
 use crate::arrays::Bool;
+use crate::arrays::Constant;
+use crate::arrays::ConstantArray;
 use crate::arrays::scalar_fn::ExactScalarFn;
 use crate::arrays::scalar_fn::ScalarFnArrayView;
+use crate::builtins::ArrayBuiltins;
 use crate::kernel::ExecuteParentKernel;
 use crate::optimizer::rules::ArrayParentReduceRule;
+use crate::scalar::Scalar;
 use crate::scalar_fn::fns::mask::Mask as MaskExpr;
 use crate::vtable::VTable;
 
@@ -49,6 +54,26 @@ pub trait MaskKernel: VTable {
     ) -> VortexResult<Option<ArrayRef>>;
 }
 
+/// If the mask is a constant boolean, handle the trivial cases and return `Some`.
+/// Returns `None` if the mask is not a constant.
+fn handle_constant_mask(
+    array: &dyn crate::array::DynArray,
+    mask: &ArrayRef,
+) -> VortexResult<Option<ArrayRef>> {
+    if let Some(constant_mask) = mask.as_opt::<Constant>() {
+        let mask_value = constant_mask.scalar().as_bool().value().unwrap_or(false);
+        return if mask_value {
+            array.to_array().cast(array.dtype().as_nullable()).map(Some)
+        } else {
+            Ok(Some(
+                ConstantArray::new(Scalar::null(array.dtype().as_nullable()), array.len())
+                    .into_array(),
+            ))
+        };
+    }
+    Ok(None)
+}
+
 /// Adaptor that wraps a [`MaskReduce`] impl as an [`ArrayParentReduceRule`].
 #[derive(Default, Debug)]
 pub struct MaskReduceAdaptor<V>(pub V);
@@ -74,6 +99,12 @@ where
         let mask_child = parent
             .nth_child(1)
             .ok_or_else(|| vortex_err!("Mask expression must have 2 children"))?;
+
+        // Handle trivial constant mask cases before dispatching to the encoding.
+        if let Some(result) = handle_constant_mask(&**array, &mask_child)? {
+            return Ok(Some(result));
+        }
+
         if mask_child.as_opt::<Bool>().is_none() {
             return Ok(None);
         };
@@ -105,6 +136,12 @@ where
         let mask_child = parent
             .nth_child(1)
             .ok_or_else(|| vortex_err!("Mask expression must have 2 children"))?;
+
+        // Handle trivial constant mask cases before dispatching to the encoding.
+        if let Some(result) = handle_constant_mask(&**array, &mask_child)? {
+            return Ok(Some(result));
+        }
+
         <V as MaskKernel>::mask(array, &mask_child, ctx)
     }
 }