Struct MaterializedBatch 

pub struct MaterializedBatch { /* private fields */ }

Column-oriented materialized batch.

Replaces Vec<Vec<Value>> in MaterializeState / DataCollectState / RollUpApplyState. Logical rows are addressed through num_rows() which honors an optional SelectionVector.

Implementations

impl MaterializedBatch

pub fn new(num_columns: usize, schema_fingerprint: u64) -> Self

Create an empty batch with num_columns columns.

pub fn with_schema_names(names: Arc<[String]>) -> Self

Create an empty batch with column names backing the fingerprint.

The fingerprint is derived from the column names so batches with the same column count but different schemas no longer collide. When names is empty the legacy column-count fingerprint applies.

pub fn set_schema_names(&mut self, names: Arc<[String]>)

Attach column names and recompute the fingerprint from them.

pub fn schema_names(&self) -> Option<&Arc<[String]>>

Borrow the column names backing the fingerprint, if any.

pub fn set_fingerprint(&mut self, fingerprint: u64)

Override the spill-compatibility token (used by run replay checks).

pub fn from_rows(rows: impl IntoIterator<Item = Vec<Value>>) -> Self

Build a batch from an iterator of rows.

The column count is inferred from the first row; all subsequent rows must have the same arity. The schema fingerprint is the hashed column count (placeholder until R3 threads the column-name fingerprint).

pub fn num_columns(&self) -> usize

Number of columns in the batch.

pub fn num_rows(&self) -> usize

Logical row count (length of the selection, or physical count).

pub fn is_empty(&self) -> bool

Whether the batch holds no logical rows.

pub fn schema_fingerprint(&self) -> u64

Schema fingerprint (spill-compatibility token).

pub fn append_row(&mut self, row: Vec<Value>)

Append one row, growing the column set from the first row’s arity.

Panics if a non-empty batch receives a row with a different column count; blocking operators feed rows of uniform arity so this invariant always holds.

pub fn append_column(&mut self, values: Vec<Value>)

Append one pre-built column of values.

The column length must match the existing row count (or define it when the batch is empty). Column count grows by one.

pub fn column(&self, i: usize) -> &ColumnBuffer

Borrow column i.

pub fn row(&self, i: usize) -> Vec<Value>

Logical row i (after selection) as an owned Vec<Value>.

pub fn rows(&self) -> impl Iterator<Item = Vec<Value>> + '_

Iterate logical rows as owned Vec<Value>.

pub fn to_rows(&self) -> Vec<Vec<Value>>

All logical rows as owned Vec<Vec<Value>> (borrow version).

pub fn into_rows(&mut self) -> Vec<Vec<Value>>

Drain the batch’s column buffers and return all logical rows without cloning values (transposes column buffers into row vectors). The batch is left empty but remains a valid zero-row state, so it can be called through a &mut reference owned by an operator state struct.

pub fn memory_size(&self) -> usize

Approximate in-memory footprint in bytes, for MemoryTracker accounting.

This is a conservative per-value heuristic plus per-column vector overhead; it intentionally does not try to measure heap payloads behind Value’s indirection (the row-oriented path used the same heuristic via MemoryBudget::estimate_row_memory).

pub fn set_selection(&mut self, sel: SelectionVector)

Install a selection vector over the physical rows.

The selection length must equal the logical row count (i.e. the value returned by num_rows() before installing it).

pub fn clear_selection(&mut self)

Clear any installed selection vector, reverting to identity.

pub fn refresh_fingerprint(&mut self)

Recompute the schema fingerprint from the current column count.

Legacy behavior preserved for batches without column names. Prefer Self::refresh_fingerprint_from_names for new code.

pub fn refresh_fingerprint_from_names(&mut self, names: &[String])

Recompute the fingerprint from explicit column names.

pub fn clear(&mut self)

Remove all rows while keeping the column layout and names.

pub fn column_slice(&self, i: usize) -> &[Value]

Borrow one column as a value slice.

pub fn slice_rows(&self, offset: usize, len: usize) -> MaterializedBatch

Copy a row range into a new batch (clamped to the logical size).

The selection, if any, is resolved so the output batch is always identity-selected. Schema names are carried over.

pub fn gather(&self, indices: &[usize]) -> MaterializedBatch

Reorder/copy rows by physical indices into a new identity batch.

pub fn hash_rows(&self, cols: &[usize]) -> Vec<u64>

Hash each logical row over a column subset (FNV-1a over postcard bytes).

cols empty means all columns. Only the equality partition matters: rows equal under Value equality share a hash; unequal rows may (rarely) collide. Null/NaN/mixed-kind handling follows postcard encoding, and equivalence with HashSet<Vec<Value>> is covered by tests.

Trait Implementations

impl Clone for MaterializedBatch

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MaterializedBatch

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

Formats the value using the given formatter.