Add Array::deserialize arguments

encodings/alp/src/alp/array.rs

@@ -36,6 +36,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
+use vortex_session::VortexSession;
 
 use crate::ALPFloat;
 use crate::alp::Exponents;
@@ -74,9 +75,14 @@ impl VTable for ALPVTable {
         Ok(Some(metadata.serialize()))
     }
 
-    fn deserialize(buffer: &[u8]) -> VortexResult<Self::Metadata> {
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
         Ok(ProstMetadata(
-            <ProstMetadata<ALPMetadata> as DeserializeMetadata>::deserialize(buffer)?,
+            <ProstMetadata<ALPMetadata> as DeserializeMetadata>::deserialize(bytes)?,
         ))
     }
 

encodings/alp/src/alp_rd/array.rs

@@ -42,6 +42,7 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_mask::Mask;
+use vortex_session::VortexSession;
 
 use crate::alp_rd::kernel::PARENT_KERNELS;
 use crate::alp_rd_decode;
@@ -100,9 +101,14 @@ impl VTable for ALPRDVTable {
         Ok(Some(metadata.serialize()))
     }
 
-    fn deserialize(buffer: &[u8]) -> VortexResult<Self::Metadata> {
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
         Ok(ProstMetadata(
-            <ProstMetadata<ALPRDMetadata> as DeserializeMetadata>::deserialize(buffer)?,
+            <ProstMetadata<ALPRDMetadata> as DeserializeMetadata>::deserialize(bytes)?,
         ))
     }
 

encodings/bytebool/Cargo.toml

@@ -24,6 +24,7 @@ vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
+vortex-session = { workspace = true }
 
 [dev-dependencies]
 rstest = { workspace = true }

encodings/bytebool/src/array.rs

@@ -36,6 +36,7 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
 use vortex_scalar::Scalar;
+use vortex_session::VortexSession;
 
 vtable!(ByteBool);
 
@@ -61,7 +62,12 @@ impl VTable for ByteBoolVTable {
         Ok(Some(vec![]))
     }
 
-    fn deserialize(_buffer: &[u8]) -> VortexResult<Self::Metadata> {
+    fn deserialize(
+        _bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
         Ok(EmptyMetadata)
     }
 

encodings/datetime-parts/Cargo.toml

@@ -25,9 +25,9 @@ vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
+vortex-session = { workspace = true }
 
 [dev-dependencies]
 rstest = { workspace = true }
 vortex-array = { workspace = true, features = ["_test-harness"] }
 vortex-error = { workspace = true }
-vortex-session = { workspace = true }

encodings/datetime-parts/src/array.rs

@@ -35,6 +35,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
+use vortex_session::VortexSession;
 
 use crate::canonical::decode_to_temporal;
 use crate::compute::rules::PARENT_RULES;
@@ -97,9 +98,14 @@ impl VTable for DateTimePartsVTable {
         Ok(Some(metadata.serialize()))
     }
 
-    fn deserialize(buffer: &[u8]) -> VortexResult<Self::Metadata> {
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
         Ok(ProstMetadata(
-            <ProstMetadata<DateTimePartsMetadata> as DeserializeMetadata>::deserialize(buffer)?,
+            <ProstMetadata<DateTimePartsMetadata> as DeserializeMetadata>::deserialize(bytes)?,
         ))
     }
 

encodings/decimal-byte-parts/Cargo.toml

@@ -25,6 +25,7 @@ vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
+vortex-session = { workspace = true }
 
 [dev-dependencies]
 rstest = { workspace = true }

encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs

@@ -44,6 +44,7 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_scalar::DecimalValue;
 use vortex_scalar::Scalar;
+use vortex_session::VortexSession;
 
 use crate::decimal_byte_parts::rules::PARENT_RULES;
 
@@ -82,8 +83,13 @@ impl VTable for DecimalBytePartsVTable {
         Ok(Some(metadata.serialize()))
     }
 
-    fn deserialize(buffer: &[u8]) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(DecimalBytesPartsMetadata::decode(buffer)?))
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
+        Ok(ProstMetadata(DecimalBytesPartsMetadata::decode(bytes)?))
     }
 
     fn build(

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

@@ -25,6 +25,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
+use vortex_session::VortexSession;
 
 use crate::BitPackedArray;
 use crate::bitpack_decompress::unpack_array;
@@ -146,8 +147,13 @@ impl VTable for BitPackedVTable {
         Ok(Some(metadata.serialize()))
     }
 
-    fn deserialize(buffer: &[u8]) -> VortexResult<Self::Metadata> {
-        let inner = <ProstMetadata<BitPackedMetadata> as DeserializeMetadata>::deserialize(buffer)?;
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
+        let inner = <ProstMetadata<BitPackedMetadata> as DeserializeMetadata>::deserialize(bytes)?;
         Ok(ProstMetadata(inner))
     }
 

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

@@ -19,6 +19,7 @@ use vortex_dtype::match_each_unsigned_integer_ptype;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
+use vortex_session::VortexSession;
 
 use crate::DeltaArray;
 use crate::delta::array::delta_decompress::delta_decompress;
@@ -91,8 +92,13 @@ impl VTable for DeltaVTable {
         Ok(Some(metadata.0.encode_to_vec()))
     }
 
-    fn deserialize(buffer: &[u8]) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(DeltaMetadata::decode(buffer)?))
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
+        Ok(ProstMetadata(DeltaMetadata::decode(bytes)?))
     }
 
     fn build(

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

@@ -21,6 +21,7 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_scalar::Scalar;
 use vortex_scalar::ScalarValue;
+use vortex_session::VortexSession;
 
 use crate::FoRArray;
 use crate::r#for::array::for_decompress::decompress;
@@ -74,8 +75,13 @@ impl VTable for FoRVTable {
         Ok(Some(metadata.serialize()))
     }
 
-    fn deserialize(buffer: &[u8]) -> VortexResult<Self::Metadata> {
-        ScalarValueMetadata::deserialize(buffer)
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
+        ScalarValueMetadata::deserialize(bytes)
     }
 
     fn build(

encodings/fastlanes/src/lib.rs

@@ -14,3 +14,24 @@ mod r#for;
 mod rle;
 
 pub(crate) const FL_CHUNK_SIZE: usize = 1024;
+
+#[cfg(test)]
+mod test {
+    use std::sync::LazyLock;
+
+    use vortex_array::session::ArraySessionExt;
+    use vortex_session::VortexSession;
+
+    use super::*;
+
+    pub static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+        let session = VortexSession::empty();
+        session
+            .arrays()
+            .register(BitPackedVTable::ID, BitPackedVTable);
+        session.arrays().register(DeltaVTable::ID, DeltaVTable);
+        session.arrays().register(FoRVTable::ID, FoRVTable);
+        session.arrays().register(RLEVTable::ID, RLEVTable);
+        session
+    });
+}

