fixes

Signed-off-by: Robert Kruszewski <github@robertk.io>

Author: robert3005

encodings/runend/src/arbitrary.rs

@@ -4,6 +4,7 @@
 use arbitrary::Arbitrary;
 use arbitrary::Result;
 use arbitrary::Unstructured;
+use arbitrary::unstructured::Int;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
@@ -13,6 +14,7 @@ use vortex_array::arrays::arbitrary::ArbitraryWith;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
+use vortex_array::dtype::UnsignedPType;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
@@ -91,64 +93,72 @@ fn random_strictly_sorted_ends(
     target_len: usize,
 ) -> Result<ArrayRef> {
     // Choose a random unsigned PType for ends
-    let ends_ptype = *u.choose(&[PType::U8, PType::U16, PType::U32, PType::U64])?;
+    let mut ends_ptypes = vec![PType::U8, PType::U16, PType::U32, PType::U64];
+    if target_len >= u8::MAX as usize {
+        ends_ptypes.remove(0);
+    }
+    if target_len >= u16::MAX as usize {
+        ends_ptypes.remove(0);
+    }
+    if target_len >= u32::MAX as usize {
+        ends_ptypes.remove(0);
+    }
+    let ends_ptype = *u.choose(&ends_ptypes)?;
+
+    match ends_ptype {
+        PType::U8 => random_strictly_sorted(
+            u,
+            num_runs,
+            u8::try_from(target_len).vortex_expect("must fit in u8"),
+        ),
+        PType::U16 => random_strictly_sorted(
+            u,
+            num_runs,
+            u16::try_from(target_len).vortex_expect("must fit in u16"),
+        ),
+        PType::U32 => random_strictly_sorted(
+            u,
+            num_runs,
+            u32::try_from(target_len).vortex_expect("must fit in u32"),
+        ),
+        PType::U64 => random_strictly_sorted(
+            u,
+            num_runs,
+            u64::try_from(target_len).vortex_expect("must fit in u64"),
+        ),
+        _ => unreachable!("Only unsigned integer types are valid for ends"),
+    }
+}
 
+fn random_strictly_sorted<T: UnsignedPType + Int>(
+    u: &mut Unstructured,
+    num_runs: usize,
+    target: T,
+) -> Result<ArrayRef> {
     // Generate strictly increasing values
     // Start from 0, increment by at least 1 each time
-    let mut ends: Vec<u64> = Vec::with_capacity(num_runs);
-    let mut current: u64 = 0;
+    let mut ends: Vec<T> = Vec::with_capacity(num_runs);
+    let mut current = T::zero();
 
     for i in 0..num_runs {
         // Each run must have at least length 1, so increment by at least 1
         let increment = match i == num_runs - 1 {
             true => {
                 // Last element should reach target_len
-                let target = target_len as u64;
                 if target > current {
                     target - current
                 } else {
-                    1
+                    T::one()
                 }
             }
             false => {
                 // Random increment between 1 and 10
-                u.int_in_range(1..=10)?
+                u.int_in_range(T::one()..=T::from(10).vortex_expect("10 will fit in all T"))?
             }
         };
         current += increment;
         ends.push(current);
     }
 
-    // Convert to the chosen PType
-    // The values are bounded: max is num_runs (20) * max_increment (10) = 200
-    // This fits in all unsigned types
-    let ends_array = match ends_ptype {
-        PType::U8 => {
-            let ends_typed: Vec<u8> = ends
-                .iter()
-                .map(|&e| u8::try_from(e).vortex_expect("end value fits in u8"))
-                .collect();
-            PrimitiveArray::new(Buffer::copy_from(ends_typed), Validity::NonNullable).into_array()
-        }
-        PType::U16 => {
-            let ends_typed: Vec<u16> = ends
-                .iter()
-                .map(|&e| u16::try_from(e).vortex_expect("end value fits in u16"))
-                .collect();
-            PrimitiveArray::new(Buffer::copy_from(ends_typed), Validity::NonNullable).into_array()
-        }
-        PType::U32 => {
-            let ends_typed: Vec<u32> = ends
-                .iter()
-                .map(|&e| u32::try_from(e).vortex_expect("end value fits in u32"))
-                .collect();
-            PrimitiveArray::new(Buffer::copy_from(ends_typed), Validity::NonNullable).into_array()
-        }
-        PType::U64 => {
-            PrimitiveArray::new(Buffer::copy_from(ends), Validity::NonNullable).into_array()
-        }
-        _ => unreachable!("Only unsigned integer types are valid for ends"),
-    };
-
-    Ok(ends_array)
+    Ok(PrimitiveArray::new(Buffer::copy_from(ends), Validity::NonNullable).into_array())
 }

vortex-array/src/builders/list.rs

@@ -176,7 +176,7 @@ impl<O: IntegerPType> ListBuilder<O> {
     /// [`ListViewBuilder`](crate::builders::ListViewBuilder)), so it is never produced by
     /// [`builder_with_capacity`]. List encodings still dispatch into it via `match_each_list_builder`
     /// when a caller supplies one directly.
-    pub(crate) fn append_list_array(
+    pub fn append_list_array(
         &mut self,
         array: &ArrayRef,
         ctx: &mut ExecutionCtx,

vortex-array/src/builders/listview.rs

@@ -228,7 +228,7 @@ impl<O: IntegerPType, S: IntegerPType> ListViewBuilder<O, S> {
 
     /// Appends the values of a canonical [`ListViewArray`] to the builder, recursing into the
     /// elements builder.
-    pub(crate) fn append_listview_array(
+    pub fn append_listview_array(
         &mut self,
         array: &ListViewArray,
         ctx: &mut ExecutionCtx,