api consistency updates

Author: clabby

glue/src/stateful/db/any.rs

@@ -37,12 +37,7 @@ use commonware_storage::{
     translator::Translator,
     Persistable,
 };
-use commonware_utils::{
-    channel::mpsc,
-    non_empty_range,
-    sync::{AsyncRwLock, AsyncRwLockReadGuard},
-    Array,
-};
+use commonware_utils::{channel::mpsc, non_empty_range, sync::AsyncRwLock, Array};
 use std::{ops::Deref, sync::Arc};
 
 type AnyDbHandle<F, E, C, I, H, U> = Arc<AsyncRwLock<Db<F, E, C, I, H, U>>>;
@@ -84,25 +79,13 @@ where
         self
     }
 
-    /// Acquire a read lock on the DB.
-    pub async fn lock(
-        &self,
-    ) -> AsyncRwLockReadGuard<'_, Db<F, E, C, I, H, unordered::Update<K, V>>> {
-        self.db.read().await
-    }
-
-    /// Get a reference to the inner batch.
-    pub const fn batch(&self) -> &UnmerkleizedBatch<F, H, unordered::Update<K, V>> {
-        &self.batch
-    }
-
     /// Read a value by key, falling back to committed state.
     pub async fn get(&self, key: &K) -> Result<Option<V::Value>, Error<F>> {
         let db = self.db.read().await;
         self.batch.get(key, &*db).await
     }
 
-    /// Read multiple values by key, amortizing lock acquisition and journal I/O.
+    /// Read multiple values by key, falling back to committed state.
     ///
     /// Returns results in the same order as the input keys.
     pub async fn get_many(&self, keys: &[&K]) -> Result<Vec<Option<V::Value>>, Error<F>> {
@@ -186,7 +169,7 @@ where
         self.batch.get(key, &*db).await
     }
 
-    /// Read multiple values by key, amortizing lock acquisition and journal I/O.
+    /// Read multiple values by key, falling back to committed state.
     ///
     /// Returns results in the same order as the input keys.
     pub async fn get_many(&self, keys: &[&K]) -> Result<Vec<Option<V::Value>>, Error<F>> {
@@ -201,6 +184,32 @@ where
     }
 }
 
+/// Read-through operations for the `any` merkleized batch.
+impl<F, E, C, I, H, U> AnyMerkleized<F, E, C, I, H, U>
+where
+    F: Family,
+    E: Storage + Clock + Metrics,
+    U: Update,
+    C: Contiguous<Item = Operation<F, U>>,
+    I: UnorderedIndex<Value = Location<F>> + 'static,
+    H: Hasher,
+    Operation<F, U>: Codec,
+{
+    /// Read a value by key, falling back to committed state.
+    pub async fn get(&self, key: &U::Key) -> Result<Option<U::Value>, Error<F>> {
+        let db = self.db.read().await;
+        self.inner.get(key, &*db).await
+    }
+
+    /// Read multiple values by key, falling back to committed state.
+    ///
+    /// Returns results in the same order as the input keys.
+    pub async fn get_many(&self, keys: &[&U::Key]) -> Result<Vec<Option<U::Value>>, Error<F>> {
+        let db = self.db.read().await;
+        self.inner.get_many(keys, &*db).await
+    }
+}
+
 /// Implement [`Unmerkleized`](UnmerkleizedTrait) for the `any` unordered update kind.
 impl<F, E, C, I, H, K, V> UnmerkleizedTrait
     for AnyUnmerkleized<F, E, C, I, H, unordered::Update<K, V>>

glue/src/stateful/db/current.rs

@@ -88,7 +88,7 @@ where
         self.batch.get(key, &*db).await
     }
 
-    /// Read multiple values by key, amortizing lock acquisition and journal I/O.
+    /// Read multiple values by key, falling back to committed state.
     ///
     /// Returns results in the same order as the input keys.
     pub async fn get_many(&self, keys: &[&K]) -> Result<Vec<Option<V::Value>>, Error<F>> {
@@ -173,7 +173,7 @@ where
         self.batch.get(key, &*db).await
     }
 
-    /// Read multiple values by key, amortizing lock acquisition and journal I/O.
+    /// Read multiple values by key, falling back to committed state.
     ///
     /// Returns results in the same order as the input keys.
     pub async fn get_many(&self, keys: &[&K]) -> Result<Vec<Option<V::Value>>, Error<F>> {
@@ -188,6 +188,32 @@ where
     }
 }
 
+/// Read-through operations for the `current` merkleized batch.
+impl<F, E, C, I, H, U, const N: usize> CurrentMerkleized<F, E, C, I, H, U, N>
+where
+    F: Graftable,
+    E: Storage + Clock + Metrics,
+    U: Update,
+    C: Contiguous<Item = Operation<F, U>>,
+    I: UnorderedIndex<Value = Location<F>> + 'static,
+    H: Hasher,
+    Operation<F, U>: Codec,
+{
+    /// Read a value by key, falling back to committed state.
+    pub async fn get(&self, key: &U::Key) -> Result<Option<U::Value>, Error<F>> {
+        let db = self.db.read().await;
+        self.inner.get(key, &*db).await
+    }
+
+    /// Read multiple values by key, falling back to committed state.
+    ///
+    /// Returns results in the same order as the input keys.
+    pub async fn get_many(&self, keys: &[&U::Key]) -> Result<Vec<Option<U::Value>>, Error<F>> {
+        let db = self.db.read().await;
+        self.inner.get_many(keys, &*db).await
+    }
+}
+
 /// Implement [`Unmerkleized`](UnmerkleizedTrait) for the `current` unordered update kind.
 impl<F, E, C, I, H, K, V, const N: usize> UnmerkleizedTrait
     for CurrentUnmerkleized<F, E, C, I, H, unordered::Update<K, V>, N>

glue/src/stateful/db/immutable.rs

@@ -107,7 +107,7 @@ where
         self.batch.get(key, &*db).await
     }
 
-    /// Read multiple values by key, amortizing lock acquisition and journal I/O.
+    /// Read multiple values by key, falling back to committed state.
     ///
     /// Returns results in the same order as the input keys.
     pub async fn get_many(&self, keys: &[&K]) -> Result<Vec<Option<V::Value>>, Error<F>> {
@@ -174,7 +174,7 @@ where
         self.inner.get(key, &*db).await
     }
 
-    /// Read multiple values by key, amortizing lock acquisition and journal I/O.
+    /// Read multiple values by key, falling back to committed state.
     ///
     /// Returns results in the same order as the input keys.
     pub async fn get_many(&self, keys: &[&K]) -> Result<Vec<Option<V::Value>>, Error<F>> {

glue/src/stateful/db/keyless.rs

@@ -100,9 +100,10 @@ where
         self.batch.get(location, &*db).await
     }
 
-    /// Read values at multiple locations, amortizing lock acquisition.
+    /// Read multiple values by location, falling back to committed state.
     ///
-    /// Locations must be sorted in ascending order.
+    /// Locations must be sorted in ascending order. Returns results in the same
+    /// order as the input locations.
     pub async fn get_many(
         &self,
         locations: &[Location<F>],
@@ -164,9 +165,10 @@ where
         self.inner.get(location, &*db).await
     }
 
-    /// Read values at multiple locations, amortizing lock acquisition.
+    /// Read multiple values by location, falling back to committed state.
     ///
-    /// Locations must be sorted in ascending order.
+    /// Locations must be sorted in ascending order. Returns results in the same
+    /// order as the input locations.
     pub async fn get_many(
         &self,
         locations: &[Location<F>],