fix: avoid panic in RunEndBuffer::sliced_values for empty run arrays

arrow-array/src/array/run_array.rs

@@ -642,6 +642,7 @@ mod tests {
     use super::*;
     use crate::builder::PrimitiveRunBuilder;
     use crate::cast::AsArray;
+    use crate::new_empty_array;
     use crate::types::{Int8Type, UInt32Type};
     use crate::{Int16Array, Int32Array, StringArray};
 
@@ -739,6 +740,26 @@ mod tests {
         assert_eq!(run_ends.values(), &run_ends_values);
     }
 
+    #[test]
+    fn test_run_array_empty() {
+        let runs = new_empty_array(&DataType::Int16);
+        let runs = runs.as_primitive::<Int16Type>();
+        let values = new_empty_array(&DataType::Int64);
+        let array = RunArray::try_new(runs, &values).unwrap();
+
+        fn assertions(array: &RunArray<Int16Type>) {
+            assert!(array.is_empty());
+            assert_eq!(array.get_start_physical_index(), 0);
+            assert_eq!(array.get_end_physical_index(), 0);
+            assert!(array.get_physical_indices::<i16>(&[]).unwrap().is_empty());
+            assert!(array.run_ends().is_empty());
+            assert_eq!(array.run_ends().sliced_values().count(), 0);
+        }
+
+        assertions(&array);
+        assertions(&array.slice(0, 0));
+    }
+
     #[test]
     fn test_run_array_fmt_debug() {
         let mut builder = PrimitiveRunBuilder::<Int16Type, UInt32Type>::with_capacity(3);

arrow-buffer/src/buffer/run.rs

@@ -199,9 +199,18 @@ where
     pub fn sliced_values(&self) -> impl Iterator<Item = E> + '_ {
         let offset = self.logical_offset;
         let len = self.logical_length;
-        let start = self.get_start_physical_index();
-        let end = self.get_end_physical_index();
-        self.run_ends[start..=end].iter().map(move |&val| {
+
+        // Doing this roundabout way since the iterator type we return must be
+        // the same (i.e. cannot use std::iter::empty())
+        let range = if self.is_empty() {
+            0..0
+        } else {
+            let start = self.get_start_physical_index();
+            let end = self.get_end_physical_index() + 1;
+            start..end
+        };
+
+        self.run_ends[range].iter().map(move |&val| {
             let val = val.as_usize().saturating_sub(offset).min(len);
             E::from_usize(val).unwrap()
         })