Enum ColChunk 

pub enum ColChunk<U: ColumnarUpdate> {
    Resident(Rc<UpdatesTyped<U>>),
    Paged(Rc<PagedChunk<U>>),
}

A sorted, consolidated columnar trie of ((key, val), time, diff): resident, or paged to backing storage.

Variants

Resident(Rc<UpdatesTyped<U>>)

The trie in memory, shared via Rc.

Paged(Rc<PagedChunk<U>>)

Spilled out: resident bounds + a fetch handle (and a fill-once cache).

Implementations

impl<U: ColumnarUpdate> ColChunk<U>

pub fn from_trie(updates: UpdatesTyped<U>) -> Self

Wrap an already sorted, consolidated trie as a resident chunk. The chunker uses this to hand its melded UpdatesTyped blobs to the Chunk harness.

pub fn updates_mut(&mut self) -> &mut UpdatesTyped<U>

Mutable access to the backing trie (materializing if paged, cloning if the Rc is shared), for builder closures that populate a chunk in place — e.g. reduce_abelian.

Trait Implementations

impl<U: ColumnarUpdate> Accountable for ColChunk<U>

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<U: ColumnarUpdate> Chunk for ColChunk<U>

where U::Time: 'static,

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

Trie-native binary merge of the two deques’ front chunks through their shared horizon, via trie_merger::merge_pair: it merges one input fully and a prefix of the other (the survey/write_layer bulk range-copy), leaving the survivor’s suffix as a cursor we materialize with trie_merger::suffix_chunk and push back. The harness re-invokes.

One pair per call (not a resumable drain): merge_pair surveys each batch from index 0, so re-passing a large survivor would re-survey its whole body every call (quadratic). Re-materializing the suffix as a standalone chunk keeps each survey bounded by the shrinking remainder instead.

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

Partition the front chunk by frontier (keep >=, ship <), folding kept times into residual, via trie_merger::extract. One chunk per call.

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

Advance times by frontier, consolidating each complete (key, val) group and withholding the last unless done.

Streams the input one chunk at a time, holding at most a single chunk plus the withheld trailing (key, val) group (the carry) — it never pulls the whole chain into core. Cross-chunk consolidation happens only where a (key, val) straddles a boundary: the (un-advanced) carry is melded onto the next chunk’s head, a sorted-chain meld that just stitches that one group. [advance_trie] then advances and consolidates the time runs within each chunk (keys / vals / diffs stay columnar refs, no global re-sort). Grading the emitted chunks is left to Chunk::settle.

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

Maximal packing via the harness pack: coalesce by melding the next trie onto the carry (adjacent chunks of a sorted, consolidated chain, so meld’s “strictly greater first triple” precondition holds), split with trie_merger::split_at, and seal through [seal_chunk] (the spill point — pages a committed chunk when a spiller is installed).

const TARGET: usize = TARGET

The intended maximum chunk size.

type Time = <<ColumnarLayout<U> as Layout>::TimeContainer as BatchContainer>::Owned

The timestamp type of the chunk’s updates.

fn len(&self) -> usize

The number of updates in the chunk.

impl<U: ColumnarUpdate> Clone for ColChunk<U>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<U: ColumnarUpdate> Consolidate for ColChunk<U>

fn len(&self) -> usize

The number of elements in the container.

fn clear(&mut self)

Clear the container.

fn consolidate_into(&mut self, target: &mut Self)

Sort and consolidate self into target.

impl<U: ColumnarUpdate> Default for ColChunk<U>

fn default() -> Self

Returns the “default value” for a type.

impl<U: ColumnarUpdate> Navigable for ColChunk<U>

where U::Time: 'static,

type Cursor = ColChunkCursor<U>

The cursor type.

fn cursor(&self) -> Self::Cursor

Acquire a cursor suitable for the instance.

impl<U: ColumnarUpdate> NavigableChunk for ColChunk<U>

where U::Time: 'static,

fn bounds( &self, ) -> ((<Self::Cursor as Cursor>::Key<'_>, <Self::Cursor as Cursor>::Val<'_>, <Self::Cursor as Cursor>::TimeGat<'_>), (<Self::Cursor as Cursor>::Key<'_>, <Self::Cursor as Cursor>::Val<'_>, <Self::Cursor as Cursor>::TimeGat<'_>))

The first and last (key, val, time) triples in the chunk.

impl<U: ColumnarUpdate> PushInto<((<U as ColumnarUpdate>::Key, <U as ColumnarUpdate>::Val), <U as ColumnarUpdate>::Time, <U as ColumnarUpdate>::Diff)> for ColChunk<U>

fn push_into(&mut self, item: ((U::Key, U::Val), U::Time, U::Diff))

Push item into self.

impl<U: ColumnarUpdate> SizableContainer for ColChunk<U>

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.

impl<U: ColumnarUpdate> WithLayout for ColChunk<U>

type Layout = ColumnarLayout<U>

The layout.