Struct ColumnMergeBatcher 

pub struct ColumnMergeBatcher<D, T, R>
where
    D: Columnar,
    T: Columnar,
    R: Columnar,
{ /* private fields */ }

Drives the merge-batcher over Column chunks routed through a ColumnPager.

Chains hold PagedColumn entries rather than resident Columns, so each insert / merge / extract step can hand its output to the pager and store whatever the policy returns (resident, paged, or compressed). Reads during merge materialize lazily via FetchIter.

Resolves its pager lazily per call via column_pager::global_pager, so late-arriving dyncfg updates (e.g. enable_column_paged_batcher flipping on after the batcher was constructed) take effect without rebuilding the operator. Tests may override that lookup via Self::set_pager.

Implementations

impl<D, T, R> ColumnMergeBatcher<D, T, R>

where D: Columnar, T: Columnar, R: Columnar,

pub fn set_pager(&mut self, pager: ColumnPager)

Pin the pager this batcher uses, overriding the thread-local lookup. Mainly for tests; production should leave the override unset so dyncfg-driven re-installs take effect immediately.

Trait Implementations

impl<D, T, R> Batcher for ColumnMergeBatcher<D, T, R>

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

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

Type produced by the batcher, and also the type it consumes.

type Time = T

Times at which batches are formed.

fn new(logger: Option<Logger>, operator_id: usize) -> Self

Allocates a new empty batcher.

fn seal( &mut self, upper: Antichain<Self::Time>, ) -> (Vec<Self::Output>, Description<Self::Time>)

Returns all updates not greater or equal to an element of upper, as a sorted and consolidated chain together with the description that bounds them.

fn frontier(&mut self) -> AntichainRef<'_, Self::Time>

Returns the lower envelope of contained update times.

impl<D, T, R> Drop for ColumnMergeBatcher<D, T, R>

where D: Columnar, T: Columnar, R: Columnar,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

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.