feat: teach constant to fill_null (#4985)

Does what it says on the tin.

---------

Signed-off-by: Daniel King <[email protected]>

Author: danking

vortex-array/src/arrays/constant/compute/fill_null.rs

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_scalar::Scalar;
+
+use crate::arrays::{ConstantArray, ConstantVTable};
+use crate::compute::{FillNullKernel, FillNullKernelAdapter, cast};
+use crate::{ArrayRef, IntoArray, register_kernel};
+
+impl FillNullKernel for ConstantVTable {
+    fn fill_null(&self, array: &ConstantArray, fill_value: &Scalar) -> VortexResult<ArrayRef> {
+        if array.scalar().is_null() {
+            Ok(ConstantArray::new(fill_value.clone(), array.len()).into_array())
+        } else {
+            cast(array.as_ref(), fill_value.dtype())
+        }
+    }
+}
+
+register_kernel!(FillNullKernelAdapter(ConstantVTable).lift());
+
+#[cfg(test)]
+mod test {
+    use vortex_scalar::Scalar;
+
+    use crate::IntoArray as _;
+    use crate::arrays::ConstantArray;
+    use crate::arrow::IntoArrowArray as _;
+    use crate::compute::fill_null;
+
+    #[test]
+    fn test_null() {
+        let actual = fill_null(
+            &ConstantArray::new(Scalar::from(None::<i32>), 3).into_array(),
+            &Scalar::from(1),
+        )
+        .unwrap();
+        let expected = ConstantArray::new(Scalar::from(1), 3).into_array();
+
+        assert!(!actual.dtype().is_nullable());
+
+        let actual_arrow = actual.clone().into_arrow_preferred().unwrap();
+        let expected_arrow = expected.clone().into_arrow_preferred().unwrap();
+        assert_eq!(
+            &actual_arrow,
+            &expected_arrow,
+            "{}, {}",
+            actual.display_values(),
+            expected.display_values()
+        );
+    }
+
+    #[test]
+    fn test_non_null() {
+        let actual = fill_null(
+            &ConstantArray::new(Scalar::from(Some(1)), 3).into_array(),
+            &Scalar::from(1),
+        )
+        .unwrap();
+        let expected = ConstantArray::new(Scalar::from(1), 3).into_array();
+
+        assert!(!actual.dtype().is_nullable());
+
+        let actual_arrow = actual.clone().into_arrow_preferred().unwrap();
+        let expected_arrow = expected.clone().into_arrow_preferred().unwrap();
+        assert_eq!(
+            &actual_arrow,
+            &expected_arrow,
+            "{}, {}",
+            actual.display_values(),
+            expected.display_values()
+        );
+    }
+
+    #[test]
+    fn test_non_nullable_with_nullable() {
+        let actual = fill_null(
+            &ConstantArray::new(Scalar::from(1), 3).into_array(),
+            &Scalar::from(Some(1)),
+        )
+        .unwrap();
+        let expected = ConstantArray::new(Scalar::from(1), 3).into_array();
+
+        assert!(!Scalar::from(1).dtype().is_nullable());
+
+        assert!(actual.dtype().is_nullable());
+
+        let actual_arrow = actual.clone().into_arrow_preferred().unwrap();
+        let expected_arrow = expected.clone().into_arrow_preferred().unwrap();
+        assert_eq!(
+            &actual_arrow,
+            &expected_arrow,
+            "{}, {}",
+            actual.display_values(),
+            expected.display_values()
+        );
+    }
+}

vortex-array/src/arrays/constant/compute/mod.rs

@@ -5,6 +5,7 @@ mod binary_numeric;
 mod boolean;
 mod cast;
 mod compare;
+mod fill_null;
 mod filter;
 mod invert;
 mod mask;

vortex-array/src/compute/fill_null.rs

@@ -24,6 +24,20 @@ pub(crate) fn warm_up_vtable() -> usize {
     FILL_NULL_FN.kernels().len()
 }
 
+/// Replace nulls in the array with another value.
+///
+/// # Examples
+///
+/// ```
+/// use vortex_array::arrays::{PrimitiveArray};
+/// use vortex_array::compute::{fill_null};
+/// use vortex_scalar::Scalar;
+///
+/// let array =
+///     PrimitiveArray::from_option_iter([Some(0i32), None, Some(1i32), None, Some(2i32)]);
+/// let array = fill_null(array.as_ref(), &Scalar::from(42i32)).unwrap();
+/// assert_eq!(array.display_values().to_string(), "[0i32, 42i32, 1i32, 42i32, 2i32]");
+/// ```
 pub fn fill_null(array: &dyn Array, fill_value: &Scalar) -> VortexResult<ArrayRef> {
     FILL_NULL_FN
         .invoke(&InvocationArgs {