Struct mz_persist_client::internal::state_diff::StateDiff

pub struct StateDiff<T> {

    pub(crate) applier_version: Version,
    pub(crate) seqno_from: SeqNo,
    pub(crate) seqno_to: SeqNo,
    pub(crate) walltime_ms: u64,
    pub(crate) latest_rollup_key: PartialRollupKey,
    pub(crate) rollups: Vec<StateFieldDiff<SeqNo, HollowRollup>>,
    pub(crate) hostname: Vec<StateFieldDiff<(), String>>,
    pub(crate) last_gc_req: Vec<StateFieldDiff<(), SeqNo>>,
    pub(crate) leased_readers: Vec<StateFieldDiff<LeasedReaderId, LeasedReaderState<T>>>,
    pub(crate) critical_readers: Vec<StateFieldDiff<CriticalReaderId, CriticalReaderState<T>>>,
    pub(crate) writers: Vec<StateFieldDiff<WriterId, WriterState<T>>>,
    pub(crate) schemas: Vec<StateFieldDiff<SchemaId, EncodedSchemas>>,
    pub(crate) since: Vec<StateFieldDiff<(), Antichain<T>>>,
    pub(crate) legacy_batches: Vec<StateFieldDiff<HollowBatch<T>, ()>>,
    pub(crate) hollow_batches: Vec<StateFieldDiff<SpineId, Arc<HollowBatch<T>>>>,
    pub(crate) spine_batches: Vec<StateFieldDiff<SpineId, ThinSpineBatch<T>>>,
    pub(crate) merges: Vec<StateFieldDiff<SpineId, ThinMerge<T>>>,
}

Fields

applier_version: Version

seqno_from: SeqNo

seqno_to: SeqNo

walltime_ms: u64

latest_rollup_key: PartialRollupKey

rollups: Vec<StateFieldDiff<SeqNo, HollowRollup>>

hostname: Vec<StateFieldDiff<(), String>>

last_gc_req: Vec<StateFieldDiff<(), SeqNo>>

leased_readers: Vec<StateFieldDiff<LeasedReaderId, LeasedReaderState<T>>>

critical_readers: Vec<StateFieldDiff<CriticalReaderId, CriticalReaderState<T>>>

writers: Vec<StateFieldDiff<WriterId, WriterState<T>>>

schemas: Vec<StateFieldDiff<SchemaId, EncodedSchemas>>

since: Vec<StateFieldDiff<(), Antichain<T>>>

legacy_batches: Vec<StateFieldDiff<HollowBatch<T>, ()>>

hollow_batches: Vec<StateFieldDiff<SpineId, Arc<HollowBatch<T>>>>

spine_batches: Vec<StateFieldDiff<SpineId, ThinSpineBatch<T>>>

merges: Vec<StateFieldDiff<SpineId, ThinMerge<T>>>

Implementations

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

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

where B: BufMut,

pub fn decode(build_version: &Version, buf: Bytes) -> Self

impl<T: Timestamp + Codec64> StateDiff<T>

pub fn new( applier_version: Version, seqno_from: SeqNo, seqno_to: SeqNo, walltime_ms: u64, latest_rollup_key: PartialRollupKey, ) -> Self

pub fn referenced_batches( &self, ) -> impl Iterator<Item = StateFieldValDiff<&HollowBatch<T>>>

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

pub fn from_diff(from: &State<T>, to: &State<T>) -> Self

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

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

pub fn validate_roundtrip<K, V, D>( metrics: &Metrics, from_state: &TypedState<K, V, T, D>, diff: &Self, to_state: &TypedState<K, V, T, D>, ) -> Result<(), String>

where K: Codec + Debug, V: Codec + Debug, D: Semigroup + Codec64,

Trait Implementations

impl<T: Clone> Clone for StateDiff<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for StateDiff<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for StateDiff<T>

fn eq(&self, other: &StateDiff<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: Timestamp + Codec64> RustType<ProtoStateDiff> for StateDiff<T>

fn into_proto(&self) -> ProtoStateDiff

Convert a Self into a Proto value.

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

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

impl<T> StructuralPartialEq for StateDiff<T>