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.

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 finish(&mut self) -> Result<ArrayRef, ArrowError>

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