Struct MutablePrimitiveArray

pub struct MutablePrimitiveArray<T: NativeType> { /* private fields */ }

The Arrow’s equivalent to Vec<Option<T>> where T is byte-size (e.g. i32). Converting a MutablePrimitiveArray into a PrimitiveArray is O(1).

Implementations

impl<'a, T: NativeType> MutablePrimitiveArray<T>

pub fn iter(&'a self) -> ZipValidity<&'a T, Iter<'a, T>, BitmapIter<'a>>

Returns an iterator over Option<T>

pub fn values_iter(&'a self) -> Iter<'a, T>

Returns an iterator of T

impl<T: NativeType> MutablePrimitiveArray<T>

pub fn new() -> Self

Creates a new empty MutablePrimitiveArray.

pub fn with_capacity(capacity: usize) -> Self

Creates a new MutablePrimitiveArray with a capacity.

pub fn try_new( dtype: ArrowDataType, values: Vec<T>, validity: Option<MutableBitmap>, ) -> PolarsResult<Self>

The canonical method to create a MutablePrimitiveArray out of its internal components.

Implementation

This function is O(1).

Errors

This function errors iff:

• The validity is not None and its length is different from values’s length
• The dtype’s crate::datatypes::PhysicalType is not equal to [crate::datatypes::PhysicalType::Primitive(T::PRIMITIVE)]

pub fn into_inner(self) -> (ArrowDataType, Vec<T>, Option<MutableBitmap>)

Extract the low-end APIs from the MutablePrimitiveArray.

pub fn apply_values<F: Fn(&mut [T])>(&mut self, f: F)

Applies a function f to the values of this array, cloning the values iff they are being shared with others

This is an API to use clone-on-write

Implementation

This function is O(f) if the data is not being shared, and O(N) + O(f) if it is being shared (since it results in a O(N) memcopy).

Panics

This function panics iff f panics

impl<T: NativeType> MutablePrimitiveArray<T>

pub fn with_capacity_from(capacity: usize, dtype: ArrowDataType) -> Self

Creates a new MutablePrimitiveArray from a capacity and ArrowDataType.

pub fn reserve(&mut self, additional: usize)

Reserves additional entries.

pub fn push_value(&mut self, value: T)

pub fn push(&mut self, value: Option<T>)

Adds a new value to the array.

pub fn pop(&mut self) -> Option<T>

Pop a value from the array. Note if the values is empty, this method will return None.

pub fn extend_constant(&mut self, additional: usize, value: Option<T>)

Extends the MutablePrimitiveArray with a constant

pub fn extend_trusted_len<P, I>(&mut self, iterator: I)

where P: Borrow<T>, I: TrustedLen<Item = Option<P>>,

Extends the MutablePrimitiveArray from an iterator of trusted len.

pub unsafe fn extend_trusted_len_unchecked<P, I>(&mut self, iterator: I)

where P: Borrow<T>, I: Iterator<Item = Option<P>>,

Extends the MutablePrimitiveArray from an iterator of trusted len.

Safety

The iterator must be trusted len.

pub fn extend_trusted_len_values<I>(&mut self, iterator: I)

where I: TrustedLen<Item = T>,

Extends the MutablePrimitiveArray from an iterator of values of trusted len. This differs from extend_trusted_len which accepts in iterator of optional values.

pub unsafe fn extend_trusted_len_values_unchecked<I>(&mut self, iterator: I)

where I: Iterator<Item = T>,

Extends the MutablePrimitiveArray from an iterator of values of trusted len. This differs from extend_trusted_len_unchecked which accepts in iterator of optional values.

Safety

The iterator must be trusted len.

pub fn extend_from_slice(&mut self, items: &[T])

Extends the MutablePrimitiveArray from a slice

pub fn to(self, dtype: ArrowDataType) -> Self

Changes the arrays’ ArrowDataType, returning a new MutablePrimitiveArray. Use to change the logical type without changing the corresponding physical Type.

Implementation

This operation is O(1).

pub fn into_arc(self) -> Arc<dyn Array>

Converts itself into an Array.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the MutablePrimitiveArray to fit its current length.

pub fn capacity(&self) -> usize

Returns the capacity of this MutablePrimitiveArray.

pub fn freeze(self) -> PrimitiveArray<T>

pub fn clear(&mut self)

Clears the array, removing all values.

Note that this method has no effect on the allocated capacity of the array.

pub fn with_freeze<K, F: FnOnce(&PrimitiveArray<T>) -> K>(&mut self, f: F) -> K

Apply a function that temporarily freezes this MutableArray into a PrimitiveArray.

impl<T: NativeType> MutablePrimitiveArray<T>

Accessors

pub fn values(&self) -> &Vec<T>

Returns its values.

pub fn values_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice of values.

impl<T: NativeType> MutablePrimitiveArray<T>

Setters

pub fn set(&mut self, index: usize, value: Option<T>)

Sets position index to value. Note that if it is the first time a null appears in this array, this initializes the validity bitmap (O(N)).

Panic

Panics iff index >= self.len().

pub unsafe fn set_unchecked(&mut self, index: usize, value: Option<T>)

Sets position index to value. Note that if it is the first time a null appears in this array, this initializes the validity bitmap (O(N)).

Safety

Caller must ensure index < self.len()

pub fn set_validity(&mut self, validity: Option<MutableBitmap>)

Sets the validity.

Panic

Panics iff the validity’s len is not equal to the existing values’ length.

pub fn set_values(&mut self, values: Vec<T>)

Sets values.

Panic

Panics iff the values’ length is not equal to the existing validity’s len.

impl<T: NativeType> MutablePrimitiveArray<T>

pub fn from_slice<P: AsRef<[T]>>(slice: P) -> Self

Creates a MutablePrimitiveArray from a slice of values.

pub unsafe fn from_trusted_len_iter_unchecked<I, P>(iterator: I) -> Self

where P: Borrow<T>, I: Iterator<Item = Option<P>>,

Creates a MutablePrimitiveArray from an iterator of trusted length.

Safety

The iterator must be TrustedLen. I.e. size_hint().1 correctly reports its length.

pub fn from_trusted_len_iter<I, P>(iterator: I) -> Self

where P: Borrow<T>, I: TrustedLen<Item = Option<P>>,

Creates a MutablePrimitiveArray from a TrustedLen.

pub unsafe fn try_from_trusted_len_iter_unchecked<E, I, P>( iter: I, ) -> Result<Self, E>

where P: Borrow<T>, I: IntoIterator<Item = Result<Option<P>, E>>,

Creates a MutablePrimitiveArray from an fallible iterator of trusted length.

Safety

The iterator must be TrustedLen. I.e. that size_hint().1 correctly reports its length.

pub fn try_from_trusted_len_iter<E, I, P>(iterator: I) -> Result<Self, E>

where P: Borrow<T>, I: TrustedLen<Item = Result<Option<P>, E>>,

Creates a MutablePrimitiveArray from an fallible iterator of trusted length.

pub fn from_trusted_len_values_iter<I: TrustedLen<Item = T>>(iter: I) -> Self

Creates a new MutablePrimitiveArray out an iterator over values

pub fn from_vec(values: Vec<T>) -> Self

Creates a (non-null) MutablePrimitiveArray from a vector of values. This does not have memcopy and is the fastest way to create a PrimitiveArray.

pub unsafe fn from_trusted_len_values_iter_unchecked<I: Iterator<Item = T>>( iter: I, ) -> Self

Creates a new MutablePrimitiveArray from an iterator over values

Safety

The iterator must be TrustedLen. I.e. that size_hint().1 correctly reports its length.

Trait Implementations

impl<T: Clone + NativeType> Clone for MutablePrimitiveArray<T>

fn clone(&self) -> MutablePrimitiveArray<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + NativeType> Debug for MutablePrimitiveArray<T>

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

Formats the value using the given formatter.

impl<T: NativeType> Default for MutablePrimitiveArray<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: NativeType> Extend<Option<T>> for MutablePrimitiveArray<T>

fn extend<I: IntoIterator<Item = Option<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: NativeType> From<ArrowDataType> for MutablePrimitiveArray<T>

fn from(dtype: ArrowDataType) -> Self

Converts to this type from the input type.

impl<T: NativeType> From<MutablePrimitiveArray<T>> for PrimitiveArray<T>

fn from(other: MutablePrimitiveArray<T>) -> Self

Converts to this type from the input type.

impl<T: NativeType, P: AsRef<[Option<T>]>> From<P> for MutablePrimitiveArray<T>

fn from(slice: P) -> Self

Converts to this type from the input type.

impl<T: NativeType, Ptr: Borrow<Option<T>>> FromIterator<Ptr> for MutablePrimitiveArray<T>

fn from_iter<I: IntoIterator<Item = Ptr>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: NativeType> MutableArray for MutablePrimitiveArray<T>

fn len(&self) -> usize

The length of the array.

fn validity(&self) -> Option<&MutableBitmap>

The optional validity of the array.

fn as_box(&mut self) -> Box<dyn Array>

Convert itself to an (immutable) Array.

fn as_arc(&mut self) -> Arc<dyn Array>

Convert itself to an (immutable) atomically reference counted Array.

fn dtype(&self) -> &ArrowDataType

The ArrowDataType of the array.

fn as_any(&self) -> &dyn Any

Convert to Any, to enable dynamic casting.

fn as_mut_any(&mut self) -> &mut dyn Any

Convert to mutable Any, to enable dynamic casting.

fn push_null(&mut self)

Adds a new null element to the array.

fn reserve(&mut self, additional: usize)

Reserves additional slots to its capacity.

fn shrink_to_fit(&mut self)

Shrink the array to fit its length.

fn is_empty(&self) -> bool

Whether the array is empty.

fn is_valid(&self, index: usize) -> bool

Whether index is valid / set.

impl<T: NativeType> PartialEq for MutablePrimitiveArray<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: NativeType> Pushable<Option<T>> for MutablePrimitiveArray<T>

type Freeze = PrimitiveArray<T>

fn reserve(&mut self, additional: usize)

fn push(&mut self, value: Option<T>)

fn len(&self) -> usize

fn push_null(&mut self)

fn extend_constant(&mut self, additional: usize, value: Option<T>)

fn extend_null_constant(&mut self, additional: usize)

fn freeze(self) -> Self::Freeze

fn with_capacity(capacity: usize) -> Self

fn extend_n(&mut self, n: usize, iter: impl Iterator<Item = T>)

impl<T: NativeType> TryExtend<Option<T>> for MutablePrimitiveArray<T>

fn try_extend<I: IntoIterator<Item = Option<T>>>( &mut self, iter: I, ) -> PolarsResult<()>

This is infallible and is implemented for consistency with all other types

impl<T: NativeType> TryExtendFromSelf for MutablePrimitiveArray<T>

fn try_extend_from_self(&mut self, other: &Self) -> PolarsResult<()>

Tries to extend itself with elements from other, failing only on overflow.

impl<T: NativeType> TryPush<Option<T>> for MutablePrimitiveArray<T>

fn try_push(&mut self, item: Option<T>) -> PolarsResult<()>

This is infalible and is implemented for consistency with all other types