Struct mz_stash::transaction::Transaction

pub struct Transaction<'a> {
    stmts: &'a CountedStatements<'a>,
    client: &'a Client,
    consolidations: UnboundedSender<ConsolidateRequest>,
    savepoint: Arc<Mutex<bool>>,
    sinces: Arc<Mutex<BTreeMap<i64, Antichain<Timestamp>>>>,
    uppers: Arc<Mutex<BTreeMap<i64, Antichain<Timestamp>>>>,
    stash_collections: &'a BTreeMap<String, i64>,
    txn_collections: Arc<Mutex<BTreeMap<String, i64>>>,
}

Fields

stmts: &'a CountedStatements<'a>

client: &'a Client

consolidations: UnboundedSender<ConsolidateRequest>

savepoint: Arc<Mutex<bool>>

sinces: Arc<Mutex<BTreeMap<i64, Antichain<Timestamp>>>>

uppers: Arc<Mutex<BTreeMap<i64, Antichain<Timestamp>>>>

stash_collections: &'a BTreeMap<String, i64>

txn_collections: Arc<Mutex<BTreeMap<String, i64>>>

Implementations

impl<'a> Transaction<'a>

async fn in_savepoint<'res, F, T>(&self, f: F) -> Result<T, StashError>where F: FnOnce() -> BoxFuture<'res, Result<T, StashError>>,

Executes f in a SAVEPOINT. RELEASE if f returns Ok, ROLLBACK if f returns Err. This must be used for any fn that performs any falliable operation after its first write. This includes multiple write operations in a row (any function with multpile writes must use this function).

pub async fn collection<K, V>( &self, name: &str ) -> Result<StashCollection<K, V>, StashError>where K: Data, V: Data,

pub async fn collections(&self) -> Result<BTreeMap<i64, String>, StashError>

Returns the ids and names of all collections.

pub(crate) async fn consolidate(&self, id: i64) -> Result<(), StashError>

pub(crate) async fn upper( &self, collection_id: i64 ) -> Result<Antichain<Timestamp>, StashError>

pub(crate) async fn since( &self, collection_id: i64 ) -> Result<Antichain<Timestamp>, StashError>

pub(crate) async fn iter<K, V>( &self, collection: StashCollection<K, V> ) -> Result<Vec<((K, V), Timestamp, Diff)>, StashError>where K: Data, V: Data,

Iterates over a collection.

pub(crate) async fn iter_raw( &self, id: i64 ) -> Result<impl Iterator<Item = ((Vec<u8>, Vec<u8>), Timestamp, Diff)>, StashError>

Iterates over a collection, returning the raw data on disk, unconsolidated.

pub(crate) async fn iter_key<K, V>( &self, collection: StashCollection<K, V>, key: &K ) -> Result<Vec<(V, Timestamp, Diff)>, StashError>where K: Data, V: Data,

Iterates over the values of a key.

async fn peek_timestamp_id(&self, id: i64) -> Result<Timestamp, StashError>

Returns the most recent timestamp at which sealed entries can be read.

pub(crate) async fn peek_timestamp<K, V>( &self, collection: StashCollection<K, V> ) -> Result<Timestamp, StashError>where K: Data, V: Data,

Returns the most recent timestamp at which sealed entries can be read.

pub(crate) async fn peek<K, V>( &self, collection: StashCollection<K, V> ) -> Result<Vec<(K, V, Diff)>, StashError>where K: Data, V: Data,

Returns the current value of sealed entries.

Entries are iterated in (key, value) order and are guaranteed to be consolidated.

Sealed entries are those with timestamps less than the collection’s upper frontier.

pub async fn peek_one<K, V>( &self, collection: StashCollection<K, V> ) -> Result<BTreeMap<K, V>, StashError>where K: Data, V: Data,

Returns the current k,v pairs of sealed entries, erroring if there is more than one entry for a given key or the multiplicity is not 1 for each key.

Sealed entries are those with timestamps less than the collection’s upper frontier.

pub async fn peek_key_one<K, V>( &self, collection: StashCollection<K, V>, key: &K ) -> Result<Option<V>, StashError>where K: Data, V: Data,

Returns the current sealed value for the given key, erroring if there is more than one entry for the key or its multiplicity is not 1.

Sealed entries are those with timestamps less than the collection’s upper frontier.

pub async fn append(&self, batches: Vec<AppendBatch>) -> Result<(), StashError>

Applies batches to the current transaction. If any batch fails and in error returned, all other applications are rolled back.

pub(crate) async fn update_savepoint<K, V>( &self, collection_id: i64, entries: &[((K, V), Timestamp, Diff)], upper: Option<Antichain<Timestamp>> ) -> Result<(), StashError>where K: Data, V: Data,

Like update, but starts a savepoint.

async fn update( &self, collection_id: i64, entries: &[((Vec<u8>, Vec<u8>), Timestamp, Diff)], upper: Option<Antichain<Timestamp>> ) -> Result<(), StashError>

Directly add k, v, ts, diff tuples to a collection. upper can be Some if the collection’s upper is already known. Caller must have already called in_savepoint.

This function should not be called outside of the stash crate since it allows for arbitrary bytes, non-unit diffs in collections, and doesn’t support transaction safety. Use TypedCollection’s methods instead.

pub(crate) async fn compact<'ts>( &self, id: i64, new_since: &'ts Antichain<Timestamp>, upper: Option<Antichain<Timestamp>> ) -> Result<(), StashError>

Sets the since of a collection. The current upper can be Some if it is already known.

pub(crate) async fn seal( &self, id: i64, new_upper: Antichain<Timestamp>, upper: Option<Antichain<Timestamp>> ) -> Result<(), StashError>

Sets the upper of a collection. The current upper can be Some if it is already known.