Struct polars::chunked_array::ChunkedArray

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

ChunkedArray

Every Series contains a ChunkedArray<T>. Unlike Series, ChunkedArray's are typed. This allows us to apply closures to the data and collect the results to a ChunkedArray of te same type T. Below we use an apply to use the cosine function to the values of a ChunkedArray.

fn apply_cosine(ca: &Float32Chunked) -> Float32Chunked {
    ca.apply(|v| v.cos())
}

If we would like to cast the result we could use a Rust Iterator instead of an apply method. Note that Iterators are slightly slower as the null values aren't ignored implicitly.

fn apply_cosine_and_cast(ca: &Float32Chunked) -> Float64Chunked {
    ca.into_iter()
        .map(|opt_v| {
        opt_v.map(|v| v.cos() as f64)
    }).collect()
}

Another option is to first cast and then use an apply.

fn apply_cosine_and_cast(ca: &Float32Chunked) -> Float64Chunked {
    ca.cast::<Float64Type>()
        .unwrap()
        .apply(|v| v.cos())
}

Conversion between Series and ChunkedArray's

Conversion from a Series to a ChunkedArray is effortless.

fn to_chunked_array(series: &Series) -> Result<&Int32Chunked>{
    series.i32()
}

fn to_series(ca: Int32Chunked) -> Series {
    ca.into_series()
}

Iterators

ChunkedArrays fully support Rust native Iterator and DoubleEndedIterator traits, thereby giving access to all the excelent methods available for Iterators.

fn iter_forward(ca: &Float32Chunked) {
    ca.into_iter()
        .for_each(|opt_v| println!("{:?}", opt_v))
}

fn iter_backward(ca: &Float32Chunked) {
    ca.into_iter()
        .rev()
        .for_each(|opt_v| println!("{:?}", opt_v))
}

Memory layout

ChunkedArray's use Apache Arrow as backend for the memory layout. Arrows memory is immutable which makes it possible to make mutliple zero copy (sub)-views from a single array.

To be able to append data, Polars uses chunks to append new memory locations, hence the ChunkedArray<T> data structure. Appends are cheap, because it will not lead to a full reallocation of the whole array (as could be the case with a Rust Vec).

However, multiple chunks in a ChunkArray will slow down the Iterators, arithmetic and other operations. When multiplying two ChunkArray's with different chunk sizes they cannot utilize SIMD for instance. However, when chunk size don't match, Iterators will be used to do the operation (instead of arrows upstream implementation, which may utilize SIMD) and the result will be a single chunked array.

The key takeaway is that by applying operations on a ChunkArray of multiple chunks, the results will converge to a ChunkArray of a single chunk! It is recommended to leave them as is. If you want to have predictable performance (no unexpected re-allocation of memory), it is adviced to call the rechunk after multiple append operations.

Implementations

impl<T> ChunkedArray<T>

pub fn array_data(&self) -> Vec<ArrayDataRef>

Get Arrow ArrayData

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

Get the null count and the buffer of bits representing null values

pub fn unpack_series_matching_type(
    &self,
    series: &Series
) -> Result<&ChunkedArray<T>>

Series to ChunkedArray

pub fn len(&self) -> usize

Combined length of all the chunks.

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

Unique id representing the number of chunks

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

A reference to the chunks

pub fn is_optimal_aligned(&self) -> bool

Returns true if contains a single chunk and has no null values

pub fn null_count(&self) -> usize

Count the null values.

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

Take a view of top n elements

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

Append arrow array in place.

let mut array = Int32Chunked::new_from_slice("array", &[1, 2]);
let array_2 = Int32Chunked::new_from_slice("2nd", &[3]);

array.append(&array_2);
assert_eq!(Vec::from(&array), [Some(1), Some(2), Some(3)])

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 is_null(&self) -> BooleanChunked

Get a mask of the null values.

pub fn dtype(&self) -> &ArrowDataType

Get data type of ChunkedArray.

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.

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: PolarsDataType, 

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

Create a new ChunkedArray from existing chunks.

impl ChunkedArray<Utf8Type>

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

👎 Deprecated since 3.1:

Use new_from_slice

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

👎 Deprecated since 3.1:

Use new_from_opt_slice

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

pub fn new_from_aligned_vec(name: &str, v: AlignedVec<T::Native>) -> Self

Create a new ChunkedArray by taking ownershipt of the AlignedVec. This operation is zero copy.

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

Nullify values in slice with an existing null bitmap

