chore: remove get_many to reconsider the API

Author: prestwich

crates/hot-mdbx/src/test_utils.rs

@@ -329,21 +329,6 @@ mod tests {
                 assert_eq!(read_account.as_ref(), Some(expected_account));
             }
         }
-
-        // Test batch get_many
-        {
-            let reader: Tx<Ro> = db.reader().unwrap();
-            let addresses: Vec<Address> = accounts.iter().map(|(addr, _)| *addr).collect();
-            let read_accounts: Vec<(_, Option<Account>)> = reader
-                .get_many::<tables::PlainAccountState, _>(addresses.iter())
-                .into_iter()
-                .collect::<Result<Vec<_>, _>>()
-                .unwrap();
-
-            for (i, (_, expected_account)) in accounts.iter().enumerate() {
-                assert_eq!(read_accounts[i].1.as_ref(), Some(expected_account));
-            }
-        }
     }
 
     #[test]

crates/hot/src/conformance.rs

@@ -1959,7 +1959,6 @@ pub fn test_get_many<T: HotKv>(hot_kv: &T) {
     let addr1 = address!("0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee01");
     let addr2 = address!("0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee02");
     let addr3 = address!("0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee03");
-    let addr4 = address!("0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee04"); // non-existent
 
     let acc1 = Account { nonce: 1, balance: U256::from(100), bytecode_hash: None };
     let acc2 = Account { nonce: 2, balance: U256::from(200), bytecode_hash: None };
@@ -1973,34 +1972,6 @@ pub fn test_get_many<T: HotKv>(hot_kv: &T) {
         writer.put_account(&addr3, &acc3).unwrap();
         writer.commit().unwrap();
     }
-
-    // Batch retrieve
-    {
-        let reader = hot_kv.reader().unwrap();
-        let keys = [addr1, addr2, addr3, addr4];
-        let results = reader
-            .get_many::<tables::PlainAccountState, _>(&keys)
-            .into_iter()
-            .collect::<Result<Vec<_>, _>>()
-            .unwrap();
-
-        assert_eq!(results.len(), 4);
-
-        // Build a map for easier checking (order not guaranteed)
-        let result_map: HashMap<&Address, Option<Account>> =
-            results.iter().map(|(k, v)| (*k, *v)).collect();
-
-        assert!(result_map[&addr1].is_some());
-        assert_eq!(result_map[&addr1].as_ref().unwrap().nonce, 1);
-
-        assert!(result_map[&addr2].is_some());
-        assert_eq!(result_map[&addr2].as_ref().unwrap().nonce, 2);
-
-        assert!(result_map[&addr3].is_some());
-        assert_eq!(result_map[&addr3].as_ref().unwrap().nonce, 3);
-
-        assert!(result_map[&addr4].is_none(), "Non-existent key should return None");
-    }
 }
 
 /// Test queue_put_many batch writes.

crates/hot/src/mem.rs

@@ -1519,22 +1519,6 @@ mod tests {
             writer.queue_put_many::<TestTable, _>(entry_refs).unwrap();
             writer.raw_commit().unwrap();
         }
-
-        // Read batch
-        {
-            let reader = store.reader().unwrap();
-            let keys: Vec<_> = entries.iter().map(|(k, _)| k).collect();
-            let values = reader
-                .get_many::<TestTable, _>(keys)
-                .into_iter()
-                .collect::<Result<Vec<_>, _>>()
-                .unwrap();
-
-            assert_eq!(values.len(), 3);
-            assert_eq!(values[0], (&1u64, Some(Bytes::from_static(b"first"))));
-            assert_eq!(values[1], (&2u64, Some(Bytes::from_static(b"second"))));
-            assert_eq!(values[2], (&3u64, Some(Bytes::from_static(b"third"))));
-        }
     }
 
     #[test]

crates/hot/src/model/revm.rs

@@ -1,5 +1,5 @@
 use crate::{
-    model::{GetManyItem, HotKvError, HotKvRead, HotKvWrite},
+    model::{HotKvError, HotKvRead, HotKvWrite},
     tables::{self, Bytecodes, DualKey, PlainAccountState, SingleKey, Table},
 };
 use alloy::primitives::{Address, B256, KECCAK256_EMPTY};
@@ -74,18 +74,6 @@ impl<U: HotKvRead> HotKvRead for RevmRead<U> {
     ) -> Result<Option<T::Value>, Self::Error> {
         self.reader.get_dual::<T>(key1, key2)
     }
-
-    fn get_many<'a, T, I>(
-        &self,
-        keys: I,
-    ) -> impl IntoIterator<Item = Result<GetManyItem<'a, T>, Self::Error>>
-    where
-        T::Key: 'a,
-        T: SingleKey,
-        I: IntoIterator<Item = &'a T::Key>,
-    {
-        self.reader.get_many::<T, I>(keys)
-    }
 }
 
 /// Read-write REVM database adapter. This adapter allows committing changes.
