Struct ByteViewGroupValueBuilder 

pub struct ByteViewGroupValueBuilder<B: ByteViewType> {
    views: Vec<u128>,
    in_progress: Vec<u8>,
    completed: Vec<Buffer>,
    max_block_size: usize,
    nulls: MaybeNullBufferBuilder,
    _phantom: PhantomData<B>,
}

An implementation of GroupColumn for binary view and utf8 view types.

Stores a collection of binary view or utf8 view group values in a buffer whose structure is similar to GenericByteViewArray, and we can get benefits:

1. Efficient comparison of incoming rows to existing rows
2. Efficient construction of the final output array
3. Efficient to perform take_n comparing to use GenericByteViewBuilder

Fields

views: Vec<u128>

The views of string values

If string len <= 12, the view’s format will be: string(12B) | len(4B)

If string len > 12, its format will be: offset(4B) | buffer_index(4B) | prefix(4B) | len(4B)

in_progress: Vec<u8>

The progressing block

New values will be inserted into it until its capacity is not enough(detail can see max_block_size).

completed: Vec<Buffer>

The completed blocks

max_block_size: usize

The max size of in_progress

in_progress will be flushed into completed, and create new in_progress when found its remaining capacity(max_block_size - len(in_progress)), is no enough to store the appended value.

Currently it is fixed at 2MB.

nulls: MaybeNullBufferBuilder

Nulls

_phantom: PhantomData<B>

phantom data so the type requires <B>

Implementations

impl<B: ByteViewType> ByteViewGroupValueBuilder<B>

pub fn new() -> Self

fn with_max_block_size(self, max_block_size: usize) -> Self

Set the max block size

fn equal_to_inner( &self, lhs_row: usize, array: &ArrayRef, rhs_row: usize, ) -> bool

fn append_val_inner(&mut self, array: &ArrayRef, row: usize)

fn vectorized_equal_to_inner( &self, lhs_rows: &[usize], array: &ArrayRef, rhs_rows: &[usize], equal_to_results: &mut [bool], )

fn vectorized_append_inner(&mut self, array: &ArrayRef, rows: &[usize])

fn do_append_val_inner(&mut self, array: &GenericByteViewArray<B>, row: usize)

where B: ByteViewType,

fn ensure_in_progress_big_enough(&mut self, value_len: usize)

fn do_equal_to_inner( &self, lhs_row: usize, array: &GenericByteViewArray<B>, rhs_row: usize, ) -> bool

fn value(&self, buffer_index: usize, offset: usize, length: usize) -> &[u8]

fn build_inner(self) -> ArrayRef

fn take_n_inner(&mut self, n: usize) -> ArrayRef

fn take_buffers_with_whole_last( &mut self, last_remaining_buffer_index: usize, ) -> Vec<Buffer>

fn take_buffers_with_partial_last( &mut self, last_remaining_buffer_index: usize, last_take_len: usize, ) -> Vec<Buffer>

fn should_take_whole_buffer(&self, buffer_index: usize, take_len: usize) -> bool

fn flush_in_progress(&mut self)

Trait Implementations

impl<B: ByteViewType> Default for ByteViewGroupValueBuilder<B>

fn default() -> Self

Returns the “default value” for a type.

impl<B: ByteViewType> GroupColumn for ByteViewGroupValueBuilder<B>

fn equal_to(&self, lhs_row: usize, array: &ArrayRef, rhs_row: usize) -> bool

Returns equal if the row stored in this builder at lhs_row is equal to the row in array at rhs_row

fn append_val(&mut self, array: &ArrayRef, row: usize) -> Result<()>

Appends the row at row in array to this builder

fn vectorized_equal_to( &self, group_indices: &[usize], array: &ArrayRef, rows: &[usize], equal_to_results: &mut [bool], )

The vectorized version equal to

fn vectorized_append(&mut self, array: &ArrayRef, rows: &[usize]) -> Result<()>

The vectorized version append_val

fn len(&self) -> usize

Returns the number of rows stored in this builder

fn size(&self) -> usize

Returns the number of bytes used by this GroupColumn

fn build(self: Box<Self>) -> ArrayRef

Builds a new array from all of the stored rows

fn take_n(&mut self, n: usize) -> ArrayRef

Builds a new array from the first n stored rows, shifting the remaining rows to the start of the builder

fn is_empty(&self) -> bool

true if len == 0