address comments

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

Author: a10y

encodings/fastlanes/src/bitpacking/plugin.rs

@@ -47,7 +47,7 @@ impl ArrayPlugin for BitPackedPatchedPlugin {
             .deserialize(dtype, len, metadata, buffers, children, session)?
             .try_downcast::<BitPacked>()
             .map_err(|_| {
-                vortex_err!("BitPacked plugin should only deserialize vortex.bitpacked")
+                vortex_err!("BitPacked plugin should only deserialize fastlanes.bitpacked")
             })?;
 
         // Create a new BitPackedArray without the interior patches installed.
@@ -74,3 +74,151 @@ impl ArrayPlugin for BitPackedPatchedPlugin {
         Ok(patched.into_array())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::sync::LazyLock;
+
+    use vortex_array::ArrayPlugin;
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::PatchedArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::patched::PatchedArrayExt;
+    use vortex_array::buffer::BufferHandle;
+    use vortex_array::session::ArraySession;
+    use vortex_array::session::ArraySessionExt;
+    use vortex_buffer::Buffer;
+    use vortex_error::VortexResult;
+    use vortex_error::vortex_err;
+    use vortex_session::VortexSession;
+
+    use super::BitPackedPatchedPlugin;
+    use crate::BitPacked;
+    use crate::BitPackedArray;
+    use crate::BitPackedArrayExt;
+    use crate::BitPackedData;
+
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+        let session = VortexSession::empty().with::<ArraySession>();
+        session.arrays().register(BitPackedPatchedPlugin);
+        session
+    });
+
+    #[test]
+    fn test_decode_bitpacked_patches() -> VortexResult<()> {
+        // Create values where some exceed the bit width, causing patches.
+        // With bit_width=9, max value is 511. Values >=512 become patches.
+        let values: Buffer<i32> = (0i32..=512).collect();
+        let parray = values.into_array();
+        let bitpacked = BitPackedData::encode(&parray, 9)?;
+
+        assert!(
+            bitpacked.patches().is_some(),
+            "Expected BitPacked array to have patches"
+        );
+
+        let array = bitpacked.as_array();
+
+        let metadata = array.metadata()?.unwrap_or_default();
+        let children = array.children();
+        let buffers = array
+            .buffers()
+            .into_iter()
+            .map(BufferHandle::new_host)
+            .collect::<Vec<_>>();
+
+        let deserialized = BitPackedPatchedPlugin.deserialize(
+            array.dtype(),
+            array.len(),
+            &metadata,
+            &buffers,
+            &children,
+            &SESSION     )?;
+
+        let patched: PatchedArray = deserialized
+            .try_downcast()
+            .map_err(|a| vortex_err!("Expected Patched, got {}", a.encoding_id()))?;
+
+        let inner_bitpacked: BitPackedArray = patched
+            .base_array()
+            .clone()
+            .try_downcast()
+            .map_err(|a| vortex_err!("Expected inner BitPacked, got {}", a.encoding_id()))?;
+
+        assert!(
+            inner_bitpacked.patches().is_none(),
+            "Inner BitPacked should NOT have patches"
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn bitpacked_without_patches_stays_bitpacked() -> VortexResult<()> {
+        // With bit_width=16, max value is 65535. All values 0..100 fit.
+        let values: Buffer<i32> = (0i32..100).collect();
+        let parray = values.into_array();
+        let bitpacked = BitPackedData::encode(&parray, 16)?;
+
+        assert!(
+            bitpacked.patches().is_none(),
+            "Expected BitPacked array without patches"
+        );
+
+        let array = bitpacked.as_array();
+
+        let metadata = array.metadata()?.unwrap_or_default();
+        let children = array.children();
+        let buffers = array
+            .buffers()
+            .into_iter()
+            .map(BufferHandle::new_host)
+            .collect::<Vec<_>>();
+
+        let deserialized = BitPackedPatchedPlugin.deserialize(
+            array.dtype(),
+            array.len(),
+            &metadata,
+            &buffers,
+            &children,
+            &SESSION,
+        )?;
+
+        let result = deserialized
+            .try_downcast::<BitPacked>()
+            .map_err(|a| vortex_err!("Expected deserialize BitPacked, got {}", a.encoding_id()))?;
+
+        assert!(result.patches().is_none(), "Result should not have patches");
+
+        Ok(())
+    }
+
+    #[test]
+    fn primitive_array_returns_error() -> VortexResult<()> {
+        let array = PrimitiveArray::from_iter([1i32, 2, 3]).into_array();
+
+        let metadata = array.metadata()?.unwrap_or_default();
+        let children = array.children();
+        let buffers = array
+            .buffers()
+            .into_iter()
+            .map(BufferHandle::new_host)
+            .collect::<Vec<_>>();
+
+        let result = BitPackedPatchedPlugin.deserialize(
+            array.dtype(),
+            array.len(),
+            &metadata,
+            &buffers,
+            &children,
+            &SESSION,
+        );
+
+        assert!(
+            result.is_err(),
+            "Expected error when deserializing PrimitiveArray with BitPackedPatchedPlugin"
+        );
+
+        Ok(())
+    }
+}

vortex-array/src/serde.rs

@@ -268,16 +268,16 @@ pub trait ArrayChildren {
     }
 }
 
-impl ArrayChildren for &[ArrayRef] {
+impl<T: AsRef<[ArrayRef]>> ArrayChildren for T {
     fn get(&self, index: usize, dtype: &DType, len: usize) -> VortexResult<ArrayRef> {
-        let array = self[index].clone();
+        let array = self.as_ref()[index].clone();
         assert_eq!(array.len(), len);
         assert_eq!(array.dtype(), dtype);
         Ok(array)
     }
 
     fn len(&self) -> usize {
-        <[_]>::len(self)
+        self.as_ref().len()
     }
 }
 

vortex-btrblocks/src/schemes/integer.rs

@@ -351,6 +351,7 @@ impl Scheme for BitPackingScheme {
                     &p,
                     &mut LEGACY_SESSION.create_execution_ctx(),
                 )?
+                .with_stats_set(packed_stats)
                 .into_array(),
             }
         } else {