arrow-array: Implement PartialEq for RunArray (#7727)

# Which issue does this PR close?

Closes #7691

# Are there any user-facing changes?

No, just implementing for ease of use and consistency in tests and
elsewhere across the wider repository.

@alamb

Author: brancz

arrow-array/src/array/mod.rs

@@ -733,6 +733,12 @@ impl<T: ByteViewType + ?Sized> PartialEq for GenericByteViewArray<T> {
     }
 }
 
+impl<R: RunEndIndexType> PartialEq for RunArray<R> {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
 /// Constructs an array using the input `data`.
 /// Returns a reference-counted `Array` instance.
 pub fn make_array(data: ArrayData) -> ArrayRef {

arrow-array/src/array/run_array.rs

@@ -670,7 +670,7 @@ mod tests {
     use crate::builder::PrimitiveRunBuilder;
     use crate::cast::AsArray;
     use crate::types::{Int8Type, UInt32Type};
-    use crate::{Int32Array, StringArray};
+    use crate::{Int16Array, Int32Array, StringArray};
 
     fn build_input_array(size: usize) -> Vec<Option<i32>> {
         // The input array is created by shuffling and repeating
@@ -1104,4 +1104,69 @@ mod tests {
             assert_eq!(&n, &expected[offset..offset + length], "{offset} {length}");
         }
     }
+
+    #[test]
+    fn test_run_array_eq_identical() {
+        let run_ends1 = Int32Array::from(vec![2, 4, 6]);
+        let values1 = StringArray::from(vec!["a", "b", "c"]);
+        let array1 = RunArray::<Int32Type>::try_new(&run_ends1, &values1).unwrap();
+
+        let run_ends2 = Int32Array::from(vec![2, 4, 6]);
+        let values2 = StringArray::from(vec!["a", "b", "c"]);
+        let array2 = RunArray::<Int32Type>::try_new(&run_ends2, &values2).unwrap();
+
+        assert_eq!(array1, array2);
+    }
+
+    #[test]
+    fn test_run_array_ne_different_run_ends() {
+        let run_ends1 = Int32Array::from(vec![2, 4, 6]);
+        let values1 = StringArray::from(vec!["a", "b", "c"]);
+        let array1 = RunArray::<Int32Type>::try_new(&run_ends1, &values1).unwrap();
+
+        let run_ends2 = Int32Array::from(vec![1, 4, 6]);
+        let values2 = StringArray::from(vec!["a", "b", "c"]);
+        let array2 = RunArray::<Int32Type>::try_new(&run_ends2, &values2).unwrap();
+
+        assert_ne!(array1, array2);
+    }
+
+    #[test]
+    fn test_run_array_ne_different_values() {
+        let run_ends1 = Int32Array::from(vec![2, 4, 6]);
+        let values1 = StringArray::from(vec!["a", "b", "c"]);
+        let array1 = RunArray::<Int32Type>::try_new(&run_ends1, &values1).unwrap();
+
+        let run_ends2 = Int32Array::from(vec![2, 4, 6]);
+        let values2 = StringArray::from(vec!["a", "b", "d"]);
+        let array2 = RunArray::<Int32Type>::try_new(&run_ends2, &values2).unwrap();
+
+        assert_ne!(array1, array2);
+    }
+
+    #[test]
+    fn test_run_array_eq_with_nulls() {
+        let run_ends1 = Int32Array::from(vec![2, 4, 6]);
+        let values1 = StringArray::from(vec![Some("a"), None, Some("c")]);
+        let array1 = RunArray::<Int32Type>::try_new(&run_ends1, &values1).unwrap();
+
+        let run_ends2 = Int32Array::from(vec![2, 4, 6]);
+        let values2 = StringArray::from(vec![Some("a"), None, Some("c")]);
+        let array2 = RunArray::<Int32Type>::try_new(&run_ends2, &values2).unwrap();
+
+        assert_eq!(array1, array2);
+    }
+
+    #[test]
+    fn test_run_array_eq_different_run_end_types() {
+        let run_ends_i16_1 = Int16Array::from(vec![2_i16, 4, 6]);
+        let values_i16_1 = StringArray::from(vec!["a", "b", "c"]);
+        let array_i16_1 = RunArray::<Int16Type>::try_new(&run_ends_i16_1, &values_i16_1).unwrap();
+
+        let run_ends_i16_2 = Int16Array::from(vec![2_i16, 4, 6]);
+        let values_i16_2 = StringArray::from(vec!["a", "b", "c"]);
+        let array_i16_2 = RunArray::<Int16Type>::try_new(&run_ends_i16_2, &values_i16_2).unwrap();
+
+        assert_eq!(array_i16_1, array_i16_2);
+    }
 }