refactor: replace build_runs_with_nulls with runs_using_eq macro for run computations

Author: Weijun-H

arrow-cast/src/cast/run_array.rs

@@ -258,69 +258,65 @@ fn runs_for_null(len: usize) -> (Vec<usize>, Vec<usize>) {
     (vec![len], vec![0])
 }
 
+macro_rules! runs_using_eq {
+    ($array:expr, $equal:expr) => {{
+        let array = $array;
+        let has_nulls = array.null_count() > 0;
+        build_runs(array.len(), |lhs, rhs| {
+            if has_nulls {
+                let lhs_valid = array.is_valid(lhs);
+                let rhs_valid = array.is_valid(rhs);
+                if lhs_valid && rhs_valid {
+                    ($equal)(&array, lhs, rhs)
+                } else {
+                    lhs_valid == rhs_valid
+                }
+            } else {
+                ($equal)(&array, lhs, rhs)
+            }
+        })
+    }};
+}
+
 fn runs_for_boolean(array: &BooleanArray) -> (Vec<usize>, Vec<usize>) {
-    build_runs_with_nulls(
-        array.len(),
-        array.null_count() > 0,
-        |idx| array.is_valid(idx),
-        |idx| array.value(idx),
-    )
+    runs_using_eq!(array, |array: &BooleanArray, lhs, rhs| array.value(lhs)
+        == array.value(rhs))
 }
 
 fn runs_for_primitive<T: ArrowPrimitiveType>(
     array: &PrimitiveArray<T>,
 ) -> (Vec<usize>, Vec<usize>) {
-    build_runs_with_nulls(
-        array.len(),
-        array.null_count() > 0,
-        |idx| array.is_valid(idx),
-        |idx| array.value(idx),
-    )
+    runs_using_eq!(array, |array: &PrimitiveArray<T>, lhs, rhs| array
+        .value(lhs)
+        == array.value(rhs))
 }
 
 fn runs_for_binary<O: OffsetSizeTrait>(array: &GenericBinaryArray<O>) -> (Vec<usize>, Vec<usize>) {
-    build_runs_with_nulls(
-        array.len(),
-        array.null_count() > 0,
-        |idx| array.is_valid(idx),
-        |idx| array.value(idx),
-    )
+    runs_using_eq!(array, |array: &GenericBinaryArray<O>, lhs, rhs| array
+        .value(lhs)
+        == array.value(rhs))
 }
 
 fn runs_for_string<O: OffsetSizeTrait>(array: &GenericStringArray<O>) -> (Vec<usize>, Vec<usize>) {
-    build_runs_with_nulls(
-        array.len(),
-        array.null_count() > 0,
-        |idx| array.is_valid(idx),
-        |idx| array.value(idx),
-    )
+    runs_using_eq!(array, |array: &GenericStringArray<O>, lhs, rhs| array
+        .value(lhs)
+        == array.value(rhs))
 }
 
 fn runs_for_binary_view(array: &BinaryViewArray) -> (Vec<usize>, Vec<usize>) {
-    build_runs_with_nulls(
-        array.len(),
-        array.null_count() > 0,
-        |idx| array.is_valid(idx),
-        |idx| array.value(idx),
-    )
+    runs_using_eq!(array, |array: &BinaryViewArray, lhs, rhs| array.value(lhs)
+        == array.value(rhs))
 }
 
 fn runs_for_string_view(array: &StringViewArray) -> (Vec<usize>, Vec<usize>) {
-    build_runs_with_nulls(
-        array.len(),
-        array.null_count() > 0,
-        |idx| array.is_valid(idx),
-        |idx| array.value(idx),
-    )
+    runs_using_eq!(array, |array: &StringViewArray, lhs, rhs| array.value(lhs)
+        == array.value(rhs))
 }
 
 fn runs_for_fixed_size_binary(array: &FixedSizeBinaryArray) -> (Vec<usize>, Vec<usize>) {
-    build_runs_with_nulls(
-        array.len(),
-        array.null_count() > 0,
-        |idx| array.is_valid(idx),
-        |idx| array.value(idx),
-    )
+    runs_using_eq!(array, |array: &FixedSizeBinaryArray, lhs, rhs| array
+        .value(lhs)
+        == array.value(rhs))
 }
 
 fn runs_for_dictionary<K: ArrowDictionaryKeyType>(
@@ -347,27 +343,6 @@ fn build_runs(len: usize, mut equal: impl FnMut(usize, usize) -> bool) -> (Vec<u
     (run_ends, values_indexes)
 }
 
-fn build_runs_with_nulls<T: PartialEq>(
-    len: usize,
-    has_nulls: bool,
-    mut is_valid: impl FnMut(usize) -> bool,
-    mut value_at: impl FnMut(usize) -> T,
-) -> (Vec<usize>, Vec<usize>) {
-    build_runs(len, |lhs, rhs| {
-        if has_nulls {
-            let lhs_valid = is_valid(lhs);
-            let rhs_valid = is_valid(rhs);
-            if lhs_valid && rhs_valid {
-                value_at(lhs) == value_at(rhs)
-            } else {
-                lhs_valid == rhs_valid
-            }
-        } else {
-            value_at(lhs) == value_at(rhs)
-        }
-    })
-}
-
 fn runs_generic(array: &ArrayRef) -> (Vec<usize>, Vec<usize>) {
     let mut run_ends = Vec::new();
     let mut values_indexes = vec![0usize];