Struct polars::chunked_array::ChunkedArray

pub struct ChunkedArray<T> { /* fields omitted */ }

Implementations

impl<T> ChunkedArray<T> where
    T: PolarsDataType, 

pub fn new_from_chunks(name: &str, chunks: Vec<ArrayRef>) -> Self

Create a new ChunkedArray from existing chunks.

pub fn null_bits(&self) -> Vec<(usize, Option<Buffer>)>

impl<T> ChunkedArray<T> where
    T: PolarsDataType,
    ChunkedArray<T>: ChunkOps, 

pub fn chunk_id(&self) -> &Vec<usize>

pub fn chunks(&self) -> &Vec<ArrayRef>

A reference to the chunks

pub fn null_count(&self) -> usize

Count the null values.

pub fn is_null(&self) -> BooleanChunked

Get a mask of the null values.

pub fn u32(self) -> Result<UInt32Chunked>

Downcast

pub fn i32(self) -> Result<Int32Chunked>

Downcast

pub fn i64(self) -> Result<Int64Chunked>

Downcast

pub fn f32(self) -> Result<Float32Chunked>

Downcast

pub fn f64(self) -> Result<Float64Chunked>

Downcast

pub fn bool(self) -> Result<BooleanChunked>

Downcast

pub fn utf8(self) -> Result<Utf8Chunked>

Downcast

pub fn date32(self) -> Result<Date32Chunked>

Downcast

pub fn date64(self) -> Result<Date64Chunked>

Downcast

pub fn time64ns(self) -> Result<Time64NsChunked>

Downcast

pub fn duration_ns(self) -> Result<DurationNsChunked>

Downcast

pub fn limit(&self, num_elements: usize) -> Result<Self>

Take a view of top n elements

pub fn filter(&self, filter: &BooleanChunked) -> Result<Self>

Chunk sizes should match or rhs should have one chunk

pub fn append_array(&mut self, other: ArrayRef) -> Result<()>

Append arrow array in place.

pub fn len(&self) -> usize

Combined length of all the chunks.

pub fn get(&self, index: usize) -> AnyType

Get a single value. Beware this is slow.

pub fn slice(&self, offset: usize, length: usize) -> Result<Self>

Slice the array. The chunks are reallocated the underlying data slices are zero copy.

pub fn head(&self, length: Option<usize>) -> Self

Get the head of the ChunkedArray

pub fn tail(&self, length: Option<usize>) -> Self

Get the tail of the ChunkedArray

pub fn append(&mut self, other: &Self) where
    Self: Sized, 

Append in place.

impl ChunkedArray<Utf8Type>

pub fn new_utf8_from_slice<S: AsRef<str>>(name: &str, v: &[S]) -> Self

pub fn new_utf8_from_opt_slice<S: AsRef<str>>(
    name: &str,
    opt_v: &[Option<S>]
) -> Self

impl<T> ChunkedArray<T> where
    T: PolarsDataType,
    ChunkedArray<T>: ChunkOps, 

pub fn name(&self) -> &str

Name of the ChunkedArray.

pub fn ref_field(&self) -> &Field

Get a reference to the field.

pub fn rename(&mut self, name: &str)

Rename this ChunkedArray.

impl<T> ChunkedArray<T> where
    T: ArrowPrimitiveType, 

pub fn new_from_slice(name: &str, v: &[T::Native]) -> Self

pub fn new_from_opt_slice(name: &str, opt_v: &[Option<T::Native>]) -> Self

pub fn new_with_null_bitmap(
    name: &str,
    v: &[T::Native],
    buffer: Option<Buffer>,
    null_count: usize
) -> Self

Nullify values in slice with an existing null bitmap

impl<T> ChunkedArray<T> where
    T: PolarsNumericType, 

pub fn cont_slice(&self) -> Result<&[T::Native]>

Contiguous slice

pub fn map<B, F>(&self, f: F) -> Result<Map<Copied<Iter<T::Native>>, F>> where
    F: Fn(T::Native) -> B, 

