Struct ConsolidatingColumnBuilder 

pub struct ConsolidatingColumnBuilder<D, T, R>
where
    D: Columnar,
    T: Columnar,
    R: Columnar,
{
    staging: Vec<(D, T, R)>,
    staging_cap: usize,
    cur_d: D::Container,
    cur_t: T::Container,
    cur_r: R::Container,
    cur_len: usize,
    pending: VecDeque<Column<(D, T, R)>>,
    finished: Option<Column<(D, T, R)>>,
}

A container builder that consolidates (D, T, R) updates and emits Column<(D, T, R)>.

Stages updates in an AoS Vec for in-place consolidation, then drains consolidated rows in DRAIN_CHUNK_ROWS-sized chunks (three sequential per-column passes per chunk) into SoA sub-containers, flushing whenever the accumulator hits the flush threshold (90% of OUTPUT_TARGET_WORDS). Flushed accumulators are written into aligned Vec<u64> (via indexed::encode, no zero-fill) and queued as Column::Align. The trailing partial on finish ships as Column::Typed.

Does not maintain FIFO ordering (consolidation reorders updates).

Fields

staging: Vec<(D, T, R)>

AoS staging buffer for in-place consolidation. Cap = Self::staging_cap.

staging_cap: usize

Capacity of staging. Drain triggers when staging.len() hits this.

cur_d: D::Container

SoA accumulator, one sub-container per column.

cur_t: T::Container

cur_r: R::Container

cur_len: usize

Number of (D, T, R) tuples currently in cur_*.

pending: VecDeque<Column<(D, T, R)>>

Finished columns ready to ship.

finished: Option<Column<(D, T, R)>>

The currently extracted/finished column.

Implementations

impl<D, T, R> ConsolidatingColumnBuilder<D, T, R>

where D: Data + Columnar, T: Data + Columnar, R: Semigroup + Columnar + 'static, (D, T, R): Columnar<Container = (D::Container, T::Container, R::Container)>,

fn consolidate_and_drain(&mut self, grain: usize)

Sort and consolidate staging, then drain a multiple-of-grain prefix into the SoA accumulator. Pass 1 to drain everything (used by finish). Pushes in chunks of DRAIN_CHUNK_ROWS and flushes mid-drain whenever the accumulator hits FLUSH_THRESHOLD_WORDS, so a single drain can mint several aligned containers when the prefix is large.

fn flush_aligned(&mut self)

Serialize the SoA accumulator into a Column::Align via indexed::encode, which builds the buffer with Vec::push/extend_from_slice so no memory is initialized twice.

Trait Implementations

impl<D, T, R> ContainerBuilder for ConsolidatingColumnBuilder<D, T, R>

where D: Data + Columnar, T: Data + Columnar, R: Semigroup + Columnar + 'static, (D, T, R): Columnar<Container = (D::Container, T::Container, R::Container)>, <(D, T, R) as Columnar>::Container: Clone,

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

The container type we’re building.

fn extract(&mut self) -> Option<&mut Self::Container>

Extract assembled containers, potentially leaving unfinished data behind. Can be called repeatedly, for example while the caller can send data.

fn finish(&mut self) -> Option<&mut Self::Container>

Extract assembled containers and any unfinished data. Should be called repeatedly until it returns None.

fn relax(&mut self)

Indicates a good moment to release resources.

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

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

fn default() -> Self

Returns the “default value” for a type.

impl<D, T, R> PushInto<(D, T, R)> for ConsolidatingColumnBuilder<D, T, R>

where D: Data + Columnar, T: Data + Columnar, R: Semigroup + Columnar + 'static, (D, T, R): Columnar<Container = (D::Container, T::Container, R::Container)>,

fn push_into(&mut self, item: (D, T, R))

Push an element into the staging buffer; consolidate + drain when full.