fix[array]: chunked array sum int correctly

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

@@ -42,23 +42,27 @@ register_kernel!(SumKernelAdapter(ChunkedVTable).lift());
 fn sum_int<T: NativePType + PrimInt + FromPrimitiveOrF16>(
     chunks: &[ArrayRef],
 ) -> VortexResult<Option<T>> {
-    let mut result = T::zero();
+    let mut result: Option<T> = None;
     for chunk in chunks {
         let chunk_sum = sum(chunk)?;
 
         let Some(chunk_sum) = chunk_sum.as_primitive().as_::<T>() else {
-            // Bail out missing statistic
-            return Ok(None);
-        };
-
-        let Some(chunk_result) = result.checked_add(&chunk_sum) else {
-            // Bail out on overflow
-            return Ok(None);
+            // Skip missing null chunk
+            continue;
         };
 
-        result = chunk_result;
+        result = Some(match result {
+            None => chunk_sum,
+            Some(result) => {
+                let Some(chunk_result) = result.checked_add(&chunk_sum) else {
+                    // Bail out on overflow
+                    return Ok(None);
+                };
+                chunk_result
+            }
+        });
     }
-    Ok(Some(result))
+    Ok(result)
 }
 
 fn sum_float(chunks: &[ArrayRef]) -> VortexResult<f64> {
@@ -179,6 +183,19 @@ mod tests {
         assert_eq!(result.as_primitive().as_::<f64>(), Some(36.0));
     }
 
+    #[test]
+    fn test_sum_chunked_int_almost_all_null_chunks() {
+        let chunk1 = PrimitiveArray::from_option_iter::<u32, _>(vec![Some(1)]);
+        let chunk2 = PrimitiveArray::from_option_iter::<u32, _>(vec![None]);
+
+        let dtype = chunk1.dtype().clone();
+        let chunked =
+            ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype).unwrap();
+
+        let result = sum(chunked.as_ref()).unwrap();
+        assert_eq!(result.as_primitive().as_::<u64>(), Some(1));
+    }
+
     #[test]
     fn test_sum_chunked_decimals() {
         // Create decimal chunks with precision=10, scale=2