Struct HollowBatchPart

pub struct HollowBatchPart<T> {
    pub key: PartialBatchKey,
    pub encoded_size_bytes: usize,
    pub key_lower: Vec<u8>,
    pub structured_key_lower: Option<LazyProto<ProtoArrayData>>,
    pub stats: Option<LazyPartStats>,
    pub ts_rewrite: Option<Antichain<T>>,
    pub diffs_sum: Option<[u8; 8]>,
    pub format: Option<BatchColumnarFormat>,
    pub schema_id: Option<SchemaId>,
    pub deprecated_schema_id: Option<SchemaId>,
}

A subset of a HollowBatch corresponding 1:1 to a blob.

Fields

key: PartialBatchKey

Pointer usable to retrieve the updates.

encoded_size_bytes: usize

The encoded size of this part.

key_lower: Vec<u8>

A lower bound on the keys in the part. (By default, this the minimum possible key: vec![].)

structured_key_lower: Option<LazyProto<ProtoArrayData>>

A lower bound on the keys in the part, stored as structured data.

stats: Option<LazyPartStats>

Aggregate statistics about data contained in this part.

ts_rewrite: Option<Antichain<T>>

A frontier to which timestamps in this part are advanced on read, if set.

A value of Some([T::minimum()]) is functionally the same as None, but we maintain the distinction between the two for some internal sanity checking of invariants as well as metrics. If this ever becomes an issue, everything still works with this as just Antichain<T>.

diffs_sum: Option<[u8; 8]>

A Codec64 encoded sum of all diffs in this part, if known.

This is None if this part was written before we started storing this information, or if it was written when the dyncfg was off.

It could also make sense to model this as part of the pushdown stats, if we later decide that’s of some benefit.

format: Option<BatchColumnarFormat>

Columnar format that this batch was written in.

This is None if this part was written before we started writing structured columnar data.

schema_id: Option<SchemaId>

The schemas used to encode the data in this batch part.

Or None for historical data written before the schema registry was added.

deprecated_schema_id: Option<SchemaId>

ID of a schema that has since been deprecated and exists only to cleanly roundtrip.

Trait Implementations

impl<T: Clone> Clone for HollowBatchPart<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for HollowBatchPart<T>

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

Formats the value using the given formatter.

impl<T: Ord> Ord for HollowBatchPart<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,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for HollowBatchPart<T>

fn eq(&self, other: &HollowBatchPart<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 HollowBatchPart<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> Serialize for HollowBatchPart<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for HollowBatchPart<T>

impl<T> StructuralPartialEq for HollowBatchPart<T>