Struct mz_stash::sqlite::Sqlite

pub struct Sqlite {
    conn: Connection,
}

A Stash whose data is stored in a single file on disk. The format of this file is not specified and should not be relied upon. The only promise is stability. Any changes to the on-disk format will be accompanied by a clear migration path.

Fields

conn: Connection

Implementations

impl Sqlite

pub fn open(path: Option<&Path>) -> Result<Sqlite, StashError>

Opens the stash stored at the specified path. If None, opens an in-memory instance.

fn since_tx(
    tx: &Transaction<'_>,
    collection_id: Id
) -> Result<Antichain<Timestamp>, StashError>

fn upper_tx(
    tx: &Transaction<'_>,
    collection_id: Id
) -> Result<Antichain<Timestamp>, StashError>

fn seal_batch_tx<'a, I>(tx: &Transaction<'_>, seals: I) -> Result<(), StashError>where
    I: Iterator<Item = (Id, &'a Antichain<Timestamp>)>,

fn update_many_tx<I>(
    tx: &Transaction<'_>,
    collection_id: Id,
    entries: I
) -> Result<(), StashError>where
    I: Iterator<Item = ((Value, Value), Timestamp, Diff)>,

fn compact_batch_tx<'a, I>(
    tx: &Transaction<'_>,
    compactions: I
) -> Result<(), StashError>where
    I: Iterator<Item = (Id, &'a Antichain<Timestamp>)>,

fn consolidate_batch_tx(
    tx: &Transaction<'_>,
    collections: &[Id]
) -> Result<(), StashError>

Trait Implementations

impl Append for Sqlite

fn append_batch<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    batches: &'life1 [AppendBatch]
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Same as append, but does not consolidate batches.

fn append<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    batches: &'life1 [AppendBatch]
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Send + 'async_trait,

Atomically adds entries, seals, compacts, and consolidates multiple collections.

impl Debug for Sqlite

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

Formats the value using the given formatter.

impl Stash for Sqlite

fn since<'life0, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>
) -> Pin<Box<dyn Future<Output = Result<Antichain<Timestamp>, StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Reports the current since frontier.

fn upper<'life0, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>
) -> Pin<Box<dyn Future<Output = Result<Antichain<Timestamp>, StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Reports the current upper frontier.

fn collection<'life0, 'life1, 'async_trait, K, V>(
    &'life0 mut self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<StashCollection<K, V>, StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Loads or creates the named collection.

fn collections<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<BTreeSet<String>, StashError>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Returns the names of the collections in the stash.

fn iter<'life0, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>
) -> Pin<Box<dyn Future<Output = Result<Vec<((K, V), Timestamp, Diff)>, StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Iterates over all entries in the stash.

fn iter_key<'life0, 'life1, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>,
    key: &'life1 K
) -> Pin<Box<dyn Future<Output = Result<Vec<(V, Timestamp, Diff)>, StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Iterates over entries in the stash for the given key.

fn update_many<'life0, 'async_trait, K, V, I>(
    &'life0 mut self,
    collection: StashCollection<K, V>,
    entries: I
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    I: IntoIterator<Item = ((K, V), Timestamp, Diff)> + Send,
    I::IntoIter: Send,
    K: 'async_trait,
    V: 'async_trait,
    I: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Atomically adds multiple entries to the arrangement.

fn seal<'life0, 'life1, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>,
    new_upper: AntichainRef<'life1, Timestamp>
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Atomically advances the upper frontier to the specified value.

fn seal_batch<'life0, 'life1, 'async_trait, K, V>(
    &'life0 mut self,
    seals: &'life1 [(StashCollection<K, V>, Antichain<Timestamp>)]
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Performs multiple seals at once, potentially in a more performant way than performing the individual seals one by one.

fn compact<'a, 'async_trait, K, V>(
    &'a mut self,
    collection: StashCollection<K, V>,
    new_since: AntichainRef<'a, Timestamp>
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    'a: 'async_trait,
    K: 'async_trait,
    V: 'async_trait,
    Self: 'async_trait,

Atomically advances the since frontier to the specified value.

fn compact_batch<'life0, 'life1, 'async_trait, K, V>(
    &'life0 mut self,
    compactions: &'life1 [(StashCollection<K, V>, Antichain<Timestamp>)]
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Performs multiple compactions at once, potentially in a more performant way than performing the individual compactions one by one.

fn consolidate<'life0, 'async_trait>(
    &'life0 mut self,
    collection: Id
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Atomically consolidates entries less than the since frontier.

fn consolidate_batch<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    collections: &'life1 [Id]
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Performs multiple consolidations at once, potentially in a more performant way than performing the individual consolidations one by one.

fn confirm_leadership<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Returns Ok if this stash instance was the leader at some point from the invocation of this method to the return of this method. Otherwise, returns Err.

fn epoch(&self) -> Option<NonZeroI64>

Returns the stash’s epoch number. If Some, it is a positive number that increases with each start of a stash.

fn peek_timestamp<'life0, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>
) -> Pin<Box<dyn Future<Output = Result<Timestamp, StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

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

fn peek<'life0, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>
) -> Pin<Box<dyn Future<Output = Result<Vec<(K, V, Diff)>, StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Returns the current value of sealed entries.

fn peek_one<'life0, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>
) -> Pin<Box<dyn Future<Output = Result<BTreeMap<K, V>, StashError>> + Send + 'async_trait>>where
    K: Data + Hash,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

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.

fn peek_key_one<'life0, 'life1, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>,
    key: &'life1 K
) -> Pin<Box<dyn Future<Output = Result<Option<V>, StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

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.

fn update<'life0, 'async_trait, K, V>(
    &'life0 mut self,
    collection: StashCollection<K, V>,
    data: (K, V),
    time: Timestamp,
    diff: Diff
) -> Pin<Box<dyn Future<Output = Result<(), StashError>> + Send + 'async_trait>>where
    K: Data,
    V: Data,
    K: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Atomically adds a single entry to the arrangement.