Struct mz_persist_client::internal::state::State

pub struct State<T> {
    pub(crate) applier_version: Version,
    pub(crate) shard_id: ShardId,
    pub(crate) seqno: SeqNo,
    pub(crate) walltime_ms: u64,
    pub(crate) hostname: String,
    pub(crate) collections: StateCollections<T>,
}

Fields

applier_version: Version

shard_id: ShardId

seqno: SeqNo

walltime_ms: u64

A strictly increasing wall time of when this state was written, in milliseconds since the unix epoch.

hostname: String

Hostname of the persist user that created this version of state. For debugging.

collections: StateCollections<T>

Implementations

impl<T> State<T>

where T: Timestamp + Lattice + Codec64,

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 spine_batch_count(&self) -> usize

pub fn size_metrics(&self) -> StateSizeMetrics

pub fn latest_rollup(&self) -> (&SeqNo, &HollowRollup)

pub(crate) fn seqno_since(&self) -> SeqNo

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

pub fn seqnos_held(&self) -> usize

Return the number of gc-ineligible state versions.

pub fn expire_at(&mut self, walltime_ms: EpochMillis) -> ExpiryMetrics

Expire all readers and writers up to the given walltime_ms.

pub fn snapshot( &self, as_of: &Antichain<T>, ) -> Result<Vec<HollowBatch<T>>, SnapshotErr<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>, ) -> Result<HollowBatch<T>, SeqNo>

pub fn need_rollup(&self, threshold: usize) -> Option<SeqNo>

pub(crate) fn blobs(&self) -> impl Iterator<Item = HollowBlobRef<'_, T>>

impl<T: Timestamp + Lattice + Codec64> State<T>

pub fn apply_encoded_diffs<'a, I: IntoIterator<Item = &'a VersionedData>>( &mut self, cfg: &PersistConfig, metrics: &Metrics, diffs: I, )

impl<T: Timestamp + Lattice + Codec64> State<T>

pub fn apply_diffs<I: IntoIterator<Item = (StateDiff<T>, Bytes)>>( &mut self, metrics: &Metrics, diffs: I, )

pub(super) fn apply_diff( &mut self, metrics: &Metrics, diff: StateDiff<T>, ) -> Result<(), String>

Trait Implementations

impl<T: Clone> Clone for State<T>

fn clone(&self) -> State<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for State<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for State<T>

fn eq(&self, other: &State<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Serialize + Timestamp + Lattice> Serialize for State<T>

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for State<T>