Struct ColumnMerger 

pub struct ColumnMerger<D, T, R> {
    _marker: PhantomData<(D, T, R)>,
}

Counterpart to ColInternalMerger (which merges ColumnationStack chunks). Drives the merge batcher with Column-shaped chunks, no columnation detour, by way of the inherent merge_from / extract methods on Column<(D, T, R)> below.

Fields

_marker: PhantomData<(D, T, R)>

Trait Implementations

impl<D, T, R> Default for ColumnMerger<D, T, R>

fn default() -> Self

Returns the “default value” for a type.

impl<D, T, R> Merger for ColumnMerger<D, T, R>

where D: Columnar + Default + 'static, for<'a> Ref<'a, D>: Copy + Ord, T: Columnar + Default + Clone + Ord + PartialOrder + 'static, for<'a> Ref<'a, T>: Copy + Ord, R: Columnar + Default + Semigroup + for<'a> Semigroup<Ref<'a, R>> + 'static, 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>,

Merger impl driving MergeBatcher over Column-shaped chunks.

merge walks two sorted chains of chunks in lockstep, calling Column::merge_from to consume up to one ship-threshold’s worth of input per pass and shipping result to output whenever it crosses at_capacity. Exhausted input chunks are reset and pushed to stash for reuse. The drain phase appends remaining full chunks to output directly, with no per-element copy.

extract walks each chunk via Column::extract, partitioning records into kept (times beyond upper) and ship (sealed into the output batch); both grow chunk-by-chunk under the same at_capacity ship signal.

type Time = T

The type of time in frontiers to extract updates.

type Chunk = Column<(D, T, R)>

The internal representation of chunks of data.

fn merge( &mut self, list1: Vec<Self::Chunk>, list2: Vec<Self::Chunk>, output: &mut Vec<Self::Chunk>, stash: &mut Vec<Self::Chunk>, )

Merge chains into an output chain.

fn extract( &mut self, merged: Vec<Self::Chunk>, upper: AntichainRef<'_, Self::Time>, frontier: &mut Antichain<Self::Time>, ship: &mut Vec<Self::Chunk>, kept: &mut Vec<Self::Chunk>, stash: &mut Vec<Self::Chunk>, )

Extract ready updates based on the upper frontier.

fn account(chunk: &Self::Chunk) -> (usize, usize, usize, usize)

Account size and allocation changes. Returns a tuple of (records, size, capacity, allocations).