If cont_slice is successful a closure is mapped over the elements.

Example

use polars::prelude::*;
fn multiply(ca: &UInt32Chunked) -> Result<Series> {
    let mapped = ca.map(|v| v * 2)?;
    Ok(mapped.collect())
}

pub fn map_null_checks<'a, B, F>(
    &'a self,
    f: F
) -> Map<Box<dyn ExactSizeIterator<Item = Option<T::Native>> + 'a>, F> where
    F: Fn(Option<T::Native>) -> B, 

If cont_slice fails we can fallback on an iterator with null checks and map a closure over the elements.

Example

use polars::prelude::*;
use itertools::Itertools;
fn multiply(ca: &UInt32Chunked) -> Series {
    let mapped_result = ca.map(|v| v * 2);

    if let Ok(mapped) = mapped_result {
        mapped.collect()
    } else {
        ca
        .map_null_checks(|opt_v| opt_v.map(|v |v * 2)).collect()
    }
}

pub fn fold<F, B>(&self, init: B, f: F) -> Result<B> where
    F: Fn(B, T::Native) -> B, 

If cont_slice is successful a closure can be applied as aggregation

Example

use polars::prelude::*;
fn compute_sum(ca: &UInt32Chunked) -> Result<u32> {
    ca.fold(0, |acc, value| acc + value)
}

pub fn fold_null_checks<F, B>(&self, init: B, f: F) -> B where
    F: Fn(B, Option<T::Native>) -> B, 

If cont_slice fails we can fallback on an iterator with null checks and a closure for aggregation

Example

use polars::prelude::*;
fn compute_sum(ca: &UInt32Chunked) -> u32 {
    match ca.fold(0, |acc, value| acc + value) {
        // faster sum without null checks was successful
        Ok(sum) => sum,
        // Null values or multiple chunks in ChunkedArray, we need to do more bounds checking
        Err(_) => ca.fold_null_checks(0, |acc, opt_value| {
            match opt_value {
                Some(v) => acc + v,
                None => acc
            }
        })
    }
}

Trait Implementations

impl<T, '_> Add<&'_ ChunkedArray<T>> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + Sub<Output = T::Native> + Mul<Output = T::Native> + Div<Output = T::Native> + Zero, 

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T> Add<ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + Sub<Output = T::Native> + Mul<Output = T::Native> + Div<Output = T::Native> + Zero, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T> Agg<<T as ArrowPrimitiveType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + PartialOrd, 

fn sum(&self) -> Option<T::Native>

Returns None if the array is empty or only contains null values.

fn min(&self) -> Option<T::Native>

Returns the minimum value in the array, according to the natural order. Returns an option because the array is nullable.

fn max(&self) -> Option<T::Native>

Returns the maximum value in the array, according to the natural order. Returns an option because the array is nullable.

