Struct ChangeBuffer 

pub struct ChangeBuffer<K, R> {
    buffer: IndexMap<K, Record<R>>,
    ib: InconsistencyBehavior,
}

A buffer that accumulates changes and produce compacted changes.

Fields

buffer: IndexMap<K, Record<R>>

ib: InconsistencyBehavior

Implementations

impl<K, R> ChangeBuffer<K, R>

where K: Key, R: Row,

pub fn insert(&mut self, key: K, new_row: R)

Apply an insertion of a row with the given key.

pub fn delete(&mut self, key: K, old_row: R)

Apply a deletion of a row with the given key.

pub fn update(&mut self, key: K, old_row: R, new_row: R)

Apply an update of a row with the given key.

pub fn apply_record(&mut self, record: Record<R>, key_fn: impl Fn(&R) -> K)

Apply a change record, with the key extracted by the given function.

For Record::Update, inconsistency is reported if the old key and the new key are different. Further behavior is determined by the InconsistencyBehavior.

pub fn apply_op_row(&mut self, op: Op, key: K, row: R)

Apply an Op of a row with the given key.

pub fn into_records(self) -> impl Iterator<Item = Record<R>>

Consume the buffer and produce a list of change records.

No-op updates are filtered out.

impl<K, R> ChangeBuffer<K, R>

pub fn new() -> Self

Create a new ChangeBuffer that panics on inconsistency.

pub fn with_capacity(capacity: usize) -> Self

Create a new ChangeBuffer with the given capacity that panics on inconsistency.

pub fn with_inconsistency_behavior(self, ib: InconsistencyBehavior) -> Self

Set the inconsistency behavior.

pub fn len(&self) -> usize

Get the number of keys that have pending changes in the buffer.

pub fn is_empty(&self) -> bool

Check if the buffer is empty.

impl<K, R> ChangeBuffer<K, R>

where K: Key, R: Row + Row,

pub fn into_chunk<const KIND: OutputKind>( self, data_types: Vec<DataType>, ) -> Option<StreamChunk>

Consume the buffer and produce a single compacted chunk.

pub fn into_chunk_with_key( self, data_types: Vec<DataType>, key_indices: &[usize], ) -> Option<StreamChunk>

Consume the buffer and produce a single compacted chunk, with the given new key indices.

The key must be a superset of the old key to ensure uniqueness. Otherwise, changes to the same key might be written multiple times so that the correct ordering of the operations cannot be guaranteed.

pub fn into_chunks<const KIND: OutputKind>( self, data_types: Vec<DataType>, chunk_size: usize, ) -> Vec<StreamChunk>

Consume the buffer and produce a list of compacted chunks with the given size at most.

Trait Implementations

impl<K: Debug, R: Debug> Debug for ChangeBuffer<K, R>

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

Formats the value using the given formatter.

impl<K, R> Default for ChangeBuffer<K, R>

fn default() -> Self

Returns the “default value” for a type.