pub fn new_from_owned_with_null_bitmap(
    name: &str,
    values: AlignedVec<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 data_views(&self) -> Vec<&[T::Native]>

Get slices of the underlying arrow data. NOTE: null values should be taken into account by the user of these slices as they are handled separately

pub fn as_single_ptr(&mut self) -> usize

Rechunk and return a ptr to the start of the array

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<B, F>(
    &self,
    f: F
) -> Map<NumericChunkIterDispatch<'_, T>, 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, N, '_> Add<N> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumCast,
    N: Num + ToPrimitive,
    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: N) -> Self::Output

Performs the + operation.

impl AsMut<ChunkedArray<BooleanType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<Date32Type>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<Date64Type>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<DurationMicrosecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<DurationMillisecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<DurationNanosecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<DurationSecondType>> for Series

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

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<Int16Type>> for Series

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

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<Int8Type>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<IntervalDayTimeType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<IntervalYearMonthType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<LargeListType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<Time32MillisecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<Time32SecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<Time64MicrosecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<Time64NanosecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<TimestampMicrosecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<TimestampMillisecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<TimestampNanosecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<TimestampSecondType>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<UInt16Type>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<UInt32Type>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<UInt64Type>> for Series

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

Performs the conversion.

impl AsMut<ChunkedArray<UInt8Type>> for Series

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

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<Date32Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Date64Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<DurationMicrosecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<DurationMillisecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<DurationNanosecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<DurationSecondType>> for Series

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

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<Int16Type>> for Series

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

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 AsRef<ChunkedArray<Int8Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<IntervalDayTimeType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<IntervalYearMonthType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<LargeListType>> for Series

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

Performs the conversion.

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

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

Performs the conversion.

impl AsRef<ChunkedArray<Time32MillisecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Time32SecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Time64MicrosecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Time64NanosecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<TimestampMicrosecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<TimestampMillisecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<TimestampNanosecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<TimestampSecondType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<UInt16Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<UInt32Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<UInt64Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<UInt8Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Utf8Type>> for Series

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

Performs the conversion.

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

type Output = Result<BooleanChunked>

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<ChunkedArray<BooleanType>> for BooleanChunked

type Output = Result<BooleanChunked>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Result<BooleanChunked>

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<ChunkedArray<BooleanType>> for BooleanChunked

type Output = Result<BooleanChunked>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T> ChunkAgg<<T as ArrowPrimitiveType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + PartialOrd + Div<Output = T::Native> + Num + NumCast + ToPrimitive, 

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

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

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

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.

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

Returns the mean value in the array. Returns an option because the array is nullable.

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

Returns the mean value in the array. Returns an option because the array is nullable.

impl<'a, T> ChunkApply<'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 + Copy, 

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<T> ChunkCast for ChunkedArray<T> where
    T: PolarsNumericType, 

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

Cast ChunkedArray<T> to ChunkedArray<N>

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

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

Check for equality and regard missing values as equal.

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<'_> ChunkCompare<&'_ ChunkedArray<LargeListType>> for LargeListChunked

fn eq_missing(&self, rhs: &LargeListChunked) -> BooleanChunked

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

fn gt(&self, _rhs: &LargeListChunked) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, _rhs: &LargeListChunked) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, _rhs: &LargeListChunked) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, _rhs: &LargeListChunked) -> BooleanChunked

Less than or equal comparison

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

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

Check for equality and regard missing values as equal.

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<'_> ChunkCompare<&'_ ChunkedArray<Utf8Type>> for Utf8Chunked

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

Check for equality and regard missing values as equal.

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> ChunkCompare<Rhs> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumCast,
    Rhs: NumComp + ToPrimitive, 

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

Check for equality and regard missing values as equal.

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> ChunkFillNone<<T as ArrowPrimitiveType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Add<Output = T::Native> + PartialOrd + Div<Output = T::Native> + Num + NumCast, 

fn fill_none(&self, strategy: FillNoneStrategy) -> Result<Self>

Replace None values with one of the following strategies:

fn fill_none_with_value(&self, value: T::Native) -> Result<Self>

Replace None values with a give value T.

impl<T> ChunkFilter<T> for ChunkedArray<T> where
    T: PolarsSingleType,
    ChunkedArray<T>: ChunkOps, 

fn filter(&self, filter: &BooleanChunked) -> Result<ChunkedArray<T>>

Filter values in the ChunkedArray with a boolean mask.

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> ChunkReverse<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    ChunkedArray<T>: ChunkOps, 

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

Return a reversed version of this array.

impl<'a, T> ChunkSet<'a, <T as ArrowPrimitiveType>::Native, <T as ArrowPrimitiveType>::Native> for ChunkedArray<T> where
    T: ArrowPrimitiveType,
    &'a ChunkedArray<T>: IntoNoNullIterator<Item = T::Native> + IntoIterator<Item = Option<T::Native>>,
    T::Native: Copy, 

