Struct MutableArrayData 

pub struct MutableArrayData<'a> {
    arrays: Vec<&'a ArrayData>,
    data: _MutableArrayData<'a>,
    dictionary: Option<ArrayData>,
    variadic_data_buffers: Vec<Buffer>,
    extend_values: Vec<Box<dyn Fn(&mut _MutableArrayData<'_>, usize, usize, usize) -> Result<(), ArrowError> + 'a>>,
    extend_null_bits: Vec<Box<dyn Fn(&mut _MutableArrayData<'_>, usize, usize) + 'a>>,
    extend_nulls: Box<dyn Fn(&mut _MutableArrayData<'_>, usize) -> Result<(), ArrowError>>,
}

Efficiently create an ArrayData from one or more existing ArrayDatas by copying chunks.

The main use case of this struct is to perform unary operations to arrays of arbitrary types, such as filter and take.

Example

use arrow_buffer::Buffer;
use arrow_data::ArrayData;
use arrow_data::transform::MutableArrayData;
use arrow_schema::DataType;
fn i32_array(values: &[i32]) -> ArrayData {
  ArrayData::try_new(DataType::Int32, 5, None, 0, vec![Buffer::from_slice_ref(values)], vec![]).unwrap()
}
let arr1  = i32_array(&[1, 2, 3, 4, 5]);
let arr2  = i32_array(&[6, 7, 8, 9, 10]);
// Create a mutable array for copying values from arr1 and arr2, with a capacity for 6 elements
let capacity = 3 * std::mem::size_of::<i32>();
let mut mutable = MutableArrayData::new(vec![&arr1, &arr2], false, 10);
// Copy the first 3 elements from arr1
mutable.extend(0, 0, 3);
// Copy the last 3 elements from arr2
mutable.extend(1, 2, 4);
// Complete the MutableArrayData into a new ArrayData
let frozen = mutable.freeze();
assert_eq!(frozen, i32_array(&[1, 2, 3, 8, 9, 10]));

Fields

arrays: Vec<&'a ArrayData>

data: _MutableArrayData<'a>

dictionary: Option<ArrayData>

variadic_data_buffers: Vec<Buffer>

extend_values: Vec<Box<dyn Fn(&mut _MutableArrayData<'_>, usize, usize, usize) -> Result<(), ArrowError> + 'a>>

extend_null_bits: Vec<Box<dyn Fn(&mut _MutableArrayData<'_>, usize, usize) + 'a>>

extend_nulls: Box<dyn Fn(&mut _MutableArrayData<'_>, usize) -> Result<(), ArrowError>>

Implementations

impl<'a> MutableArrayData<'a>

pub fn new( arrays: Vec<&'a ArrayData>, use_nulls: bool, capacity: usize, ) -> MutableArrayData<'a>

Returns a new MutableArrayData with capacity to capacity slots and specialized to create an ArrayData from multiple arrays.

Arguments

• arrays - the source arrays to copy from
• use_nulls - a flag used to optimize insertions
  • false if the only source of nulls are the arrays themselves
  • true if the user plans to call MutableArrayData::extend_nulls.
• capacity - the preallocated capacity of the output array, in bytes

Thus, if use_nulls is false, calling MutableArrayData::extend_nulls should not be used.

pub fn with_capacities( arrays: Vec<&'a ArrayData>, use_nulls: bool, capacities: Capacities, ) -> MutableArrayData<'a>

Similar to MutableArrayData::new, but lets users define the preallocated capacities of the array with more granularity.

See MutableArrayData::new for more information on the arguments.

Panics

This function panics if the given capacities don’t match the data type of arrays. Or when a Capacities variant is not yet supported.

pub fn try_extend( &mut self, index: usize, start: usize, end: usize, ) -> Result<(), ArrowError>

Extends the in progress array with a region of the input arrays, returning an error on overflow.

Arguments

• index - the index of array that you want to copy values from
• start - the start index of the chunk (inclusive)
• end - the end index of the chunk (exclusive)

Errors

Returns an error if offset arithmetic overflows the underlying integer type.

Panic

This function panics if there is an invalid index, i.e. index >= the number of source arrays or end > the length of the indexth array

pub fn extend(&mut self, index: usize, start: usize, end: usize)

👎Deprecated since 59.0.0:

Use try_extend which returns an error on overflow instead of panicking

Extends the in progress array with a region of the input arrays.

Panic

This function panics if there is an invalid index, i.e. index >= the number of source arrays, end > the length of the indexth array, or the offset type overflows (e.g. more than 2 GiB in a StringArray).

pub fn try_extend_nulls(&mut self, len: usize) -> Result<(), ArrowError>

Extends the in progress array with null elements, ignoring the input arrays, returning an error on overflow.

Prefer this over extend_nulls to handle cases where the run-end counter overflows (relevant for RunEndEncoded arrays).

Panics

Panics if MutableArrayData not created with use_nulls or nullable source arrays

pub fn extend_nulls(&mut self, len: usize)

👎Deprecated since 59.0.0:

Use try_extend_nulls which returns an error on overflow instead of panicking

Extends the in progress array with null elements, ignoring the input arrays.

Panics

Panics if MutableArrayData not created with use_nulls or nullable source arrays, or if the run-end counter overflows for RunEndEncoded arrays.

pub fn len(&self) -> usize

Returns the current length

pub fn is_empty(&self) -> bool

Returns true if len is 0

pub fn null_count(&self) -> usize

Returns the current null count

pub fn freeze(self) -> ArrayData

Creates a ArrayData from the in progress array, consuming self.

pub fn into_builder(self) -> ArrayDataBuilder

Consume self and returns the in progress array as ArrayDataBuilder.

This is useful for extending the default behavior of MutableArrayData.

Trait Implementations

impl Debug for MutableArrayData<'_>

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

Formats the value using the given formatter.