Merge

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

bench-vortex/src/realnest/gharchive.rs

@@ -230,6 +230,10 @@ impl Benchmark for GithubArchive {
     fn data_url(&self) -> &Url {
         &self.data_url
     }
+
+    fn expected_row_counts(&self) -> Option<&[usize]> {
+        Some(&[1, 2, 100, 10, 82468])
+    }
 }
 
 pub async fn register_table(

encodings/alp/src/alp/mod.rs

@@ -193,7 +193,7 @@ pub trait ALPFloat: private::Sealed + Float + Display + NativePType {
     }
 
     fn decode_buffer(encoded: BufferMut<Self::ALPInt>, exponents: Exponents) -> BufferMut<Self> {
-        encoded.map_each(move |encoded| Self::decode_single(encoded, exponents))
+        encoded.map_each_in_place(move |encoded| Self::decode_single(encoded, exponents))
     }
 
     #[inline(always)]

encodings/alp/src/alp_rd/mod.rs

@@ -311,7 +311,7 @@ pub fn alp_rd_decode<T: ALPRDFloat>(
     // Shift the left-parts and add in the right-parts.
     let mut index = 0;
     right_parts
-        .map_each(|right| {
+        .map_each_in_place(|right| {
             let left = values[index];
             index += 1;
             let left = <T as ALPRDFloat>::from_u16(left);

encodings/datetime-parts/src/canonical.rs

@@ -53,7 +53,7 @@ pub fn decode_to_temporal(array: &DateTimePartsArray) -> TemporalArray {
     // are constant.
     let mut values: BufferMut<i64> = days_buf
         .into_buffer_mut::<i64>()
-        .map_each(|d| d * 86_400 * divisor);
+        .map_each_in_place(|d| d * 86_400 * divisor);
 
     if let Some(seconds) = array.seconds().as_constant() {
         let seconds = seconds

encodings/fastlanes/src/bitpacking/compute/cast.rs

@@ -79,7 +79,7 @@ mod tests {
 
         let decoded = casted.to_primitive();
         assert_arrays_eq!(
-            decoded,
+            decoded.as_ref(),
             PrimitiveArray::from_iter([10u32, 20, 30, 40, 50, 60])
         );
     }

encodings/fastlanes/src/for/compress.rs

@@ -151,7 +151,9 @@ fn decompress_primitive<T: NativePType + WrappingAdd + PrimInt>(
     values: BufferMut<T>,
     min: T,
 ) -> Buffer<T> {
-    values.map_each(move |v| v.wrapping_add(&min)).freeze()
+    values
+        .map_each_in_place(move |v| v.wrapping_add(&min))
+        .freeze()
 }
 
 #[cfg(test)]

encodings/fastlanes/src/rle/compress.rs

@@ -285,15 +285,13 @@ mod test {
     fn test_partial_last_chunk() {
         // Test array with partial last chunk (not divisible by 1024)
         let values: Buffer<u32> = (0..1500).map(|i| (i / 100) as u32).collect();
-        let expected: Vec<u32> = (0..1500).map(|i| (i / 100) as u32).collect();
         let array = values.into_array();
 
         let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
         let decoded = encoded.to_primitive();
 
         assert_eq!(encoded.len(), 1500);
-        let expected_array = PrimitiveArray::from_iter(expected);
-        assert_arrays_eq!(decoded, expected_array);
+        assert_arrays_eq!(decoded, array);
         // 2 chunks: 1024 + 476 elements
         assert_eq!(encoded.values_idx_offsets().len(), 2);
     }
@@ -302,15 +300,13 @@ mod test {
     fn test_two_full_chunks() {
         // Array that spans exactly 2 chunks (2048 elements)
         let values: Buffer<u32> = (0..2048).map(|i| (i / 100) as u32).collect();
-        let expected: Vec<u32> = (0..2048).map(|i| (i / 100) as u32).collect();
         let array = values.into_array();
 
         let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
         let decoded = encoded.to_primitive();
 
         assert_eq!(encoded.len(), 2048);
-        let expected_array = PrimitiveArray::from_iter(expected);
-        assert_arrays_eq!(decoded, expected_array);
+        assert_arrays_eq!(decoded, array);
         assert_eq!(encoded.values_idx_offsets().len(), 2);
     }
 

encodings/zigzag/src/compress.rs

@@ -33,7 +33,10 @@ fn zigzag_encode_primitive<T: ExternalZigZag + NativePType>(
 where
     <T as ExternalZigZag>::UInt: NativePType,
 {
-    PrimitiveArray::new(values.map_each(|v| T::encode(v)).freeze(), validity)
+    PrimitiveArray::new(
+        values.map_each_in_place(|v| T::encode(v)).freeze(),
+        validity,
+    )
 }
 
 pub fn zigzag_decode(parray: PrimitiveArray) -> PrimitiveArray {
@@ -57,7 +60,10 @@ fn zigzag_decode_primitive<T: ExternalZigZag + NativePType>(
 where
     <T as ExternalZigZag>::UInt: NativePType,
 {
-    PrimitiveArray::new(values.map_each(|v| T::decode(v)).freeze(), validity)
+    PrimitiveArray::new(
+        values.map_each_in_place(|v| T::decode(v)).freeze(),
+        validity,
+    )
 }
 
 #[cfg(test)]

vortex-array/src/arrays/bool/vtable/operator.rs

@@ -27,7 +27,7 @@ impl OperatorVTable<BoolVTable> for BoolVTable {
             // Note that validity already has the mask applied so we only need to apply it to bits.
             let bits = bits.filter(&mask);
 
-            Ok(BoolVector::new(bits, validity).into())
+            Ok(BoolVector::try_new(bits, validity)?.into())
         }))
     }
 }

vortex-array/src/arrays/primitive/array/mod.rs

@@ -192,7 +192,7 @@ impl PrimitiveArray {
     {
         let validity = self.validity().clone();
         let buffer = match self.try_into_buffer_mut() {
-            Ok(buffer_mut) => buffer_mut.map_each(f),
+            Ok(buffer_mut) => buffer_mut.map_each_in_place(f),
             Err(parray) => BufferMut::<R>::from_iter(parray.buffer::<T>().iter().copied().map(f)),
         };
         PrimitiveArray::new(buffer.freeze(), validity)