Enum ColumnChunk 

pub enum ColumnChunk<D: Columnar, T: Columnar, R: Columnar> {
    Resident(Rc<Column<(D, T, R)>>, u8),
    Spilled(Rc<SpilledBody<D>>),
}

A sorted, consolidated run of (D, T, R) updates, resident or spilled.

Every chunk carries a generational depth, fixed at creation: fresh chunks are depth 0, a merge output is one generation past its deepest input (saturating at u8::MAX, where remerged long-lived chunks stay), and rewrites within a generation (extract, advance, settle coalescing) preserve depth. At spill time the depth becomes the pool’s ChunkHints, so repeatedly merged (older, colder) data lands in deeper eviction bands.

Variants

Resident(Rc<Column<(D, T, R)>>, u8)

Body on the heap, shared via Rc, with its generational depth.

Spilled(Rc<SpilledBody<D>>)

Body in the pool. See SpilledBody.

Implementations

impl<D: Columnar, T: Columnar, R: Columnar> ColumnChunk<D, T, R>

pub fn from_column(column: Column<(D, T, R)>) -> Self

Wrap a sorted, consolidated, non-empty column as a resident chunk of the youngest generation.

pub fn into_column(self) -> Column<(D, T, R)>

The body as an owned column. A spilled body is copied out of the pool within this call. A shared resident body is copied.

pub fn is_spilled(&self) -> bool

True when the body lives in the pool.

Trait Implementations

impl<D: Columnar, T: Columnar, R: Columnar> Accountable for ColumnChunk<D, T, R>

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<D, T, R> Chunk for ColumnChunk<D, T, R>

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

const TARGET: usize = 65536

A nominal record count for the harness’s fuel and ladder accounting, not a bound. Actual chunk sizing is by serialized bytes: merge and extract cut output at the Column ship threshold, and settle grades by at_commit_size, so a chunk of narrow records can hold more records than this and nothing here consults it.

fn merge( in1: &mut VecDeque<Self>, in2: &mut VecDeque<Self>, out: &mut VecDeque<Self>, )

Column::merge_from does the work: gallop bulk-copies for disjoint runs, semigroup consolidation on equal (data, time), output cut at the ship threshold. A survivor pushed back untouched keeps its original form, in particular a spilled body is neither rebuilt nor re-spilled.

Fronts whose data ranges are disjoint never load at all: the resident fence entries decide, and the lower front moves to the output verbatim.

fn extract( input: &mut VecDeque<Self>, frontier: AntichainRef<'_, T>, residual: &mut Antichain<T>, keep: &mut VecDeque<Self>, ship: &mut VecDeque<Self>, )

Partition one front chunk by frontier, folding kept times into residual. One chunk per call, so the harness settles both sides between chunks. Output is cut at the ship threshold.

fn advance( input: &mut VecDeque<Self>, frontier: AntichainRef<'_, T>, done: bool, out: &mut VecDeque<Self>, )

Advance times by frontier and consolidate, withholding the trailing D group as the carry unless done (its updates may continue in input this call has not seen).

The input concatenates into the carry’s container, so a group that grows across many calls is appended to, not rebuilt. Each record is copied once on arrival, keeping the run linear. Advancing is lattice-monotone but not order-monotone, so each group’s advanced times are re-sorted before adjacent equal times fold.

fn settle(input: &mut VecDeque<Self>, done: bool, out: &mut VecDeque<Self>)

Grade by serialized bytes and commit: spilled chunks pass through untouched, resident chunks at the commit size commit as they are, and smaller neighbors coalesce until the accumulation reaches it. Committing is the spill hook (see ColumnChunk::commit). A sub-threshold tail is withheld as the carry unless done.

type Time = T

The timestamp type of the chunk’s updates.

fn len(&self) -> usize

The number of updates in the chunk.

impl<D: Columnar, T: Columnar, R: Columnar> Clone for ColumnChunk<D, T, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<D: Columnar, T: Columnar, R: Columnar> Default for ColumnChunk<D, T, R>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, T, R> UnloadChunk for ColumnChunk<(K, V), T, R>

where K: Columnar, for<'a> Ref<'a, K>: Copy + Ord, V: Columnar, for<'a> Ref<'a, V>: Copy + Ord, T: Columnar + Default + Timestamp + Lattice + Ord, for<'a> Ref<'a, T>: Copy + Ord, R: Columnar + Default + Semigroup + for<'a> Semigroup<Ref<'a, R>>,

type Staging = <((K, V), T, R) as Columnar>::Container

The flat columnar accumulation. Appends are bulk column-range copies, and a group straddling chunks stitches by plain concatenation.

type Probes<'a> = <<K as Columnar>::Container as Borrow>::Borrowed<'a>

A borrowed key column, e.g. of a Column<K> the consumer assembled from its sorted, deduplicated probe keys.

fn probe_count(probes: Self::Probes<'_>) -> usize

The number of probe keys.

fn locate(&self, probes: Self::Probes<'_>, probe_index: usize) -> Ordering

Where probes[probe_index] falls relative to this chunk’s key span: Less before the first key, Equal within [first, last], Greater past the last key.

fn extract_into( &self, probes: Self::Probes<'_>, probe_index: &mut usize, staging: &mut Self::Staging, )

Append this chunk’s updates for probes at and after *probe_index into staging, advancing *probe_index past every probe strictly below this chunk’s last key.

fn fetch_into(&self, staging: &mut Self::Staging)

Append the whole chunk into staging (the scan path).