Struct persist::client::StreamWriteHandle

pub struct StreamWriteHandle<K, V> {
    name: String,
    stream_id: Result<Id, Error>,
    client: RuntimeClient,
    _phantom: PhantomData<(K, V)>,
}

A handle that allows writes of ((Key, Value), Time, Diff) updates into an crate::indexed::Indexed via a RuntimeClient.

Fields

name: String

stream_id: Result<Id, Error>

client: RuntimeClient

_phantom: PhantomData<(K, V)>

Implementations

impl<K: Codec, V: Codec> StreamWriteHandle<K, V>

pub fn stream_name(&self) -> &str

Returns the external stream name for this handle.

pub fn stream_id(&self) -> Result<Id, Error>

Returns the internal stream Id for this handle.

pub fn write<'a, I>(&self, updates: I) -> PFuture<SeqNo> where
    I: IntoIterator<Item = &'a ((K, V), u64, isize)>, 

Asynchronously persists (Key, Value, Time, Diff) updates.

pub fn seal(&self, upper: u64) -> PFuture<SeqNo>

Closes the stream at the given timestamp, migrating data strictly less than it into the trace.

pub fn allow_compaction(&self, since: Antichain<u64>) -> PFuture<SeqNo>

Unblocks compaction for updates at or before since.

The compaction frontier can never decrease and it is an error to call this function with a since argument that is less than the current compaction frontier.

While it may seem counter-intuitive to advance the compaction frontier past the seal frontier, this is perfectly valid. It can happen when joining updates from one stream to updates from another stream, and we already know that the other stream is compacted further along. Allowing compaction on this, the first stream, then is saying that we are fine with losing historical detail, and that we already allow compaction of updates that are yet to come because we don’t need them at their full resolution. A similar case is when we know that any outstanding queries have an as_of that is in the future of the seal: we can also pro-actively allow compaction of updates that did not yet arrive.

Trait Implementations

impl<K, V> Clone for StreamWriteHandle<K, V>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.