Trait Merger 

pub trait Merger: Default {
    type Chunk: Default;
    type Time;

    // Required methods
    fn merge(
        &mut self,
        list1: Vec<Self::Chunk>,
        list2: Vec<Self::Chunk>,
        output: &mut Vec<Self::Chunk>,
        stash: &mut Vec<Self::Chunk>,
    );
    fn extract(
        &mut self,
        merged: Vec<Self::Chunk>,
        upper: AntichainRef<'_, Self::Time>,
        frontier: &mut Antichain<Self::Time>,
        readied: &mut Vec<Self::Chunk>,
        kept: &mut Vec<Self::Chunk>,
        stash: &mut Vec<Self::Chunk>,
    );
    fn len(chunk: &Self::Chunk) -> usize;

    // Provided method
    fn allocation(_chunk: &Self::Chunk) -> (usize, usize, usize) { ... }
}

A trait to describe interesting moments in a merge batcher.

Required Associated Types

type Chunk: Default

The internal representation of chunks of data.

type Time

The type of time in frontiers to extract updates.

Required Methods

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>, readied: &mut Vec<Self::Chunk>, kept: &mut Vec<Self::Chunk>, stash: &mut Vec<Self::Chunk>, )

Extract ready updates based on the upper frontier.

fn len(chunk: &Self::Chunk) -> usize

The number of updates in a chunk.

Drives the geometric ladder (chains are weighed by summed updates, not chunk counts, since regrading decouples the two) and the records field of the size logger.

Provided Methods

fn allocation(_chunk: &Self::Chunk) -> (usize, usize, usize)

Backing-allocation figures for a chunk: (size, capacity, allocations), for the size logger’s memory telemetry.

Defaults to zero — most chunk types do not track this. Override to report real figures (e.g. Materialize’s memory accounting).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<C> Merger for ChunkMerger<C>

where C: Chunk + Default + 'static, C::Time: Clone + PartialOrder + 'static,

type Chunk = C

type Time = <C as Chunk>::Time

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

where D: Ord + Clone + 'static, T: Ord + Clone + PartialOrder + 'static, R: Semigroup + 'static,

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

type Time = T