Struct mz_persist_client::impl::state::State

pub struct State<K, V, T, D> {
    pub(crate) applier_version: Version,
    pub(crate) shard_id: ShardId,
    pub(crate) seqno: SeqNo,
    pub(crate) collections: StateCollections<T>,
    pub(crate) _phantom: PhantomData<fn() -> (K, V, D)>,
}

Fields

applier_version: Version

shard_id: ShardId

seqno: SeqNo

collections: StateCollections<T>

_phantom: PhantomData<fn() -> (K, V, D)>

Implementations

impl<K, V, T, D> State<K, V, T, D> where
    K: Codec,
    V: Codec,
    T: Timestamp + Lattice + Codec64,
    D: Codec64, 

pub fn decode(
    build_version: &Version,
    buf: &[u8]
) -> Result<Self, CodecMismatch>

impl<K, V, T, D> State<K, V, T, D> where
    K: Codec,
    V: Codec,
    T: Timestamp + Lattice + Codec64,
    D: Codec64, 

fn try_from(
    x: ProtoStateRollup
) -> Result<Result<Self, CodecMismatch>, TryFromProtoError>

impl<K, V, T: Clone, D> State<K, V, T, D>

pub(crate) fn clone(&self, applier_version: Version) -> Self

impl<K, V, T, D> State<K, V, T, D> where
    K: Codec,
    V: Codec,
    T: Timestamp + Lattice + Codec64,
    D: Codec64, 

pub fn new(applier_version: Version, shard_id: ShardId) -> Self

pub fn shard_id(&self) -> ShardId

pub fn seqno(&self) -> SeqNo

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

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

pub fn batch_count(&self) -> usize

fn seqno_since(&self) -> SeqNo

pub fn maybe_gc(&mut self, is_write: bool) -> Option<(SeqNo, SeqNo)>

pub fn seqnos_held(&self) -> usize

Return the number of gc-ineligible state versions.

pub fn clone_apply<R, E, WorkFn>(
    &self,
    build_version: &Version,
    work_fn: &mut WorkFn
) -> ControlFlow<E, (R, Self)> where
    WorkFn: FnMut(SeqNo, &mut StateCollections<T>) -> ControlFlow<E, R>, 

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

Returns the batches that contain updates up to (and including) the given as_of. The result Vec contains blob keys, along with a Description of what updates in the referenced parts are valid to read.

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

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

pub fn handles_needing_expiration(
    &self,
    now_ms: EpochMillis
) -> (Vec<ReaderId>, Vec<WriterId>)

Trait Implementations

impl<K, V, T, D> Codec for State<K, V, T, D> where
    K: Codec,
    V: Codec,
    T: Timestamp + Lattice + Codec64,
    D: Codec64, 

fn codec_name() -> String

Name of the codec.

fn encode<B>(&self, buf: &mut B) where
    B: BufMut, 

Encode a key or value for permanent storage.

fn decode<'a>(buf: &'a [u8]) -> Result<Self, String>

Decode a key or value previous encoded with this codec’s Codec::encode.

impl<K: Debug, V: Debug, T: Debug, D: Debug> Debug for State<K, V, T, D>

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

Formats the value using the given formatter.

impl<K, V, T, D> RustType<ProtoStateRollup> for State<K, V, T, D> where
    K: Codec,
    V: Codec,
    T: Timestamp + Lattice + Codec64,
    D: Codec64, 

fn into_proto(&self) -> ProtoStateRollup

Convert a Self into a Proto value.

fn from_proto(proto: ProtoStateRollup) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.