fn set_at_idx<I: AsTakeIndex>(
    &'a self,
    idx: &I,
    value: Option<T::Native>
) -> Result<Self>

Set the values at indexes idx to some optional value Option<T>.

fn set_at_idx_with<I: AsTakeIndex, F>(&'a self, idx: &I, f: F) -> Result<Self> where
    F: Fn(Option<T::Native>) -> Option<T::Native>, 

Set the values at indexes idx by applying a closure to these values.

fn set(
    &'a self,
    mask: &BooleanChunked,
    value: Option<T::Native>
) -> Result<Self>

Set the values where the mask evaluates to true to some optional value Option<T>.

fn set_with<F>(&'a self, mask: &BooleanChunked, f: F) -> Result<Self> where
    F: Fn(Option<T::Native>) -> Option<T::Native>, 

Set the values where the mask evaluates to true by applying a closure to these values.

impl<T> ChunkShift<T, <T as ArrowPrimitiveType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Copy, 

fn shift(
    &self,
    periods: i32,
    fill_value: &Option<T::Native>
) -> Result<ChunkedArray<T>>

Shift the values by a given period and fill the parts that will be empty due to this operation with fill_value.

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

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

Returned a sorted ChunkedArray.

fn sort_in_place(&mut self, reverse: bool)

Sort this array in place.

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

Retrieve the indexes needed to sort this array.

impl<T> ChunkTake 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.

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

Take values from ChunkedArray by index without checking bounds.

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

Take values from ChunkedArray by Option.

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

Take values from ChunkedArray by Option.

impl<T> ChunkUnique<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.

fn n_unique(&self) -> usize

Number of unique values in the ChunkedArray

impl<T, '_> ChunkUnique<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.

fn n_unique(&self) -> usize

Number of unique values in the ChunkedArray

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<T> Debug for ChunkedArray<T> where
    T: ArrowPrimitiveType, 

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, N, '_> Div<N> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumCast,
    N: Num + ToPrimitive,
    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 div(self, rhs: N) -> 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> From<&'a ChunkedArray<BooleanType>> for Vec<Option<bool>>

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

Performs the conversion.

impl<'a, T> From<&'a ChunkedArray<T>> for Vec<Option<T::Native>> where
    T: PolarsNumericType,
    &'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<Option<&'a str>>

From trait

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

Performs the conversion.

impl From<ChunkedArray<BooleanType>> for Series

fn from(v: ChunkedArray<BooleanType>) -> Series

Performs the conversion.

impl From<ChunkedArray<BooleanType>> for Vec<Option<bool>>

fn from(ca: BooleanChunked) -> Self

Performs the conversion.

impl From<ChunkedArray<Date32Type>> for Series

fn from(v: ChunkedArray<Date32Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<Date64Type>> for Series

fn from(v: ChunkedArray<Date64Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<DurationMicrosecondType>> for Series

fn from(v: DurationMicrosecondChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<DurationMillisecondType>> for Series

fn from(v: DurationMillisecondChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<DurationNanosecondType>> for Series

fn from(v: ChunkedArray<DurationNanosecondType>) -> Series

Performs the conversion.

impl From<ChunkedArray<DurationSecondType>> for Series

fn from(v: DurationSecondChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<Float32Type>> for Series

fn from(v: ChunkedArray<Float32Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<Float64Type>> for Series

fn from(v: ChunkedArray<Float64Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<Int16Type>> for Series

fn from(v: ChunkedArray<Int16Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<Int32Type>> for Series

fn from(v: ChunkedArray<Int32Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<Int64Type>> for Series

fn from(v: ChunkedArray<Int64Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<Int8Type>> for Series

fn from(v: ChunkedArray<Int8Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<IntervalDayTimeType>> for Series

fn from(v: IntervalDayTimeChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<IntervalYearMonthType>> for Series

fn from(v: IntervalYearMonthChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<LargeListType>> for Series

fn from(v: LargeListChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<Time32MillisecondType>> for Series

fn from(v: Time32MillisecondChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<Time32SecondType>> for Series

fn from(v: Time32SecondChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<Time64MicrosecondType>> for Series

fn from(v: ChunkedArray<Time64MicrosecondType>) -> Series

Performs the conversion.

impl From<ChunkedArray<Time64NanosecondType>> for Series

fn from(v: ChunkedArray<Time64NanosecondType>) -> Series

Performs the conversion.

impl From<ChunkedArray<TimestampMicrosecondType>> for Series

fn from(v: TimestampMicrosecondChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<TimestampMillisecondType>> for Series

fn from(v: TimestampMillisecondChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<TimestampNanosecondType>> for Series

fn from(v: TimestampNanosecondChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<TimestampSecondType>> for Series

fn from(v: TimestampSecondChunked) -> Series

Performs the conversion.

impl From<ChunkedArray<UInt16Type>> for Series

fn from(v: ChunkedArray<UInt16Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<UInt32Type>> for Series

fn from(v: ChunkedArray<UInt32Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<UInt64Type>> for Series

fn from(v: ChunkedArray<UInt64Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<UInt8Type>> for Series

fn from(v: ChunkedArray<UInt8Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<Utf8Type>> for Series

fn from(v: ChunkedArray<Utf8Type>) -> Series

Performs the conversion.

impl From<ChunkedArray<Utf8Type>> for Vec<Option<String>>

fn from(ca: Utf8Chunked) -> Self

Performs the conversion.

impl<T> FromIterator<(AlignedVec<<T as ArrowPrimitiveType>::Native>, (usize, Option<Buffer>))> for ChunkedArray<T> where
    T: PolarsNumericType, 

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

Creates a value from an iterator.

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

FromIterator trait

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

Creates a value from an iterator.

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

fn from_par_iter<I: IntoParallelIterator<Item = Option<T::Native>>>(
    iter: I
) -> Self

Creates an instance of the collection from the parallel iterator par_iter.

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>
) -> Vec<(Option<usize>, Option<usize>)>

fn par_hash_join_inner(&self, _other: &ChunkedArray<T>) -> Vec<(usize, usize)>

fn par_hash_join_left(
    &self,
    _other: &ChunkedArray<T>
) -> Vec<(usize, Option<usize>)>

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 = NumericChunkIterDispatch<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

type Item = T::Native

type IntoIter = Box<dyn Iterator<Item = Self::Item> + 'a>

fn into_no_null_iter(self) -> Self::IntoIter

impl<T: PolarsDataType> IntoSeries for ChunkedArray<T>

fn into_series(self) -> Series

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

type Item = T::Native

type TakeRandom = NumTakeRandomDispatch<'a, T>

fn take_rand(&self) -> Self::TakeRandom

Create a type that implements TakeRandom.

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, N, '_> Mul<N> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumCast,
    N: Num + ToPrimitive,
    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: N) -> Self::Output

Performs the * operation.

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

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

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

fn new_from_opt_iter(
    name: &str,
    it: impl Iterator<Item = Option<T::Native>>
) -> ChunkedArray<T>

Create a new ChunkedArray from an iterator.

fn new_from_iter(
    name: &str,
    it: impl Iterator<Item = T::Native>
) -> ChunkedArray<T>

Create a new ChunkedArray from an iterator.

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, '_> 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, N, '_> Sub<N> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumCast,
    N: Num + ToPrimitive,
    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: N) -> Self::Output

Performs the - operation.

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

type Item = T::Native

fn get(&self, index: usize) -> Option<Self::Item>

Get a nullable value by index.

unsafe fn get_unchecked(&self, index: usize) -> Self::Item

Get a value by index and ignore the null bit.

impl TryInto<ChunkedArray<BooleanType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<BooleanType>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Date32Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Date32Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Date64Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Date64Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<DurationMicrosecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<DurationMicrosecondChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<DurationMillisecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<DurationMillisecondChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<DurationNanosecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<DurationNanosecondType>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<DurationSecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<DurationSecondChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Float32Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Float32Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Float64Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Float64Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Int16Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Int16Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Int32Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Int32Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Int64Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Int64Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Int8Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Int8Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<IntervalDayTimeType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<IntervalDayTimeChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<IntervalYearMonthType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<IntervalYearMonthChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<LargeListType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<LargeListChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Time32MillisecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Time32MillisecondChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Time32SecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Time32SecondChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Time64MicrosecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Time64MicrosecondType>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Time64NanosecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Time64NanosecondType>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<TimestampMicrosecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<TimestampMicrosecondChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<TimestampMillisecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<TimestampMillisecondChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<TimestampNanosecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<TimestampNanosecondChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<TimestampSecondType>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<TimestampSecondChunked, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<UInt16Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<UInt16Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<UInt32Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<UInt32Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<UInt64Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<UInt64Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<UInt8Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<UInt8Type>, Self::Error>

Performs the conversion.

impl TryInto<ChunkedArray<Utf8Type>> for Series

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ChunkedArray<Utf8Type>, Self::Error>

Performs the conversion.

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>>