Struct mz_persist_client::internal::state::HollowBatch

pub struct HollowBatch<T> {
    pub desc: Description<T>,
    pub len: usize,
    pub(crate) parts: Vec<RunPart<T>>,
    pub(crate) run_splits: Vec<usize>,
    pub(crate) run_meta: Vec<RunMeta>,
}

A Batch but with the updates themselves stored externally.

Fields

desc: Description<T>

Describes the times of the updates in the batch.

len: usize

The number of updates in the batch.

parts: Vec<RunPart<T>>

Pointers usable to retrieve the updates.

run_splits: Vec<usize>

Runs of sequential sorted batch parts, stored as indices into parts. ex.

    parts=[p1, p2, p3], runs=[]     --> run  is  [p1, p2, p2]
    parts=[p1, p2, p3], runs=[1]    --> runs are [p1] and [p2, p3]
    parts=[p1, p2, p3], runs=[1, 2] --> runs are [p1], [p2], [p3]

run_meta: Vec<RunMeta>

Run-level metadata: the first entry has metadata for the first run, and so on. If there’s no corresponding entry for a particular run, it’s assumed to be RunMeta::default().

Implementations

impl<T: Timestamp + Codec64 + Sync> HollowBatch<T>

pub fn part_stream<'a>( &'a self, shard_id: ShardId, blob: &'a dyn Blob, metrics: &'a Metrics, ) -> impl Stream<Item = Result<Cow<'a, BatchPart<T>>, MissingBlob>> + 'a

impl<T> HollowBatch<T>

pub(crate) fn new( desc: Description<T>, parts: Vec<RunPart<T>>, len: usize, run_meta: Vec<RunMeta>, run_splits: Vec<usize>, ) -> Self

Construct an in-memory hollow batch from the given metadata.

This method checks that runs is a sequence of valid indices into parts. The caller is responsible for ensuring that the defined runs are valid.

len should represent the number of valid updates in the referenced parts.

pub(crate) fn new_run( desc: Description<T>, parts: Vec<RunPart<T>>, len: usize, ) -> Self

Construct a batch of a single run with default metadata. Mostly interesting for tests.

pub(crate) fn empty(desc: Description<T>) -> Self

An empty hollow batch, representing no updates over the given desc.

pub(crate) fn runs(&self) -> impl Iterator<Item = (&RunMeta, &[RunPart<T>])>

pub(crate) fn inline_bytes(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn part_count(&self) -> usize

pub fn encoded_size_bytes(&self) -> usize

The sum of the encoded sizes of all parts in the batch.

impl<T: Timestamp + TotalOrder> HollowBatch<T>

pub(crate) fn rewrite_ts( &mut self, frontier: &Antichain<T>, new_upper: Antichain<T>, ) -> Result<(), String>

Trait Implementations

impl<T: Clone> Clone for HollowBatch<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for HollowBatch<T>

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

Formats the value using the given formatter.

impl<T: Ord> Ord for HollowBatch<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for HollowBatch<T>

fn eq(&self, other: &HollowBatch<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: Ord> PartialOrd for HollowBatch<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Timestamp + Codec64> RustType<ProtoHollowBatch> for HollowBatch<T>

fn into_proto(&self) -> ProtoHollowBatch

Convert a Self into a Proto value.

fn from_proto(proto: ProtoHollowBatch) -> 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: Serialize> Serialize for HollowBatch<T>

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

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for HollowBatch<T>

impl<T> StructuralPartialEq for HollowBatch<T>