impl<'a, T> Apply<'a, <T as ArrowPrimitiveType>::Native, <T as ArrowPrimitiveType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn apply<F>(&'a self, f: F) -> Self where
    F: Fn(T::Native) -> T::Native, 

Chooses the fastest path for closure application. Null values remain null.

Example

use polars::prelude::*;
fn double(ca: &UInt32Chunked) -> UInt32Chunked {
    ca.apply(|v| v * 2)
}

impl AsMut<ChunkedArray<BooleanType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<BooleanType>

Performs the conversion.

impl AsMut<ChunkedArray<Float32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Float32Type>

Performs the conversion.

impl AsMut<ChunkedArray<Float64Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Float64Type>

Performs the conversion.

impl AsMut<ChunkedArray<Int32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Int32Type>

Performs the conversion.

impl AsMut<ChunkedArray<Int64Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Int64Type>

Performs the conversion.

impl AsMut<ChunkedArray<UInt32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<UInt32Type>

Performs the conversion.

impl AsMut<ChunkedArray<Utf8Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Utf8Type>

Performs the conversion.

impl AsRef<ChunkedArray<BooleanType>> for Series

fn as_ref(&self) -> &ChunkedArray<BooleanType>

Performs the conversion.

impl AsRef<ChunkedArray<Float32Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Float32Type>

Performs the conversion.

impl AsRef<ChunkedArray<Float64Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Float64Type>

Performs the conversion.

impl AsRef<ChunkedArray<Int32Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Int32Type>

Performs the conversion.

impl AsRef<ChunkedArray<Int64Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Int64Type>

Performs the conversion.

impl<T> AsRef<ChunkedArray<T>> for ChunkedArray<T>

fn as_ref(&self) -> &ChunkedArray<T>

Performs the conversion.

impl AsRef<ChunkedArray<UInt32Type>> for Series

fn as_ref(&self) -> &ChunkedArray<UInt32Type>

Performs the conversion.

impl AsRef<ChunkedArray<Utf8Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Utf8Type>

Performs the conversion.

impl<T> ChunkCast for ChunkedArray<T> where
    T: PolarsNumericType, 

fn cast<N>(&self) -> Result<ChunkedArray<N>> where
    N: PolarsDataType, 

impl<T> ChunkFull<<T as ArrowPrimitiveType>::Native> for ChunkedArray<T> where
    T: ArrowPrimitiveType, 

fn full(name: &str, value: T::Native, length: usize) -> Self where
    T::Native: Copy, 

Create a ChunkedArray with a single value.

impl<T> ChunkOps for ChunkedArray<T> where
    T: PolarsNumericType, 

fn rechunk(&self, chunk_lengths: Option<&[usize]>) -> Result<Self>

Aggregate to chunk id. A chunk id is a vector of the chunk lengths.

fn optional_rechunk<A>(&self, rhs: &ChunkedArray<A>) -> Result<Option<Self>>

Only rechunk if lhs and rhs don't match

impl<T> ChunkSort<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: PartialOrd, 

fn sort(&self, reverse: bool) -> ChunkedArray<T>

fn sort_in_place(&mut self, reverse: bool)

fn argsort(&self, reverse: bool) -> Vec<usize>

impl<T> Clone for ChunkedArray<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'_> CmpOps<&'_ ChunkedArray<BooleanType>> for BooleanChunked

fn eq(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for equality.

fn neq(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: &BooleanChunked) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &BooleanChunked) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &BooleanChunked) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &BooleanChunked) -> BooleanChunked

Less than or equal comparison

impl<T, '_> CmpOps<&'_ ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn eq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Check for equality.

fn neq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Less than or equal comparison

impl<'_> CmpOps<&'_ ChunkedArray<Utf8Type>> for Utf8Chunked

fn eq(&self, rhs: &Utf8Chunked) -> BooleanChunked

Check for equality.

fn neq(&self, rhs: &Utf8Chunked) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: &Utf8Chunked) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &Utf8Chunked) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &Utf8Chunked) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &Utf8Chunked) -> BooleanChunked

Less than or equal comparison

impl<T, Rhs> CmpOps<Rhs> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumCast,
    Rhs: NumComp + ToPrimitive, 

fn eq(&self, rhs: Rhs) -> BooleanChunked

Check for equality.

fn neq(&self, rhs: Rhs) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: Rhs) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: Rhs) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: Rhs) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: Rhs) -> BooleanChunked

Less than or equal comparison

impl<T> Debug for ChunkedArray<T>

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

Formats the value using the given formatter.

impl<T, '_> Div<&'_ ChunkedArray<T>> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + Sub<Output = T::Native> + Mul<Output = T::Native> + Div<Output = T::Native> + Zero + One, 

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T> Div<ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + Sub<Output = T::Native> + Mul<Output = T::Native> + Div<Output = T::Native> + Zero + One, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T> Downcast<PrimitiveArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn downcast_chunks(&self) -> Vec<&PrimitiveArray<T>>

impl<'a, T> From<&'a ChunkedArray<T>> for Vec<Option<T::Native>> where
    T: ArrowPrimitiveType,
    &'a ChunkedArray<T>: IntoIterator<Item = Option<T::Native>>,
    ChunkedArray<T>: ChunkOps, 

