Enum Column 

pub enum Column<C: Columnar> {
    Typed(C::Container),
    Bytes(Bytes),
    Align(Vec<u64>),
}

A container based on a columnar store, encoded in aligned bytes: the container on dataflow edges.

The type can represent typed data, bytes from Timely, or an aligned allocation. The name is singular to express that the preferred format is Column::Align. The Column::Typed variant is used to construct the container, and it owns potentially multiple columns of data.

Data at rest behind an edge, in a merge batcher’s chains, a spill-backed chunk, or a batch builder, is a body::ColumnBody instead, which has no channel-bytes form.

Variants

Typed(C::Container)

The typed variant of the container.

Bytes(Bytes)

The binary variant of the container.

Align(Vec<u64>)

Relocated, aligned binary data, if Bytes doesn’t work for some reason.

Reasons could include misalignment, cloning of data, or wanting to release the Bytes as a scarce resource.

Vec<u64> guarantees u64 alignment for the contained bytes.

Implementations

impl<D, T, R> Column<(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>>,

The same merge and extract for the column pager’s Column chunks.

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> Column<C>

pub fn clear(&mut self)

Empties the column, retaining the Typed variant’s allocation so the caller can refill it.

columnar::Clear clears the typed container in place without releasing its capacity. The serialized variants (Bytes/Align) own no reusable typed buffer, so they are reset to an empty Typed.

pub fn is_empty(&self) -> bool

True when the column holds no records.

The Typed variant answers from the container itself. The serialized variants have to reconstruct their borrowed view to reach a length, so there this costs as much as Column::borrow.

pub fn borrow(&self) -> <C::Container as Borrow>::Borrowed<'_>

Borrows the container as a reference.

Trait Implementations

impl<C: Columnar> Accountable for Column<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 Column<((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 Column<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> ContainerBytes for Column<C>

fn from_bytes(bytes: Bytes) -> Self

Wrap bytes as Self.

fn length_in_bytes(&self) -> usize

The number of bytes required to serialize the data.

fn into_bytes<W: Write>(&self, writer: &mut W)

Writes the binary representation into writer.

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

fn default() -> Self

Returns the “default value” for a type.

impl<C: Columnar> DrainContainer for Column<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<D, T1, T2, R> Enter<T1, T2> for Column<(D, T1, R)>

where D: Columnar, T1: Columnar + Timestamp, T2: Columnar + Refines<T1>, R: Columnar, (D, T1, R): Columnar<Container = (D::Container, T1::Container, R::Container)>, (D, T2, R): Columnar<Container = (D::Container, T2::Container, R::Container)>, for<'a> D::Container: Push<Ref<'a, D>>, for<'a> T2::Container: Push<&'a T2>, for<'a> R::Container: Push<Ref<'a, R>>,

Re-encodes a column’s times into a refining timestamp, so a columnar collection can enter an iterative scope.

type InnerContainer = Column<(D, T2, R)>

The resulting container type.

fn enter(self) -> Self::InnerContainer

Update timestamps from T1 to T2.

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 Column<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<'a, D, T, R> PushInto<&'a mut Column<(D, T, R)>> for Chunker<ColumnationStack<(D, T, R)>>

where D: Columnar + Columnation, for<'b> Ref<'b, D>: Ord + Copy, T: Columnar + Columnation, for<'b> Ref<'b, T>: Ord + Copy, R: Columnar + Columnation + Semigroup + for<'b> Semigroup<Ref<'b, R>>, for<'b> Ref<'b, R>: Ord,

fn push_into(&mut self, container: &'a mut Column<(D, T, R)>)

Push item into self.

impl<'a, D, T, R> PushInto<&'a mut Column<(D, T, R)>> for ColumnChunker<(D, T, R)>

where D: Columnar, for<'b> Ref<'b, D>: Copy + Ord, T: Columnar, for<'b> Ref<'b, T>: Copy + Ord, R: Columnar + Default + Semigroup + for<'b> Semigroup<Ref<'b, R>>, for<'b> Ref<'b, R>: Ord, for<'b> <D as Columnar>::Container: Push<Ref<'b, D>>, for<'b> <T as Columnar>::Container: Push<Ref<'b, T>>, for<'b> <R as Columnar>::Container: Push<&'b R>,

fn push_into(&mut self, container: &'a mut Column<(D, T, R)>)

Push item into self.

impl<'a, D, T, R> PushInto<&'a mut Column<(D, T, R)>> for ChunkChunker<D, T, R>

where D: Columnar, T: Columnar, R: Columnar, ColumnChunker<(D, T, R)>: PushInto<&'a mut Column<(D, T, R)>>,

fn push_into(&mut self, item: &'a mut Column<(D, T, R)>)

Push item into self.

impl<'a, D, T, R> PushInto<&'a mut Column<(D, T, R)>> for PagedChunker<(D, T, R)>

where D: Columnar, T: Columnar, R: Columnar, ColumnChunker<(D, T, R)>: PushInto<&'a mut Column<(D, T, R)>>,

fn push_into(&mut self, item: &'a mut Column<(D, T, R)>)

Push item into self.

impl<D, T, R> PushInto<Column<(D, T, R)>> for ColumnMergeBatcher<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>>,

fn push_into(&mut self, chunk: Column<(D, T, R)>)

Accept an already-consolidated chunk from the upstream chunker, route it through the pager, and insert it as a singleton chain.

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

where C::Container: Push<T>,

fn push_into(&mut self, item: T)

Push item into self.

impl<D, T, R> ResultsIn<<T as Timestamp>::Summary> for Column<(D, T, R)>

where D: Columnar, T: Columnar + Timestamp, R: Columnar, (D, T, R): Columnar<Container = (D::Container, T::Container, R::Container)>, for<'a> D::Container: Push<Ref<'a, D>>, for<'a> T::Container: Push<&'a T>, for<'a> R::Container: Push<Ref<'a, R>>,

Advances a column’s times by step, so a columnar collection can be a loop variable.

A time that the summary does not advance drops its record, so the data and diff columns cannot move across whole the way Enter moves them: a record’s position in one column has to keep matching its position in the others. The times are read and advanced first, and the rest is rebuilt only when the step actually dropped something.

fn results_in(self, step: &T::Summary) -> Self

Advance times in the container by step.

impl<C: Columnar> SizableContainer for Column<C>

fn at_capacity(&self) -> bool

Indicates that the container is “full” and should be shipped.

fn ensure_capacity(&mut self, _stash: &mut Option<Self>)

Restores self to its desired capacity, if it has one.