Struct mz_timestamp_oracle::batching_oracle::BatchingTimestampOracle

pub struct BatchingTimestampOracle<T> {
    inner: Arc<dyn TimestampOracle<T> + Send + Sync>,
    command_tx: UnboundedSender<Command<T>>,
}

A batching TimestampOracle backed by a TimestampOracle

This will only batch calls to read_ts because the rest of the system already naturally does batching of write-related calls via the group commit mechanism. Write-related calls are passed straight through to the backing oracle.

For read_ts calls, we have to be careful to never cache results from the backing oracle: for the timestamp to be linearized we can never return a result as of an earlier moment, but batching them up is correct because this can only make it so that we return later timestamps. Those later timestamps still fall within the duration of the read_ts call and so are linearized.

Fields

inner: Arc<dyn TimestampOracle<T> + Send + Sync>

command_tx: UnboundedSender<Command<T>>

Implementations

impl<T> BatchingTimestampOracle<T>

where T: Clone + Send + Sync + 'static,

pub fn new( metrics: Arc<Metrics>, oracle: Arc<dyn TimestampOracle<T> + Send + Sync>, ) -> Self

Crates a BatchingTimestampOracle that uses the given inner oracle.

Trait Implementations

impl<T> Debug for BatchingTimestampOracle<T>

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

Formats the value using the given formatter.

impl<T> TimestampOracle<T> for BatchingTimestampOracle<T>

where T: Send + Sync,

fn write_ts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = WriteTimestamp<T>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Acquire a new timestamp for writing.

fn peek_write_ts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = T> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Peek the current write timestamp.

fn read_ts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = T> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Acquire a new timestamp for reading.

fn apply_write<'life0, 'async_trait>( &'life0 self, write_ts: T, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Mark a write at write_ts completed.