encodings/fastlanes/src/rle/array/mod.rs

@@ -223,7 +223,6 @@ mod tests {
     use vortex_array::assert_arrays_eq;
     use vortex_array::serde::ArrayParts;
     use vortex_array::serde::SerializeOptions;
-    use vortex_array::session::ArraySession;
     use vortex_array::validity::Validity;
     use vortex_buffer::Buffer;
     use vortex_buffer::ByteBufferMut;
@@ -232,7 +231,7 @@ mod tests {
     use vortex_dtype::PType;
 
     use crate::RLEArray;
-    use crate::RLEVTable;
+    use crate::test::SESSION;
 
     #[test]
     fn test_try_new() {
@@ -454,17 +453,13 @@ mod tests {
         }
         let concat = concat.freeze();
 
-        let registry = ArraySession::default()
-            .registry()
-            .clone()
-            .with(RLEVTable::ID, RLEVTable);
         let parts = ArrayParts::try_from(concat).unwrap();
         let decoded = parts
             .decode(
                 &DType::Primitive(PType::U32, Nullability::NonNullable),
                 2048,
                 &ctx,
-                &registry,
+                &SESSION,
             )
             .unwrap();
 
@@ -500,13 +495,9 @@ mod tests {
         }
         let concat = concat.freeze();
 
-        let registry = ArraySession::default()
-            .registry()
-            .clone()
-            .with(RLEVTable::ID, RLEVTable);
         let parts = ArrayParts::try_from(concat).unwrap();
         let decoded = parts
-            .decode(sliced.dtype(), sliced.len(), &ctx, &registry)
+            .decode(sliced.dtype(), sliced.len(), &ctx, &SESSION)
             .unwrap();
 
         let original_data = sliced.to_primitive();

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

@@ -17,6 +17,7 @@ use vortex_dtype::Nullability;
 use vortex_dtype::PType;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
+use vortex_session::VortexSession;
 
 use crate::RLEArray;
 use crate::rle::array::rle_decompress::rle_decompress;
@@ -93,8 +94,13 @@ impl VTable for RLEVTable {
         Ok(Some(metadata.0.encode_to_vec()))
     }
 
-    fn deserialize(buffer: &[u8]) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(RLEMetadata::decode(buffer)?))
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
+        Ok(ProstMetadata(RLEMetadata::decode(bytes)?))
     }
 
     fn build(

encodings/fsst/src/array.rs

@@ -49,6 +49,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
+use vortex_session::VortexSession;
 
 use crate::canonical::canonicalize_fsst;
 use crate::canonical::fsst_decode_views;
@@ -98,9 +99,14 @@ impl VTable for FSSTVTable {
         Ok(Some(metadata.serialize()))
     }
 
-    fn deserialize(buffer: &[u8]) -> VortexResult<Self::Metadata> {
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
         Ok(ProstMetadata(
-            <ProstMetadata<FSSTMetadata> as DeserializeMetadata>::deserialize(buffer)?,
+            <ProstMetadata<FSSTMetadata> as DeserializeMetadata>::deserialize(bytes)?,
         ))
     }