@@ -155,18 +143,6 @@ impl<U: HotKvWrite> HotKvRead for RevmWrite<U> {
     ) -> Result<Option<T::Value>, Self::Error> {
         self.writer.get_dual::<T>(key1, key2)
     }
-
-    fn get_many<'a, T, I>(
-        &self,
-        keys: I,
-    ) -> impl IntoIterator<Item = Result<GetManyItem<'a, T>, Self::Error>>
-    where
-        T::Key: 'a,
-        T: SingleKey,
-        I: IntoIterator<Item = &'a T::Key>,
-    {
-        self.writer.get_many::<T, I>(keys)
-    }
 }
 
 impl<U: HotKvWrite> HotKvWrite for RevmWrite<U> {

crates/hot/src/model/traits.rs

@@ -1,7 +1,7 @@
 use crate::{
     model::{
-        DualKeyTraverse, DualKeyValue, DualTableCursor, GetManyDualItem, GetManyItem, HotKvError,
-        HotKvReadError, KeyValue, KvTraverse, KvTraverseMut, TableCursor,
+        DualKeyTraverse, DualKeyValue, DualTableCursor, HotKvError, HotKvReadError, KeyValue,
+        KvTraverse, KvTraverseMut, TableCursor,
         revm::{RevmRead, RevmWrite},
     },
     ser::{KeySer, MAX_KEY_SIZE, ValSer},
@@ -175,79 +175,6 @@ pub trait HotKvRead {
         };
         T::Value::decode_value(&value_bytes).map(Some).map_err(Into::into)
     }
-
-    /// Get many values from a specific table.
-    ///
-    /// # Arguments
-    ///
-    /// * `keys` - An iterator over keys to retrieve.
-    ///
-    /// # Returns
-    ///
-    /// An iterator of [`KeyValue`] where each element corresponds to the value
-    /// for the respective key in the input iterator. If a key does not exist
-    /// in the table, the corresponding element will be `None`.
-    ///
-    /// Implementations ARE NOT required to preserve the order of the input
-    /// keys in the output iterator. Users should not rely on any specific
-    /// ordering.
-    ///
-    /// If any error occurs during retrieval or deserialization, the entire
-    /// operation will return an error.
-    fn get_many<'a, T, I>(
-        &self,
-        keys: I,
-    ) -> impl IntoIterator<Item = Result<GetManyItem<'a, T>, Self::Error>>
-    where
-        T::Key: 'a,
-        T: SingleKey,
-        I: IntoIterator<Item = &'a T::Key>,
-    {
-        let mut key_buf = [0u8; MAX_KEY_SIZE];
-
-        keys.into_iter()
-            .map(move |key| (key, self.raw_get(T::NAME, key.encode_key(&mut key_buf))))
-            .map(|(key, maybe_val)| {
-                maybe_val
-                    .and_then(|val| {
-                        <T::Value as ValSer>::maybe_decode_value(val.as_deref()).map_err(Into::into)
-                    })
-                    .map(|res| (key, res))
-            })
-    }
-
-    /// Get many values from a specific dual-keyed table.
-    ///
-    /// # Arguments
-    /// * `keys` - An iterator over tuples of (key1, key2) to retrieve.
-    ///
-    /// # Returns
-    fn get_many_dual<'a, T, I>(
-        &self,
-        keys: I,
-    ) -> impl IntoIterator<Item = Result<GetManyDualItem<'a, T>, Self::Error>>
-    where
-        T: DualKey,
-        T::Key: 'a,
-        T::Key2: 'a,
-        I: IntoIterator<Item = (&'a T::Key, &'a T::Key2)>,
-    {
-        let mut key_buf = [0u8; MAX_KEY_SIZE];
-        let mut key2_buf = [0u8; MAX_KEY_SIZE];
-        keys.into_iter().map(move |(key1, key2)| {
-            let key1_bytes = key1.encode_key(&mut key_buf);
-            let key2_bytes = key2.encode_key(&mut key2_buf);
-
-            let maybe_val = self.raw_get_dual(T::NAME, key1_bytes, key2_bytes)?;
-
-            let decoded_val = match maybe_val {
-                Some(val) => Some(<T::Value as ValSer>::decode_value(&val)?),
-                None => None,
-            };
-
-            Ok((key1, key2, decoded_val))
-        })
-    }
 }
 
 /// Trait for hot storage write transactions.

crates/hot/src/model/traverse.rs

@@ -5,6 +5,7 @@ use crate::{
     ser::{KeySer, MAX_KEY_SIZE},
     tables::{DualKey, SingleKey},
 };
+use core::marker::PhantomData;
 use std::ops::Range;
 
 /// Trait for traversing key-value pairs in the database.
@@ -449,8 +450,6 @@ where
 // Wrapper Structs
 // ============================================================================
 
-use core::marker::PhantomData;
-
 /// A wrapper struct for typed table traversal.
 ///
 /// This struct wraps a raw cursor and provides type-safe access to table