Enum ColumnBody 

pub enum ColumnBody<C: Columnar> {
    Typed(C::Container),
    Words(Vec<u64>),
}

A sorted, consolidated run of columnar records, typed while written and serialized once read back from a store.

Variants

Typed(C::Container)

The typed containers, which is what a body is while it is written to.

Words(Vec<u64>)

The serialized form, as a store hands a body back: u64-aligned words holding the flat columnar::bytes::indexed encoding of the typed containers. It is the only serialized form a body has.

Implementations

impl<D, T, R> ColumnBody<(D, T, R)>

where D: Columnar, for<'a> Ref<'a, D>: Copy + Ord, T: Columnar + Default + Clone + PartialOrder, for<'a> Ref<'a, T>: Copy + Ord, R: Columnar + Default + Semigroup + for<'a> Semigroup<Ref<'a, R>>,

Per-chunk merge and extract for sorted ColumnBody chunks.

These are the building blocks that [Merger for ColumnMerger] orchestrates over chains of chunks. They’re inherent methods rather than a trait impl so the merger can call them without going through any wrapper indirection. The output side of each is written to, so a serialized output body is materialized first (see ColumnBody::typed_mut).

pub fn merge_from( &mut self, others: &mut [Self], positions: &mut [usize], ) -> bool

Merge items from sorted inputs into self, advancing positions. See merge_from.

pub fn extract( &mut self, position: &mut usize, upper: AntichainRef<'_, T>, frontier: &mut Antichain<T>, keep: &mut Self, ship: &mut Self, )

Partition records starting at *position into keep and ship. See extract.

impl<C: Columnar> ColumnBody<C>

pub fn borrow(&self) -> BorrowedOf<'_, C>

Borrows the body as a columnar view.

The serialized form rebuilds its view from the encoded header on every call, so a caller that reads more than one record hoists the view out of its loop.

pub fn len(&self) -> usize

The number of records.

pub fn is_empty(&self) -> bool

True when the body holds no records.

pub fn length_in_bytes(&self) -> usize

The size of the serialized form in bytes, whether or not the body is serialized.

pub fn write_into<W: Write>(&self, writer: &mut W) -> Result<()>

Writes the serialized form, exactly ColumnBody::length_in_bytes bytes of it.

The serialized form is written as it is, so a body that went through a store and back round-trips byte-identically.

pub fn typed_mut(&mut self) -> &mut C::Container

The typed containers, for writing to.

A serialized body is copied into typed containers first, since the serialized form cannot take pushes. The copy is a bulk per-leaf extension.

pub fn into_typed(self) -> C::Container

The typed containers, taking a typed body as it is and copying a serialized one.

pub fn duplicate(&self) -> Self

An owned copy in the same form: serialized words are cloned, typed containers are copied by bulk per-leaf extension.

pub fn clear(&mut self)

Empties the body, keeping a typed body’s allocations for refilling.

A serialized body owns no typed allocation, so it becomes an empty typed body.

pub fn at_capacity(&self) -> bool

True once the body is at the ship size the builder and merger cut chunks at.

A serialized body is complete, so it is always at capacity.

Trait Implementations

impl<C: Columnar> Accountable for ColumnBody<C>

fn record_count(&self) -> i64

The number of records

fn is_empty(&self) -> bool

Determine if this contains any updates, corresponding to update_count() == 0. It is a correctness error for this to be anything other than self.record_count() == 0.

impl<KBC, VBC, K, V, T, R> BuilderInput<KBC, VBC> for ColumnBody<((K, V), T, R)>

where K: Columnar, V: Columnar, T: Columnar + Timestamp + Lattice + Clone, R: Columnar + Ord + Semigroup + Clone, for<'a> Ref<'a, K>: Copy + Ord, for<'a> Ref<'a, V>: Copy + Ord, KBC: BatchContainer, VBC: BatchContainer, for<'a, 'b> KBC::ReadItem<'a>: PartialEq<Ref<'b, K>>, for<'a, 'b> VBC::ReadItem<'a>: PartialEq<Ref<'b, V>>,

type Key<'a> = <<K as Columnar>::Container as Borrow>::Ref<'a>

Key portion

type Val<'a> = <<V as Columnar>::Container as Borrow>::Ref<'a>

Value portion

type Time = T

Time

type Diff = R

Diff

fn into_parts<'a>( item: Self::Item<'a>, ) -> (Self::Key<'a>, Self::Val<'a>, Self::Time, Self::Diff)

Split an item into separate parts.

fn key_eq(this: &Ref<'_, K>, other: KBC::ReadItem<'_>) -> bool

Test that the key equals a key in the layout’s key container.

fn val_eq(this: &Ref<'_, V>, other: VBC::ReadItem<'_>) -> bool

Test that the value equals a key in the layout’s value container.

fn key_val_upd_counts(chain: &[Self]) -> (usize, usize, usize)

Count the number of distinct keys, (key, val) pairs, and total updates.

impl<C: Columnar> Clone for ColumnBody<C>

where C::Container: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Columnar> Default for ColumnBody<C>

fn default() -> Self

Returns the “default value” for a type.

impl<C: Columnar> DrainContainer for ColumnBody<C>

type Item<'a> = <<C as Columnar>::Container as Borrow>::Ref<'a>

The type of elements when draining the container.

type DrainIter<'a> = IterOwn<<<C as Columnar>::Container as Borrow>::Borrowed<'a>>

Iterator type when draining the container.

fn drain(&mut self) -> Self::DrainIter<'_>

Returns an iterator that drains the contents of this container. Drain leaves the container in an undefined state.

impl<C: Columnar> From<Column<C>> for ColumnBody<C>

A body leaves the edge container behind: typed data moves, and channel bytes are relocated into owned words, since a body never holds a channel’s allocation.

fn from(column: Column<C>) -> Self

Converts to this type from the input type.

impl<C: Columnar> From<ColumnBody<C>> for Column<C>

A body goes back onto an edge as it is: both of its forms are forms of the edge container.

fn from(body: ColumnBody<C>) -> Self

Converts to this type from the input type.

impl<C: Columnar> MergeChunk<C> for ColumnBody<C>

fn typed(&mut self) -> &mut C::Container

The typed containers, for writing to.

fn view(&self) -> BorrowedOf<'_, C>

The chunk as a columnar view.

fn is_empty(&self) -> bool

True when the chunk holds no records.

impl<C: Columnar, T> PushInto<T> for ColumnBody<C>

where C::Container: Push<T>,

fn push_into(&mut self, item: T)

Push item into self.