fn from(ca: &'a ChunkedArray<T>) -> Self

Performs the conversion.

impl<'a> From<&'a ChunkedArray<Utf8Type>> for Vec<String>

fn from(ca: &'a Utf8Chunked) -> Self

Performs the conversion.

impl<T> FromIterator<Option<<T as ArrowPrimitiveType>::Native>> for ChunkedArray<T> where
    T: ArrowPrimitiveType, 

fn from_iter<I: IntoIterator<Item = Option<T::Native>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> HashJoin<T> for ChunkedArray<T> where
    T: PolarsNumericType + Sync,
    T::Native: Eq + Hash, 

fn hash_join_inner(&self, other: &ChunkedArray<T>) -> Vec<(usize, usize)>

fn hash_join_left(&self, other: &ChunkedArray<T>) -> Vec<(usize, Option<usize>)>

fn hash_join_outer(
    &self,
    other: &ChunkedArray<T>
) -> HashSet<(Option<usize>, Option<usize>), FnvBuildHasher>

impl<'a, T> IntoIterator for &'a ChunkedArray<T> where
    T: PolarsNumericType, 

type Item = Option<T::Native>

The type of the elements being iterated over.

type IntoIter = Box<dyn ExactSizeIterator<Item = Option<T::Native>> + 'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoTakeRandom<'a> for &'a ChunkedArray<T> where
    T: PolarsNumericType, 

type Item = T::Native

fn take_rand(&self) -> Box<dyn TakeRandom<Item = Self::Item> + 'a>

impl<T, '_> Mul<&'_ ChunkedArray<T>> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + Sub<Output = T::Native> + Mul<Output = T::Native> + Div<Output = T::Native> + Zero, 

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T> Mul<ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + Sub<Output = T::Native> + Mul<Output = T::Native> + Div<Output = T::Native> + Zero, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T> Pow for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: ToPrimitive, 

fn pow_f32(&self, exp: f32) -> Float32Chunked

fn pow_f64(&self, exp: f64) -> Float64Chunked

impl<T> Reverse<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    ChunkedArray<T>: ChunkOps, 

fn reverse(&self) -> ChunkedArray<T>

impl<T, '_> Sub<&'_ ChunkedArray<T>> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + Sub<Output = T::Native> + Mul<Output = T::Native> + Div<Output = T::Native> + Zero, 

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T> Sub<ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + Sub<Output = T::Native> + Mul<Output = T::Native> + Div<Output = T::Native> + Zero, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T> Take for ChunkedArray<T> where
    T: PolarsNumericType, 

fn take(
    &self,
    indices: impl Iterator<Item = usize>,
    capacity: Option<usize>
) -> Result<Self>

Take values from ChunkedArray by index.

fn take_opt(
    &self,
    indices: impl Iterator<Item = Option<usize>>,
    capacity: Option<usize>
) -> Result<Self>

Take values from ChunkedArray by Option.

impl<T> Unique<T> for ChunkedArray<T> where
    T: PolarsIntegerType,
    T::Native: Hash + Eq,
    ChunkedArray<T>: ChunkOps, 

fn unique(&self) -> Self

Get unique values of a ChunkedArray

fn arg_unique(&self) -> Vec<usize>

Get first index of the unique values in a ChunkedArray.

impl<T, '_> Unique<T> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumCast + ToPrimitive,
    ChunkedArray<T>: ChunkOps, 

fn unique(&self) -> ChunkedArray<T>

Get unique values of a ChunkedArray

fn arg_unique(&self) -> Vec<usize>

Get first index of the unique values in a ChunkedArray.

impl<T> ValueCounts<T> for ChunkedArray<T> where
    T: PolarsIntegerType,
    T::Native: Hash + Eq,
    ChunkedArray<T>: ChunkOps, 

fn value_counts(
    &self
) -> HashMap<Option<T::Native>, u32, BuildHasherDefault<FnvHasher>>