Struct DataChunkBuilder

pub struct DataChunkBuilder {
    data_types: Vec<DataType>,
    batch_size: usize,
    array_builders: Vec<ArrayBuilderImpl>,
    buffered_count: usize,
}

Used as a buffer for accumulating rows.

Fields

data_types: Vec<DataType>

Data types for build array

batch_size: usize

array_builders: Vec<ArrayBuilderImpl>

Buffers storing current data

buffered_count: usize

Implementations

impl DataChunkBuilder

pub fn new(data_types: Vec<DataType>, batch_size: usize) -> Self

pub fn batch_size(&self) -> usize

fn ensure_builders(&mut self)

Lazily create the array builders if absent

fn append_chunk_inner( &mut self, input_chunk: SlicedDataChunk, ) -> (Option<SlicedDataChunk>, Option<DataChunk>)

Returns not consumed input chunked data as sliced data chunk, and a data chunk of batch_size.

If input_chunk is not totally consumed, it’s returned with a new offset, which is equal to old_offset + consumed_rows. Otherwise the first value is None.

If number of batch_size rows reached, it’s returned as the second value of tuple. Otherwise it’s None.

pub fn append_chunk(&mut self, data_chunk: DataChunk) -> AppendDataChunk<'_>

Returns an iterator that yields data chunks during appending the whole input data chunk. The iterator must be fully consumed to ensure all data is appended.

pub fn consume_all(&mut self) -> Option<DataChunk>

Returns all data in current buffer.

If buffered_count is 0, None is returned.

pub fn finish(self) -> DataChunk

Build a data chunk from the current buffer.

fn append_one_row_internal(&mut self, data_chunk: &DataChunk, row_idx: usize)

fn do_append_one_row_from_datums( &mut self, datums: impl Iterator<Item = impl ToDatumRef>, )

pub fn append_one_row(&mut self, row: impl Row) -> Option<DataChunk>

Append one row from the given Row. Return a data chunk if the buffer is full after append one row. Otherwise None.

fn append_one_row_no_finish(&mut self, row: impl Row)

pub fn append_one_row_from_array_elements<'a, I1, I2>( &mut self, left_arrays: I1, left_row_id: usize, right_arrays: I2, right_row_id: usize, ) -> Option<DataChunk>

where I1: Iterator<Item = &'a ArrayImpl>, I2: Iterator<Item = &'a ArrayImpl>,

Append one row from the given two arrays. Return a data chunk if the buffer is full after append one row. Otherwise None.

fn build_data_chunk(&mut self) -> DataChunk

pub fn buffered_count(&self) -> usize

pub fn can_append(&self, count: usize) -> bool

pub fn num_columns(&self) -> usize

pub fn data_types(&self) -> Vec<DataType>

pub fn is_empty(&self) -> bool

pub fn clear(&mut self)

Trait Implementations

impl Drop for DataChunkBuilder

fn drop(&mut self)

Executes the destructor for this type.