save

Signed-off-by: Andrew Duffy <andrew@a10y.dev>

Author: a10y

encodings/fastlanes/src/bitpacking/vtable/mod.rs

@@ -297,8 +297,10 @@ impl VTable for BitPacked {
         })
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
-        Ok(ExecutionResult::done(unpack_array(array)?.into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            unpack_array(array.as_ref())?.into_array(),
+        ))
     }
 
     fn execute_parent(

encodings/fastlanes/src/delta/array/delta_compress.rs

@@ -106,7 +106,7 @@ mod tests {
     use vortex_session::VortexSession;
 
     use crate::DeltaArray;
-    use crate::bitpack_compress::bitpack_encode;
+    use crate::bitpack_compress::BitPackedEncoder;
     use crate::delta::array::delta_decompress::delta_decompress;
     use crate::delta_compress;
 
@@ -137,14 +137,14 @@ mod tests {
             (0u8..200).map(|i| (!(50..100).contains(&i)).then_some(i)),
         );
         let (bases, deltas) = delta_compress(&array, &mut SESSION.create_execution_ctx()).unwrap();
-        let bitpacked_deltas = bitpack_encode(&deltas, 1, None).unwrap();
-        let packed_delta = DeltaArray::try_new(
-            bases.into_array(),
-            bitpacked_deltas.into_array(),
-            0,
-            array.len(),
-        )
-        .unwrap();
+        let bitpacked_deltas = BitPackedEncoder::new(&deltas)
+            .with_bit_width(1)
+            .pack()
+            .unwrap()
+            .into_array()
+            .unwrap();
+        let packed_delta =
+            DeltaArray::try_new(bases.into_array(), bitpacked_deltas, 0, array.len()).unwrap();
         assert_arrays_eq!(packed_delta.to_primitive(), array);
     }
 }

vortex-array/src/arrays/lazy_patched/vtable/operations.rs

@@ -4,13 +4,18 @@
 use vortex_error::VortexResult;
 
 use crate::DynArray;
+use crate::ExecutionCtx;
 use crate::arrays::lazy_patched::LazyPatched;
 use crate::arrays::lazy_patched::LazyPatchedArray;
 use crate::scalar::Scalar;
 use crate::vtable::OperationsVTable;
 
 impl OperationsVTable<LazyPatched> for LazyPatched {
-    fn scalar_at(array: &LazyPatchedArray, index: usize) -> VortexResult<Scalar> {
+    fn scalar_at(
+        array: &LazyPatchedArray,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(if let Some(scalar) = array.patches.get_patched(index)? {
             scalar
         } else {

vortex-array/src/arrays/patched/array.rs

@@ -26,6 +26,19 @@ use crate::patches::Patches;
 use crate::stats::ArrayStats;
 use crate::validity::Validity;
 
+/// Shredded components of the [`PatchedArray`].
+///
+/// This is created when you consume the arrary using [`PatchedArray::into_parts`].
+pub struct PatchedArrayParts {
+    pub inner: ArrayRef,
+    pub n_chunks: usize,
+    pub n_lanes: usize,
+    pub offset: usize,
+    pub lane_offsets: BufferHandle,
+    pub indices: BufferHandle,
+    pub values: ArrayRef,
+}
+
 /// An array that partially "patches" another array with new values.
 #[derive(Debug, Clone)]
 pub struct PatchedArray {

vortex-array/src/vtable/dyn_.rs

@@ -19,7 +19,6 @@ use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::executor::ExecutionCtx;
 use crate::serde::ArrayChildren;
-use crate::stats::ArrayStats;
 use crate::vtable::Array;
 use crate::vtable::VTable;
 

vortex-cuda/benches/dynamic_dispatch_cuda.rs

@@ -17,19 +17,10 @@ use cudarc::driver::LaunchConfig;
 use cudarc::driver::PushKernelArg;
 use cudarc::driver::sys::CUevent_flags;
 use vortex::array::IntoArray;
-use vortex::array::ToCanonical;
-use vortex::array::arrays::DictArray;
 use vortex::array::arrays::PrimitiveArray;
-use vortex::array::scalar::Scalar;
 use vortex::array::validity::Validity::NonNullable;
 use vortex::buffer::Buffer;
 use vortex::dtype::PType;
-use vortex::encodings::alp::ALPArray;
-use vortex::encodings::alp::ALPFloat;
-use vortex::encodings::alp::Exponents;
-use vortex::encodings::alp::alp_encode;
-use vortex::encodings::fastlanes::BitPackedArray;
-use vortex::encodings::fastlanes::FoRArray;
 use vortex::encodings::runend::RunEndArray;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;