Struct mz_stash::TypedCollection

pub struct TypedCollection<K, V> {
    pub(crate) name: &'static str,
    pub(crate) typ: PhantomData<(K, V)>,
}

A helper struct to prevent mistyping of a StashCollection’s name and k,v types.

Fields

name: &'static str

typ: PhantomData<(K, V)>

Implementations

impl<K, V> TypedCollection<K, V>where K: DataProto, V: DataProto,

pub async fn migrate_to<K2, V2>( &self, _tx: &mut Transaction<'_>, _f: impl for<'a> FnOnce(&'a BTreeMap<K, V>) -> Vec<MigrationAction<K, K2, V2>> ) -> Result<(), StashError>where K2: DataProto, V2: DataProto,

Provided a closure, will migrate a TypedCollection of types K and V to types K2 and V2.

TODO(parkmycar): Fill in this implementation in a future PR.

pub async fn initialize( &self, tx: &mut Transaction<'_>, values: impl IntoIterator<Item = (K, V)> ) -> Result<(), StashError>

Initializes a TypedCollection with the values provided in values.

Panics

• If the TypedCollection is not empty.

impl<K, V> TypedCollection<K, V>

pub const fn new(name: &'static str) -> Self

pub const fn name(&self) -> &'static str

impl<K, V> TypedCollection<K, V>where K: Data, V: Data,

pub async fn make_batch( &self, stash: &mut Stash ) -> Result<(StashCollection<K, V>, AppendBatch), StashError>

pub async fn get( &self, stash: &mut Stash ) -> Result<StashCollection<K, V>, StashError>

pub async fn from_tx( &self, tx: &Transaction<'_> ) -> Result<StashCollection<K, V>, StashError>

pub async fn upper( &self, stash: &mut Stash ) -> Result<Antichain<Timestamp>, StashError>

pub async fn iter( &self, stash: &mut Stash ) -> Result<Vec<((K, V), Timestamp, Diff)>, StashError>

pub async fn peek( &self, stash: &mut Stash ) -> Result<Vec<(K, V, Diff)>, StashError>where K: Hash,

pub async fn peek_one( &self, stash: &mut Stash ) -> Result<BTreeMap<K, V>, StashError>where K: Hash,

pub async fn peek_key_one( &self, stash: &mut Stash, key: K ) -> Result<Option<V>, StashError>where K: 'static,

pub async fn insert_key_without_overwrite( &self, stash: &mut Stash, key: K, value: V ) -> Result<V, StashError>where K: 'static, V: Clone + 'static,

Sets the given k,v pair, if not already set.

Returns the new value stored in stash after this operations.

pub async fn insert_without_overwrite<I>( &self, stash: &mut Stash, entries: I ) -> Result<(), StashError>where I: IntoIterator<Item = (K, V)>, K: Clone + Hash + 'static, V: Clone + 'static,

Sets the given key value pairs, if not already set. If a new key appears multiple times in entries, its value will be from the first occurrence in entries.

pub async fn upsert_key<F, R>( &self, stash: &mut Stash, key: K, f: F ) -> Result<Result<(Option<V>, V), R>, StashError>where F: FnOnce(Option<&V>) -> Result<V, R> + Clone + Send + Sync + 'static, K: 'static,

Sets a value for a key. f is passed the previous value, if any.

Returns the previous value if one existed and the value returned from f.

pub async fn upsert<I>( &self, stash: &mut Stash, entries: I ) -> Result<(), StashError>where I: IntoIterator<Item = (K, V)>, K: Hash + 'static, V: 'static,

Sets the given key value pairs, removing existing entries match any key.

pub async fn delete<P>( &self, stash: &mut Stash, predicate: P ) -> Result<(), StashError>where P: Fn(&K, &V) -> bool + Clone + Sync + Send + 'static, K: Hash + Clone, V: Clone,

Transactionally deletes any kv pair from self which returns true for predicate.

Note that this operation:

• Runs in a single transaction and cannot be combined with other transactions.
• Scans the entire table to perform deletions.

pub async fn delete_keys( &self, stash: &mut Stash, keys: BTreeSet<K> ) -> Result<(), StashError>where K: Hash + Clone + 'static, V: Clone,

Transactionally deletes any kv pair from self whose key is in keys.

Note that:

• Unlike delete, this operation operates in time O(keys), and not O(set), however does so by parallelizing a number of point queries so is likely not performant for more than 10-or-so keys.
• This operation runs in a single transaction and cannot be combined with other transactions.

pub async fn update<T>( &self, stash: &mut Stash, transform: T ) -> Result<(), StashError>where T: Fn(&K, &V) -> Option<V> + Clone + Sync + Send + 'static, K: Hash + Clone, V: Clone,

Transactionally updates values in all KV pairs using transform.

Note that this operation:

• Runs in a single transaction and cannot be combined with other transactions.
• Scans the entire table to perform deletions.