Struct ChunkState 

pub struct ChunkState { /* private fields */ }

Unified chunk state tracking metadata for factorized execution.

This replaces scattered state tracking with a centralized structure that is updated incrementally rather than recomputed.

Key Features

• Cached multiplicities: Computed once per chunk, reused for all aggregates
• Selection integration: Supports lazy filtering without data copying
• Generation tracking: Enables cache invalidation on structure changes

Implementations

impl ChunkState

pub fn flat(row_count: usize) -> Self

Creates a new flat chunk state.

pub fn unflat(level_count: usize, logical_rows: usize) -> Self

Creates an unflat (factorized) chunk state.

pub fn factorization_state(&self) -> FactorizationState

Returns the factorization state.

pub fn is_flat(&self) -> bool

Returns true if this chunk is flat.

pub fn is_factorized(&self) -> bool

Returns true if this chunk is factorized (unflat).

pub fn logical_row_count(&self) -> usize

Returns the logical row count.

If a selection is active, this returns the base logical row count (selection count must be computed separately with multiplicities).

pub fn level_count(&self) -> usize

Returns the number of factorization levels.

pub fn generation(&self) -> u64

Returns the current generation (for cache validation).

pub fn selection(&self) -> Option<&FactorizedSelection>

Returns the selection, if any.

pub fn selection_mut(&mut self) -> &mut Option<FactorizedSelection>

Returns mutable access to the selection.

pub fn set_selection(&mut self, selection: FactorizedSelection)

Sets the selection.

pub fn clear_selection(&mut self)

Clears the selection.

pub fn set_state(&mut self, state: FactorizationState)

Updates the state (e.g., after adding a level).

pub fn invalidate_cache(&mut self)

Invalidates cached data (call when structure changes).

pub fn get_or_compute_multiplicities<F>(&mut self, compute: F) -> Arc<[usize]>

where F: FnOnce() -> Vec<usize>,

Gets cached multiplicities, or computes and caches them.

This is the key optimization: multiplicities are computed once and reused for all aggregates (COUNT, SUM, AVG, etc.).

Arguments

• compute - Function to compute multiplicities if not cached

Example

let mults = state.get_or_compute_multiplicities(|| {
    chunk.compute_path_multiplicities_impl()
});

pub fn cached_multiplicities(&self) -> Option<&Arc<[usize]>>

Returns cached multiplicities without computing.

Returns None if not yet computed.

pub fn set_cached_multiplicities(&mut self, mults: Arc<[usize]>)

Sets the cached multiplicities directly.

Useful when multiplicities are computed externally.

Trait Implementations

impl Clone for ChunkState

fn clone(&self) -> ChunkState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChunkState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ChunkState

fn default() -> Self

Returns the “default value” for a type.