feldera · gz · Dec 23, 2025 · Jan 10, 2026 · Jan 10, 2026 · Jan 10, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -29,6 +29,7 @@ members = [
   "crates/rest-api",
   "crates/ir",
   "crates/fxp",
+  "crates/storage-test-compat",
 ]
 exclude = [
   "sql-to-dbsp-compiler/temp",

diff --git a/crates/dbsp/src/dynamic/pair.rs b/crates/dbsp/src/dynamic/pair.rs
@@ -1,14 +1,12 @@
 use std::mem::take;
 
 use crate::{
-    DBData, declare_trait_object_with_archived, derive_comparison_traits, dynamic::erase::Erase,
+    DBData, declare_trait_object,
+    dynamic::erase::Erase,
     utils::Tup2,
 };
 
-use super::{Data, DataTrait, DowncastTrait};
-use crate::utils::ArchivedTup2;
-
-use crate::dynamic::rkyv::{ArchivedDBData, DeserializeDyn, DeserializeImpl};
+use super::{Data, DataTrait};
 
 /// A dynamically typed interface to `Tup2`.
 pub trait Pair<T1: DataTrait + ?Sized, T2: DataTrait + ?Sized>: Data {
@@ -86,80 +84,8 @@ where
     }
 }
 
-pub trait ArchivedPair<T1: DataTrait + ?Sized, T2: DataTrait + ?Sized> {
-    fn fst(&self) -> &T1::Archived;
-    fn snd(&self) -> &T2::Archived;
-    fn split(&self) -> (&T1::Archived, &T2::Archived);
-}
-
-impl<T1, T2, Trait1, Trait2> ArchivedPair<Trait1, Trait2> for ArchivedTup2<T1, T2>
-where
-    T1: DBData + Erase<Trait1>,
-    T2: DBData + Erase<Trait2>,
-    Trait1: DataTrait + ?Sized,
-    Trait2: DataTrait + ?Sized,
-{
-    fn fst(&self) -> &Trait1::Archived {
-        <T1 as Erase<Trait1>>::erase_archived(&self.0)
-    }
-
-    fn snd(&self) -> &Trait2::Archived {
-        <T2 as Erase<Trait2>>::erase_archived(&self.1)
-    }
-
-    fn split(&self) -> (&Trait1::Archived, &Trait2::Archived) {
-        (
-            <T1 as Erase<Trait1>>::erase_archived(&self.0),
-            <T2 as Erase<Trait2>>::erase_archived(&self.1),
-        )
-    }
-}
-
-impl<T, Trait, Trait1, Trait2> ArchivedPair<Trait1, Trait2> for DeserializeImpl<T, Trait>
+declare_trait_object!(DynPair<T1, T2> = dyn Pair<T1, T2>
 where
-    T: ArchivedDBData + 'static,
-    T::Archived: ArchivedPair<Trait1, Trait2> + Ord + Eq,
-    Trait: Pair<Trait1, Trait2> + DowncastTrait + ?Sized + 'static,
-    Trait1: DataTrait + ?Sized,
-    Trait2: DataTrait + ?Sized,
-{
-    fn fst(&self) -> &Trait1::Archived {
-        self.archived.fst()
-    }
-
-    fn snd(&self) -> &Trait2::Archived {
-        self.archived.snd()
-    }
-
-    fn split(&self) -> (&Trait1::Archived, &Trait2::Archived) {
-        (self.archived.fst(), self.archived.snd())
-    }
-}
-
-pub trait ArchivedPairTrait<T1: DataTrait + ?Sized, T2: DataTrait + ?Sized>:
-    ArchivedPair<T1, T2> + DeserializeDyn<DynPair<T1, T2>>
-{
-}
-
-impl<Trait, T1, T2> ArchivedPairTrait<T1, T2> for Trait
-where
-    Trait: ArchivedPair<T1, T2> + DeserializeDyn<DynPair<T1, T2>> + ?Sized,
-    T1: DataTrait + ?Sized,
-    T2: DataTrait + ?Sized,
-{
-}
-
-type DynArchivedPair<Trait1, Trait2> = dyn ArchivedPairTrait<Trait1, Trait2>;
-
-derive_comparison_traits!(DynArchivedPair<Trait1, Trait2> where Trait1: DataTrait + ?Sized + 'static, Trait2: DataTrait + ?Sized + 'static);
-impl<Trait1: ?Sized + 'static, Trait2: ?Sized + 'static> DowncastTrait
-    for DynArchivedPair<Trait1, Trait2>
-{
-}
-
-declare_trait_object_with_archived!(DynPair<T1, T2> = dyn Pair<T1, T2>
-    { type Archived = dyn ArchivedPairTrait<T1, T2>}
-    where
     T1: DataTrait + ?Sized,
     T2: DataTrait + ?Sized,
 );
diff --git a/crates/dbsp/src/dynamic/rkyv.rs b/crates/dbsp/src/dynamic/rkyv.rs
@@ -3,10 +3,7 @@ use crate::{
     derive_comparison_traits,
     storage::file::{Deserializer, Serializer},
 };
-use rkyv::{
-    Archive, Archived, Deserialize, Fallible, Serialize, archived_value,
-    de::deserializers::SharedDeserializeMap,
-};
+use rkyv::{Archive, Archived, Deserialize, Fallible, Serialize, archived_value};
 use std::{cmp::Ordering, marker::PhantomData, mem::transmute};
 
 /// Trait for DBData that can be deserialized with [`rkyv`].
@@ -42,7 +39,24 @@ pub trait DeserializableDyn {
     ///
     /// The offset must store a valid serialized value of the
     /// concrete type that `self` points to.
-    unsafe fn deserialize_from_bytes(&mut self, bytes: &[u8], pos: usize);
+    unsafe fn deserialize_from_bytes_with(
+        &mut self,
+        bytes: &[u8],
+        pos: usize,
+        deserializer: &mut Deserializer,
+    );
+
+    /// Deserialize `self` from the given slice and offset using the default
+    /// deserializer configuration.
+    ///
+    /// # Safety
+    ///
+    /// The offset must store a valid serialized value of the
+    /// concrete type that `self` points to.
+    unsafe fn deserialize_from_bytes(&mut self, bytes: &[u8], pos: usize) {
+        let mut deserializer = Deserializer::default();
+        unsafe { self.deserialize_from_bytes_with(bytes, pos, &mut deserializer) };
+    }
 }
 
 impl<T> SerializeDyn for T
@@ -60,20 +74,28 @@ impl<T> DeserializableDyn for T
 where
     T: ArchivedDBData,
 {
-    unsafe fn deserialize_from_bytes(&mut self, bytes: &[u8], pos: usize) {
+    unsafe fn deserialize_from_bytes_with(
+        &mut self,
+        bytes: &[u8],
+        pos: usize,
+        deserializer: &mut Deserializer,
+    ) {
         unsafe {
             let archived: &<Self as Archive>::Archived = archived_value::<Self>(bytes, pos);
 
-            *self = archived
-                .deserialize(&mut SharedDeserializeMap::new())
-                .unwrap();
+            *self = archived.deserialize(deserializer).unwrap();
         }
     }
 }
 
 /// Object-safe version of the `Deserialize` trait.
 pub trait DeserializeDyn<Trait: ?Sized>: AsAny + Comparable {
-    fn deserialize(&self, target: &mut Trait);
+    fn deserialize_with(&self, target: &mut Trait, deserializer: &mut Deserializer);
+
+    fn deserialize(&self, target: &mut Trait) {
+        let mut deserializer = Deserializer::default();
+        self.deserialize_with(target, &mut deserializer);
+    }
 
     fn eq_target(&self, target: &Trait) -> bool;
     fn cmp_target(&self, target: &Trait) -> Option<Ordering>;
@@ -143,23 +165,25 @@ where
     T: ArchivedDBData + Eq + Ord + 'static,
     Trait: DowncastTrait + ?Sized + 'static,
 {
-    fn deserialize(&self, target: &mut Trait) {
+    fn deserialize_with(&self, target: &mut Trait, deserializer: &mut Deserializer) {
         *unsafe { target.downcast_mut::<T>() } = self
             .archived
-            .deserialize(&mut SharedDeserializeMap::new())
+            .deserialize(deserializer)
             .unwrap()
     }
 
     fn eq_target(&self, other: &Trait) -> bool {
+        let mut deserializer = Deserializer::default();
         self.archived
-            .deserialize(&mut SharedDeserializeMap::new())
+            .deserialize(&mut deserializer)
             .unwrap()
             .eq(unsafe { other.downcast::<T>() })
     }
 
     fn cmp_target(&self, other: &Trait) -> Option<Ordering> {
+        let mut deserializer = Deserializer::default();
         self.archived
-            .deserialize(&mut SharedDeserializeMap::new())
+            .deserialize(&mut deserializer)
             .unwrap()
             .partial_cmp(unsafe { other.downcast::<T>() })
     }

diff --git a/crates/dbsp/src/operator/group/custom_ord.rs b/crates/dbsp/src/operator/group/custom_ord.rs
@@ -1,6 +1,6 @@
-use crate::trace::Deserializable;
+use crate::trace::{Deserializable, Deserializer};
 use feldera_macros::IsNone;
-use rkyv::{Archive, Deserialize, Serialize, de::deserializers::SharedDeserializeMap};
+use rkyv::{Archive, Deserialize, Serialize};
 use size_of::SizeOf;
 use std::{
     cmp::Ordering,
@@ -162,11 +162,11 @@ where
         // the Archived (we already know that T::Archived implements Ord).
         let real_self: T = self
             .val
-            .deserialize(&mut SharedDeserializeMap::new())
+            .deserialize(&mut Deserializer::default())
             .unwrap();
         let real_other: T = other
             .val
-            .deserialize(&mut SharedDeserializeMap::new())
+            .deserialize(&mut Deserializer::default())
             .unwrap();
         F::cmp(&real_self, &real_other)
     }

diff --git a/crates/dbsp/src/storage/bin/bench.py b/crates/dbsp/src/storage/bin/bench.py