Struct mz_catalog::durable::transaction::TableTransaction

struct TableTransaction<K, V> {
    initial: BTreeMap<K, V>,
    pending: BTreeMap<K, Vec<TransactionUpdate<V>>>,
    uniqueness_violation: Option<fn(a: &V, b: &V) -> bool>,
}

TableTransaction emulates some features of a typical SQL transaction over table for a Collection.

It supports:

• uniqueness constraints
• transactional reads and writes (including read-your-writes before commit)

K is the primary key type. Multiple entries with the same key are disallowed. V is the an arbitrary value type.

Fields

initial: BTreeMap<K, V>

pending: BTreeMap<K, Vec<TransactionUpdate<V>>>

uniqueness_violation: Option<fn(a: &V, b: &V) -> bool>

Implementations

impl<K, V> TableTransaction<K, V>

where K: Ord + Eq + Clone + Debug, V: Ord + Clone + Debug,

fn new<KP, VP>(initial: BTreeMap<KP, VP>) -> Result<Self, TryFromProtoError>

where K: RustType<KP>, V: RustType<VP>,

Create a new TableTransaction with initial data.

Internally the catalog serializes data as protobuf. All fields in a proto message are optional, which makes using them in Rust cumbersome. Generic parameters KP and VP are protobuf types which deserialize to K and V that a TableTransaction is generic over.

fn new_with_uniqueness_fn<KP, VP>( initial: BTreeMap<KP, VP>, uniqueness_violation: fn(a: &V, b: &V) -> bool, ) -> Result<Self, TryFromProtoError>

where K: RustType<KP>, V: RustType<VP>,

Like Self::new, but you can also provide uniqueness_violation, which is a function that determines whether there is a uniqueness violation among two values.

fn pending<KP, VP>(self) -> Vec<(KP, VP, Diff)>

where K: RustType<KP>, V: RustType<VP>,

Consumes and returns the pending changes and their diffs. Diff is guaranteed to be 1 or -1.

fn verify(&self) -> Result<(), DurableCatalogError>

Verifies that no items in self violate self.uniqueness_violation.

Runtime is O(n^2), where n is the number of items in self. Prefer using Self::verify_keys.

fn verify_keys<'a>( &self, keys: impl IntoIterator<Item = &'a K>, ) -> Result<(), DurableCatalogError>

where K: 'a,

Verifies that no items in self violate self.uniqueness_violation with keys.

Runtime is O(n * k), where n is the number of items in self and k is the number of items in keys.

fn for_values<F: FnMut(&K, &V)>(&self, f: F)

Iterates over the items viewable in the current transaction in arbitrary order and applies f on all key, value pairs.

fn get(&self, k: &K) -> Option<V>

Returns the current value of k.

fn items(&self) -> BTreeMap<K, V>

Returns the items viewable in the current transaction.

fn for_values_mut<F: FnMut(&mut BTreeMap<K, Vec<TransactionUpdate<V>>>, &K, &V)>( &mut self, f: F, )

Iterates over the items viewable in the current transaction, and provides a map where additional pending items can be inserted, which will be appended to current pending items. Does not verify uniqueness.

fn insert(&mut self, k: K, v: V, ts: u64) -> Result<(), DurableCatalogError>

Inserts a new k,v pair.

Returns an error if the uniqueness check failed or the key already exists.

fn update<F: Fn(&K, &V) -> Option<V>>( &mut self, f: F, ts: u64, ) -> Result<Diff, DurableCatalogError>

Updates k, v pairs. f is a function that can return Some(V) if the value should be updated, otherwise None. Returns the number of changed entries.

Returns an error if the uniqueness check failed.

Prefer using Self::update_by_key or Self::update_by_keys, which generally have better performance.

fn update_by_key( &mut self, k: K, v: V, ts: u64, ) -> Result<bool, DurableCatalogError>

Updates k, v pair if k already exists in self.

Returns true if k was updated, false otherwise. Returns an error if the uniqueness check failed.

fn update_by_keys( &mut self, kvs: impl IntoIterator<Item = (K, V)>, ts: u64, ) -> Result<Diff, DurableCatalogError>

Updates k, v pairs. Keys that don’t already exist in self are ignored.

Returns the number of changed entries. Returns an error if the uniqueness check failed.

fn set( &mut self, k: K, v: Option<V>, ts: u64, ) -> Result<Option<V>, DurableCatalogError>

Set the value for a key. Returns the previous entry if the key existed, otherwise None.

Returns an error if the uniqueness check failed.

DO NOT call this function in a loop, use Self::set_many instead.

fn set_many( &mut self, kvs: BTreeMap<K, Option<V>>, ts: u64, ) -> Result<BTreeMap<K, Option<V>>, DurableCatalogError>

Set the values for many keys. Returns the previous entry for each key if the key existed, otherwise None.

Returns an error if any uniqueness check failed.

fn delete<F: Fn(&K, &V) -> bool>(&mut self, f: F, ts: u64) -> Vec<(K, V)>

Deletes items for which f returns true. Returns the keys and values of the deleted entries.

Prefer using Self::delete_by_key or Self::delete_by_keys, which generally have better performance.

fn delete_by_key(&mut self, k: K, ts: u64) -> Option<V>

Deletes item with key k.

Returns the value of the deleted entry, if it existed.

fn delete_by_keys( &mut self, ks: impl IntoIterator<Item = K>, ts: u64, ) -> Vec<(K, V)>

Deletes items with key in ks.

Returns the keys and values of the deleted entries.

Trait Implementations

impl<K: Debug, V: Debug> Debug for TableTransaction<K, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K: PartialEq, V: PartialEq> PartialEq for TableTransaction<K, V>

fn eq(&self, other: &TableTransaction<K, V>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: Eq, V: Eq> Eq for TableTransaction<K, V>

impl<K, V> StructuralPartialEq for TableTransaction<K, V>