Struct mz_persist_client::internal::apply::Applier

pub struct Applier<K, V, T, D> {
    pub(crate) cfg: PersistConfig,
    pub(crate) metrics: Arc<Metrics>,
    pub(crate) shard_metrics: Arc<ShardMetrics>,
    pub(crate) state_versions: Arc<StateVersions>,
    shared_states: Arc<StateCache>,
    pubsub_sender: Arc<dyn PubSubSender>,
    pub(crate) shard_id: ShardId,
    state: Arc<LockingTypedState<K, V, T, D>>,
}

An applier of persist commands.

This struct exists mainly to allow us to very narrowly bound the surface area that directly interacts with state.

Fields

cfg: PersistConfig

metrics: Arc<Metrics>

shard_metrics: Arc<ShardMetrics>

state_versions: Arc<StateVersions>

shared_states: Arc<StateCache>

pubsub_sender: Arc<dyn PubSubSender>

shard_id: ShardId

state: Arc<LockingTypedState<K, V, T, D>>

Implementations

impl<K, V, T, D> Applier<K, V, T, D>where K: Debug + Codec, V: Debug + Codec, T: Timestamp + Lattice + Codec64, D: Semigroup + Codec64,

pub async fn new( cfg: PersistConfig, shard_id: ShardId, metrics: Arc<Metrics>, state_versions: Arc<StateVersions>, shared_states: Arc<StateCache>, pubsub_sender: Arc<dyn PubSubSender>, diagnostics: Diagnostics ) -> Result<Self, Box<CodecMismatch>>

pub fn watch(&self) -> StateWatch<K, V, T, D>

Returns a new StateWatch for changes to this Applier’s State.

pub async fn fetch_upper<R, F: FnMut(&Antichain<T>) -> R>(&mut self, f: F) -> R

Fetches the latest state from Consensus and passes its upper to the provided closure.

pub fn clone_upper(&self) -> Antichain<T>

A point-in-time read/clone of upper from the current state.

Due to sharing state with other handles, successive reads to this fn or any other may see a different version of state, even if this Applier has not explicitly fetched and updated to the latest state. Successive calls will always return values such that PartialOrder::less_equal(call1, call2) hold true.

fn upper<R, F: FnMut(&Antichain<T>) -> R>(&self, f: F) -> R

pub fn seqno(&self) -> SeqNo

A point-in-time read of seqno from the current state.

Due to sharing state with other handles, successive reads to this fn or any other may see a different version of state, even if this Applier has not explicitly fetched and updated to the latest state. Successive calls will always return values such that call1 <= call2 hold true.

pub fn seqno_since(&self) -> SeqNo

A point-in-time read of seqno_since from the current state.

Due to sharing state with other handles, successive reads to this fn or any other may see a different version of state, even if this Applier has not explicitly fetched and updated to the latest state. Successive calls will always return values such that call1 <= call2 hold true.

pub fn is_finalized(&self) -> bool

A point-in-time read from the current state. (We declare a shard ‘finalized’ if it’s both become an unreadable tombstone and the state itself is has been emptied out.)

Due to sharing state with other handles, successive reads to this fn or any other may see a different version of state, even if this Applier has not explicitly fetched and updated to the latest state. Once this fn returns true, it will always return true.

pub fn check_since_upper_both_empty(&self) -> Result<(), InvalidUsage<T>>

Returns whether the current’s state since and upper are both empty.

Due to sharing state with other handles, successive reads to this fn or any other may see a different version of state, even if this Applier has not explicitly fetched and updated to the latest state. Once this fn returns true, it will always return true.

pub fn rollups_lte_seqno(&self, seqno: SeqNo) -> Vec<(SeqNo, PartialRollupKey)>

Returns all rollups that are <= the given seqno.

Due to sharing state with other handles, successive reads to this fn or any other may see a different version of state, even if this Applier has not explicitly fetched and updated to the latest state.

pub fn all_fueled_merge_reqs(&self) -> Vec<FueledMergeReq<T>>

pub fn snapshot( &self, as_of: &Antichain<T> ) -> Result<Vec<HollowBatch<T>>, SnapshotErr<T>>

pub fn all_batches(&self) -> Vec<HollowBatch<T>>

pub fn verify_listen( &self, as_of: &Antichain<T> ) -> Result<Result<(), Upper<T>>, Since<T>>

pub fn next_listen_batch( &self, frontier: &Antichain<T> ) -> Result<HollowBatch<T>, SeqNo>

pub async fn write_rollup_for_state(&self) -> Option<EncodedRollup>

pub async fn apply_unbatched_cmd<R, E, WorkFn: FnMut(SeqNo, &PersistConfig, &mut StateCollections<T>) -> ControlFlow<E, R>>( &mut self, cmd: &CmdMetrics, work_fn: WorkFn ) -> Result<(SeqNo, Result<R, E>, RoutineMaintenance), Indeterminate>

async fn apply_unbatched_cmd_locked<R, E, WorkFn: FnMut(SeqNo, &PersistConfig, &mut StateCollections<T>) -> ControlFlow<E, R>>( state: &LockingTypedState<K, V, T, D>, cmd: &CmdMetrics, work_fn: &mut WorkFn, cfg: &PersistConfig, metrics: &Metrics, shard_metrics: &ShardMetrics, state_versions: &StateVersions ) -> ApplyCmdResult<K, V, T, D, R, E>

fn compute_next_state_locked<R, E, WorkFn: FnMut(SeqNo, &PersistConfig, &mut StateCollections<T>) -> ControlFlow<E, R>>( state: &TypedState<K, V, T, D>, work_fn: &mut WorkFn, metrics: &Metrics, cmd: &CmdMetrics, cfg: &PersistConfig ) -> Result<NextState<K, V, T, D, R>, (SeqNo, E)>

pub fn update_state(&mut self, new_state: TypedState<K, V, T, D>)

pub async fn fetch_and_update_state(&self, seqno_hint: Option<SeqNo>)

Fetches and updates to the latest state. Uses an optional hint to early-out if any more recent version of state is observed (e.g. updated by another handle), without making any calls to Consensus or Blob.

Trait Implementations

impl<K, V, T: Clone, D> Clone for Applier<K, V, T, D>

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, T: Debug, D: Debug> Debug for Applier<K, V, T, D>

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

Formats the value using the given formatter.