replace &PrimitiveArray with ArrayView in a bunch of places

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

encodings/alp/benches/alp_compress.rs

@@ -68,7 +68,7 @@ fn compress_alp<T: ALPFloat + NativePType>(bencher: Bencher, args: (usize, f64,
 
     bencher
         .with_inputs(|| &array)
-        .bench_values(|array| alp_encode(array, None).unwrap())
+        .bench_values(|array| alp_encode(array.as_view(), None).unwrap())
 }
 
 #[divan::bench(types = [f32, f64], args = BENCH_ARGS)]
@@ -93,7 +93,7 @@ fn decompress_alp<T: ALPFloat + NativePType>(bencher: Bencher, args: (usize, f64
         .with_inputs(|| {
             (
                 alp_encode(
-                    &PrimitiveArray::new(Buffer::copy_from(&values), validity.clone()),
+                    PrimitiveArray::new(Buffer::copy_from(&values), validity.clone()).as_view(),
                     None,
                 )
                 .unwrap(),
@@ -136,15 +136,15 @@ fn compress_rd<T: ALPRDFloat + NativePType>(bencher: Bencher, args: (usize, f64)
 
     bencher
         .with_inputs(|| (&primitive, &encoder))
-        .bench_refs(|(primitive, encoder)| encoder.encode(primitive))
+        .bench_refs(|(primitive, encoder)| encoder.encode(primitive.as_view()))
 }
 
 #[divan::bench(types = [f32, f64], args = RD_BENCH_ARGS)]
 fn decompress_rd<T: ALPRDFloat + NativePType>(bencher: Bencher, args: (usize, f64)) {
     let (n, fraction_patch) = args;
     let primitive = make_rd_array::<T>(n, fraction_patch);
     let encoder = RDEncoder::new(primitive.as_slice::<T>());
-    let encoded = encoder.encode(&primitive);
+    let encoded = encoder.encode(primitive.as_view());
 
     bencher
         .with_inputs(|| &encoded)

encodings/alp/public-api.lock

@@ -386,7 +386,7 @@ pub struct vortex_alp::RDEncoder
 
 impl vortex_alp::RDEncoder
 
-pub fn vortex_alp::RDEncoder::encode(&self, array: &vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_alp::ALPRDArray
+pub fn vortex_alp::RDEncoder::encode(&self, array: vortex_array::array::view::ArrayView<'_, vortex_array::arrays::primitive::vtable::Primitive>) -> vortex_alp::ALPRDArray
 
 pub fn vortex_alp::RDEncoder::from_parts(right_bit_width: u8, codes: alloc::vec::Vec<u16>) -> Self
 
@@ -642,7 +642,7 @@ pub fn f64::to_bits(value: Self) -> Self::UINT
 
 pub fn f64::to_u16(bits: Self::UINT) -> u16
 
-pub fn vortex_alp::alp_encode(parray: &vortex_array::arrays::primitive::vtable::PrimitiveArray, exponents: core::option::Option<vortex_alp::Exponents>) -> vortex_error::VortexResult<vortex_alp::ALPArray>
+pub fn vortex_alp::alp_encode(parray: vortex_array::array::view::ArrayView<'_, vortex_array::arrays::primitive::vtable::Primitive>, exponents: core::option::Option<vortex_alp::Exponents>) -> vortex_error::VortexResult<vortex_alp::ALPArray>
 
 pub fn vortex_alp::alp_rd_decode<T: vortex_alp::ALPRDFloat>(left_parts: vortex_buffer::buffer_mut::BufferMut<u16>, left_parts_dict: &[u16], right_bit_width: u8, right_parts: vortex_buffer::buffer_mut::BufferMut<<T as vortex_alp::ALPRDFloat>::UINT>, left_parts_patches: core::option::Option<vortex_array::patches::Patches>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_buffer::buffer::Buffer<T>>
 

encodings/alp/src/alp/array.rs

@@ -555,7 +555,7 @@ mod tests {
     #[case(2049)]
     fn test_execute_f32(#[case] size: usize) {
         let values = PrimitiveArray::from_iter((0..size).map(|i| i as f32));
-        let encoded = alp_encode(&values, None).unwrap();
+        let encoded = alp_encode(values.as_view(), None).unwrap();
 
         let result_canonical = {
             let mut ctx = SESSION.create_execution_ctx();
@@ -584,7 +584,7 @@ mod tests {
     #[case(2049)]
     fn test_execute_f64(#[case] size: usize) {
         let values = PrimitiveArray::from_iter((0..size).map(|i| i as f64));
-        let encoded = alp_encode(&values, None).unwrap();
+        let encoded = alp_encode(values.as_view(), None).unwrap();
 
         let result_canonical = {
             let mut ctx = SESSION.create_execution_ctx();
@@ -618,7 +618,7 @@ mod tests {
             .collect();
 
         let array = PrimitiveArray::from_iter(values);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         assert!(encoded.patches().unwrap().array_len() > 0);
 
         let result_canonical = {
@@ -652,7 +652,7 @@ mod tests {
             .collect();
 
         let array = PrimitiveArray::from_option_iter(values);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
 
         let result_canonical = {
             let mut ctx = SESSION.create_execution_ctx();
@@ -687,7 +687,7 @@ mod tests {
             .collect();
 
         let array = PrimitiveArray::from_option_iter(values);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         assert!(encoded.patches().unwrap().array_len() > 0);
 
         let result_canonical = {
@@ -723,7 +723,7 @@ mod tests {
             .collect();
 
         let array = PrimitiveArray::from_option_iter(values.clone());
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
 
         let slice_end = size - slice_start;
         let slice_len = slice_end - slice_start;
@@ -774,7 +774,7 @@ mod tests {
             .collect();
 
         let array = PrimitiveArray::from_option_iter(values.clone());
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
 
         let slice_end = size - slice_start;
         let slice_len = slice_end - slice_start;
@@ -815,7 +815,7 @@ mod tests {
         let original = PrimitiveArray::from_iter(values);
 
         // First encode normally to get a properly formed ALPArray with patches.
-        let normally_encoded = alp_encode(&original, None).unwrap();
+        let normally_encoded = alp_encode(original.as_view(), None).unwrap();
         assert!(
             normally_encoded.patches().is_some(),
             "Test requires patches to be present"

encodings/alp/src/alp/compress.rs

@@ -3,7 +3,9 @@
 
 use itertools::Itertools;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
+use vortex_array::arrays::Primitive;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::PType;
 use vortex_array::patches::Patches;
@@ -39,7 +41,10 @@ macro_rules! match_each_alp_float_ptype {
     }};
 }
 
-pub fn alp_encode(parray: &PrimitiveArray, exponents: Option<Exponents>) -> VortexResult<ALPArray> {
+pub fn alp_encode(
+    parray: ArrayView<'_, Primitive>,
+    exponents: Option<Exponents>,
+) -> VortexResult<ALPArray> {
     let (exponents, encoded, patches) = match parray.ptype() {
         PType::F32 => alp_encode_components_typed::<f32>(parray, exponents)?,
         PType::F64 => alp_encode_components_typed::<f64>(parray, exponents)?,
@@ -55,7 +60,7 @@ pub fn alp_encode(parray: &PrimitiveArray, exponents: Option<Exponents>) -> Vort
     reason = "u64 index cast to usize is safe for reasonable array sizes"
 )]
 fn alp_encode_components_typed<T>(
-    values: &PrimitiveArray,
+    values: ArrayView<'_, Primitive>,
     exponents: Option<Exponents>,
 ) -> VortexResult<(Exponents, ArrayRef, Option<Patches>)>
 where
@@ -68,7 +73,7 @@ where
 
     let encoded_array = PrimitiveArray::new(encoded, values.validity()?).into_array();
 
-    let validity = values.validity_mask()?;
+    let validity = values.array().validity_mask()?;
     // exceptional_positions may contain exceptions at invalid positions (which contain garbage
     // data). We remove null exceptions in order to keep the Patches small.
     let (valid_exceptional_positions, valid_exceptional_values): (Buffer<u64>, Buffer<T>) =
@@ -141,7 +146,7 @@ mod tests {
     #[test]
     fn test_compress() {
         let array = PrimitiveArray::new(buffer![1.234f32; 1025], Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         assert!(encoded.patches().is_none());
         let expected_encoded = PrimitiveArray::from_iter(vec![1234i32; 1025]);
         assert_arrays_eq!(encoded.encoded(), expected_encoded);
@@ -155,7 +160,7 @@ mod tests {
     #[test]
     fn test_nullable_compress() {
         let array = PrimitiveArray::from_option_iter([None, Some(1.234f32), None]);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         assert!(encoded.patches().is_none());
         let expected_encoded = PrimitiveArray::from_option_iter([None, Some(1234i32), None]);
         assert_arrays_eq!(encoded.encoded(), expected_encoded);
@@ -172,7 +177,7 @@ mod tests {
     fn test_patched_compress() {
         let values = buffer![1.234f64, 2.718, PI, 4.0];
         let array = PrimitiveArray::new(values.clone(), Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         assert!(encoded.patches().is_some());
         let expected_encoded = PrimitiveArray::from_iter(vec![1234i64, 2718, 1234, 4000]);
         assert_arrays_eq!(encoded.encoded(), expected_encoded);
@@ -189,7 +194,7 @@ mod tests {
     fn test_compress_ignores_invalid_exceptional_values() {
         let values = buffer![1.234f64, 2.718, PI, 4.0];
         let array = PrimitiveArray::new(values, Validity::from_iter([true, true, false, true]));
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         assert!(encoded.patches().is_none());
         let expected_encoded =
             PrimitiveArray::from_option_iter(buffer![Some(1234i64), Some(2718), None, Some(4000)]);
@@ -211,7 +216,7 @@ mod tests {
             Some(4.0),
             None,
         ]);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         assert!(encoded.patches().is_some());
 
         assert_eq!(encoded.exponents(), Exponents { e: 16, f: 13 });
@@ -225,15 +230,15 @@ mod tests {
     #[test]
     fn roundtrips_close_fractional() {
         let original = PrimitiveArray::from_iter([195.26274f32, 195.27837, -48.815685]);
-        let alp_arr = alp_encode(&original, None).unwrap();
+        let alp_arr = alp_encode(original.as_view(), None).unwrap();
         assert_arrays_eq!(alp_arr, original);
     }
 
     #[test]
     fn roundtrips_all_null() {
         let original =
             PrimitiveArray::new(buffer![195.26274f64, PI, -48.815685], Validity::AllInvalid);
-        let alp_arr = alp_encode(&original, None).unwrap();
+        let alp_arr = alp_encode(original.as_view(), None).unwrap();
         let decompressed = alp_arr.into_array().to_primitive();
 
         assert_eq!(
@@ -251,7 +256,7 @@ mod tests {
             buffer![0.0f32, -0.0, f32::NAN, f32::NEG_INFINITY, f32::INFINITY],
             Validity::NonNullable,
         );
-        let encoded = alp_encode(&original, None).unwrap();
+        let encoded = alp_encode(original.as_view(), None).unwrap();
         let decoded = encoded.as_array().to_primitive();
         for idx in 0..original.len() {
             let decoded_val = decoded.as_slice::<f32>()[idx];
@@ -272,7 +277,7 @@ mod tests {
         values[1025] = PI;
 
         let array = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         let patches = encoded.patches().unwrap();
 
         let chunk_offsets = patches.chunk_offsets().clone().unwrap().to_primitive();
@@ -295,7 +300,7 @@ mod tests {
         values[2048] = E;
 
         let array = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         let patches = encoded.patches().unwrap();
 
         let chunk_offsets = patches.chunk_offsets().clone().unwrap().to_primitive();
@@ -317,7 +322,7 @@ mod tests {
         values[0] = PI;
 
         let array = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         let patches = encoded.patches().unwrap();
 
         let chunk_offsets = patches.chunk_offsets().clone().unwrap().to_primitive();
@@ -340,7 +345,7 @@ mod tests {
         values[100] = E;
 
         let array = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         let patches = encoded.patches().unwrap();
 
         let chunk_offsets = patches.chunk_offsets().clone().unwrap().to_primitive();
@@ -361,7 +366,7 @@ mod tests {
         // Create 1024 elements, encode, slice to first 512, then decode
         let values = vec![1.234f32; 1024];
         let original = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&original, None).unwrap();
+        let encoded = alp_encode(original.as_view(), None).unwrap();
 
         let sliced_alp = encoded.slice(512..1024).unwrap();
 
@@ -373,7 +378,7 @@ mod tests {
     fn test_slice_half_chunk_f64_roundtrip() {
         let values = vec![5.678f64; 1024];
         let original = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&original, None).unwrap();
+        let encoded = alp_encode(original.as_view(), None).unwrap();
 
         let sliced_alp = encoded.slice(512..1024).unwrap();
 
@@ -389,7 +394,7 @@ mod tests {
         values[600] = 42.42;
 
         let original = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&original, None).unwrap();
+        let encoded = alp_encode(original.as_view(), None).unwrap();
 
         let sliced_alp = encoded.slice(512..1024).unwrap();
 
@@ -409,7 +414,7 @@ mod tests {
         values[1023] = 42.42;
 
         let original = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&original, None).unwrap();
+        let encoded = alp_encode(original.as_view(), None).unwrap();
 
         let sliced_alp = encoded.slice(1023..1025).unwrap();
 
@@ -425,7 +430,7 @@ mod tests {
             .collect::<Vec<_>>();
 
         let original = PrimitiveArray::from_option_iter(values);
-        let encoded = alp_encode(&original, None).unwrap();
+        let encoded = alp_encode(original.as_view(), None).unwrap();
 
         let sliced_alp = encoded.slice(512..1024).unwrap();
         let decoded = sliced_alp.to_primitive();
@@ -438,7 +443,7 @@ mod tests {
     fn test_large_f32_array_uniform_values() {
         let size = 10_000;
         let array = PrimitiveArray::new(buffer![42.125f32; size], Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
 
         assert!(encoded.patches().is_none());
         let decoded =
@@ -450,7 +455,7 @@ mod tests {
     fn test_large_f64_array_uniform_values() {
         let size = 50_000;
         let array = PrimitiveArray::new(buffer![123.456789f64; size], Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
 
         assert!(encoded.patches().is_none());
         let decoded =
@@ -468,7 +473,7 @@ mod tests {
         values[4500] = f32::INFINITY;
 
         let array = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
 
         assert!(encoded.patches().is_some());
         let decoded =
@@ -490,7 +495,7 @@ mod tests {
         values[7000] = 999.999999999;
 
         let array = PrimitiveArray::new(Buffer::from(values.clone()), Validity::NonNullable);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
 
         assert!(encoded.patches().is_some());
         let decoded =
@@ -520,7 +525,7 @@ mod tests {
             .collect();
 
         let array = PrimitiveArray::from_option_iter(values);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         let decoded =
             decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
@@ -541,7 +546,7 @@ mod tests {
         let validity = Validity::from_iter((0..size).map(|i| !matches!(i, 500 | 2500)));
 
         let array = PrimitiveArray::new(Buffer::from(values), validity);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         let decoded =
             decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
@@ -572,7 +577,7 @@ mod tests {
         values[2900] = PI;
 
         let original = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
-        let encoded = alp_encode(&original, None).unwrap();
+        let encoded = alp_encode(original.as_view(), None).unwrap();
         assert!(encoded.patches().is_some());
 
         // Slice ending mid-chunk-2 (element 2500 is inside chunk 2 = 2048..3072).

encodings/alp/src/alp/compute/between.rs

@@ -123,7 +123,7 @@ mod tests {
     fn comparison_range() {
         let value = 0.0605_f32;
         let array = PrimitiveArray::from_iter([value; 1]);
-        let encoded = alp_encode(&array, None).unwrap();
+        let encoded = alp_encode(array.as_view(), None).unwrap();
         assert!(encoded.patches().is_none());
 
         assert_between(