fix[sparse]: correctly handle cast for all-patched (#6979)

Fixes #6932

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

Author: joseph-isaacs

encodings/sparse/src/compute/cast.rs

@@ -5,6 +5,7 @@ use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
+use vortex_array::scalar::Scalar;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
@@ -13,8 +14,14 @@ use crate::SparseArray;
 
 impl CastReduce for Sparse {
     fn cast(array: &SparseArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
-        // Cast both the patches values and the fill value
-        let casted_fill = array.fill_scalar().cast(dtype)?;
+        let casted_fill = if array.patches().num_patches() == array.len() {
+            // When every position is patched the fill is unused — skip casting it
+            // entirely and substitute a zero value for the target dtype.
+            Scalar::zero_value(dtype)
+        } else {
+            // Otherwise the cast must succeed.
+            array.fill_scalar().cast(dtype)?
+        };
         let casted_patches = array
             .patches()
             .clone()
@@ -114,4 +121,53 @@ mod tests {
     fn test_cast_sparse_conformance(#[case] array: SparseArray) {
         test_cast_conformance(&array.into_array());
     }
+
+    #[test]
+    fn test_cast_sparse_null_fill_all_patched_to_non_nullable() -> vortex_error::VortexResult<()> {
+        // Regression test for https://github.com/vortex-data/vortex/issues/6932
+        //
+        // When all positions are patched the null fill is unused, so a cast to
+        // non-nullable is valid.  Sparse::cast detects this case, substitutes a
+        // zero fill, and keeps the result in the Sparse encoding.
+        let sparse = SparseArray::try_new(
+            buffer![0u64, 1, 2, 3, 4].into_array(),
+            buffer![10u64, 20, 30, 40, 50].into_array(),
+            5,
+            Scalar::null_native::<u64>(),
+        )?;
+
+        let casted = sparse
+            .into_array()
+            .cast(DType::Primitive(PType::U64, Nullability::NonNullable))?;
+
+        assert_eq!(
+            casted.dtype(),
+            &DType::Primitive(PType::U64, Nullability::NonNullable)
+        );
+
+        let expected = PrimitiveArray::from_iter([10u64, 20, 30, 40, 50]);
+        assert_arrays_eq!(casted.to_primitive(), expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_fill_null_sparse_with_null_fill() -> vortex_error::VortexResult<()> {
+        // Regression test for https://github.com/vortex-data/vortex/issues/6932
+        // fill_null on a sparse array with null fill triggers an internal cast to
+        // non-nullable, which must not panic.
+        let sparse = SparseArray::try_new(
+            buffer![1u64, 3].into_array(),
+            buffer![10u64, 20].into_array(),
+            5,
+            Scalar::null_native::<u64>(),
+        )?;
+
+        let filled = sparse.into_array().fill_null(Scalar::from(0u64))?;
+
+        assert_eq!(
+            filled.dtype(),
+            &DType::Primitive(PType::U64, Nullability::NonNullable)
+        );
+        Ok(())
+    }
 }