Struct InProgressPrimitiveArray 

pub(crate) struct InProgressPrimitiveArray<T: ArrowPrimitiveType> {
    data_type: DataType,
    source: Option<ArrayRef>,
    batch_size: usize,
    nulls: NullBufferBuilder,
    current: Vec<T::Native>,
}

InProgressArray for [PrimitiveArray]

Fields

data_type: DataType

Data type of the array

source: Option<ArrayRef>

The current source, if any

batch_size: usize

the target batch size (and thus size for views allocation)

nulls: NullBufferBuilder

In progress nulls

current: Vec<T::Native>

The currently in progress array

Implementations

impl<T: ArrowPrimitiveType> InProgressPrimitiveArray<T>

pub(crate) fn new(batch_size: usize, data_type: DataType) -> Self

Create a new InProgressPrimitiveArray

fn ensure_capacity(&mut self)

Allocate space for output values if necessary.

This is done on write (when we know it is necessary) rather than eagerly to avoid allocations that are not used.

unsafe fn append_values_by_indices( current: &mut Vec<T::Native>, values: &[T::Native], indices: FilterIterator<Copied<Iter<'_, usize>>, IndexIterator<'_>>, selected_count: usize, )

Safety

Every index yielded by indices must be less than values.len(), and indices must yield exactly selected_count indices.

unsafe fn append_values_by_slices( current: &mut Vec<T::Native>, values: &[T::Native], slices: FilterIterator<Copied<Iter<'_, (usize, usize)>>, SlicesIterator<'_>>, selected_count: usize, )

Safety

Every range yielded by slices must satisfy start <= end <= values.len(), and the ranges must contain exactly selected_count values in total.

Trait Implementations

impl<T: Debug + ArrowPrimitiveType> Debug for InProgressPrimitiveArray<T>

where T::Native: Debug,

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

Formats the value using the given formatter.

impl<T: ArrowPrimitiveType + Debug> InProgressArray for InProgressPrimitiveArray<T>

fn set_source(&mut self, source: Option<ArrayRef>)

Set the source array.

fn copy_rows(&mut self, offset: usize, len: usize) -> Result<(), ArrowError>

Copy rows from the current source array into the in-progress array

fn copy_rows_by_filter( &mut self, filter: &FilterPredicate, ) -> Result<(), ArrowError>

Copy rows selected by filter from the current source array.

fn finish(&mut self) -> Result<ArrayRef, ArrowError>

Finish the currently in-progress array and return it as an ArrayRef

fn size(&self) -> usize

Get the number of bytes this array is using

fn copy_rows_by_filter_from( &mut self, source: ArrayRef, filter: &FilterPredicate, ) -> Result<(), ArrowError>

Copy rows selected by a FilterPredicate from source.

fn copy_rows_by_selection( &mut self, selection: FilterSelection<'_>, ) -> Result<(), ArrowError>

Copy rows described by a FilterSelection from the current source array.