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 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.

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 + Default, 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>>, for<'a> <(D, T, R) as Columnar>::Container: Push<&'a (D, T, R)>, for<'a, 'a> <D as Columnar>::Container: Push<Ref<'a, D>> + Push<&'a D>, for<'a, 'a> <T as Columnar>::Container: Push<Ref<'a, T>> + Push<&'a T>, for<'a, 'a> <R as Columnar>::Container: Push<Ref<'a, R>> + Push<&'a R>,

Per-chunk merge and extract for Column-shaped sorted 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.

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

Merge items from sorted inputs into self, advancing positions.

Mirrors the dispatch shape used by the merge-batcher framework:

• 0: no-op
• 1: bulk copy (or swap, if self is empty and *pos == 0)
• 2: merge two sorted streams, with diff consolidation on equal (data, time) keys and gallop bulk-copy of long single-side runs.

Returns true if the merge stopped because the amortized ship-threshold check inside the inner loop fired (the caller should ship self before the next call). Returns false if the merge stopped because at least one input was exhausted at its position (the caller should refill that side; self may still be at capacity from accumulation across short calls and the caller should also check at_capacity in that case).

The 0- and 1-input dispatches always return false: 0 does no work, 1 is a bulk copy or swap that runs to completion.

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 (times beyond upper, retained for the next round) and ship (times not beyond upper, sealed into the output batch). Updates frontier with the times of kept records.

The caller invokes extract repeatedly until *position >= self.len(), swapping out a full output buffer between calls. This shape exists because the framework only checks at_capacity() between calls, so without an inner-loop yield a single call could quietly produce oversized output chunks.

impl<C: Columnar> Column<C>

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<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<'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<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<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.