Type Definition polars_core::datatypes::BinaryChunked

pub type BinaryChunked = ChunkedArray<BinaryType>;

Available on crate feature dtype-binary only.

Trait Implementations

impl Add<&[u8]> for &BinaryChunked

type Output = ChunkedArray<BinaryType>

The resulting type after applying the + operator.

fn add(self, rhs: &[u8]) -> Self::Output

Performs the + operation.

impl Add<&ChunkedArray<BinaryType>> for &BinaryChunked

type Output = ChunkedArray<BinaryType>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ChunkedArray<BinaryType>> for BinaryChunked

type Output = ChunkedArray<BinaryType>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AggList for BinaryChunked

unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series

Safety

impl ArgAgg for BinaryChunked

fn arg_min(&self) -> Option<usize>

Get the index of the minimal value

fn arg_max(&self) -> Option<usize>

Get the index of the maximal value

impl ChunkAggSeries for BinaryChunked

fn sum_as_series(&self) -> Series

Get the sum of the ChunkedArray as a new Series of length 1.

fn max_as_series(&self) -> Series

Get the max of the ChunkedArray as a new Series of length 1.

fn min_as_series(&self) -> Series

Get the min of the ChunkedArray as a new Series of length 1.

fn prod_as_series(&self) -> Series

Get the product of the ChunkedArray as a new Series of length 1.

impl ChunkAnyValue for BinaryChunked

unsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>

Get a single value. Beware this is slow. If you need to use this slightly performant, cast Categorical to UInt32

fn get_any_value(&self, index: usize) -> PolarsResult<AnyValue<'_>>

Get a single value. Beware this is slow.

impl<'a> ChunkApply<'a, &'a [u8], Cow<'a, [u8]>> for BinaryChunked

fn apply_cast_numeric<F, S>(&'a self, f: F) -> ChunkedArray<S>where
    F: Fn(&'a [u8]) -> S::Native + Copy,
    S: PolarsNumericType,

Apply a closure elementwise and cast to a Numeric ChunkedArray. This is fastest when the null check branching is more expensive than the closure application.

fn branch_apply_cast_numeric_no_null<F, S>(&'a self, f: F) -> ChunkedArray<S>where
    F: Fn(Option<&'a [u8]>) -> S::Native + Copy,
    S: PolarsNumericType,

Apply a closure on optional values and cast to Numeric ChunkedArray without null values.

fn apply<F>(&'a self, f: F) -> Selfwhere
    F: Fn(&'a [u8]) -> Cow<'a, [u8]> + Copy,

Apply a closure elementwise. This is fastest when the null check branching is more expensive than the closure application. Often it is.

fn try_apply<F>(&'a self, f: F) -> PolarsResult<Self>where
    F: Fn(&'a [u8]) -> PolarsResult<Cow<'a, [u8]>> + Copy,

fn apply_on_opt<F>(&'a self, f: F) -> Selfwhere
    F: Fn(Option<&'a [u8]>) -> Option<Cow<'a, [u8]>> + Copy,

Apply a closure elementwise including null values.

fn apply_with_idx<F>(&'a self, f: F) -> Selfwhere
    F: Fn((usize, &'a [u8])) -> Cow<'a, [u8]> + Copy,

Apply a closure elementwise. The closure gets the index of the element as first argument.

fn apply_with_idx_on_opt<F>(&'a self, f: F) -> Selfwhere
    F: Fn((usize, Option<&'a [u8]>)) -> Option<Cow<'a, [u8]>> + Copy,

Apply a closure elementwise. The closure gets the index of the element as first argument.

fn apply_to_slice<F, T>(&'a self, f: F, slice: &mut [T])where
    F: Fn(Option<&'a [u8]>, &T) -> T,

Apply a closure elementwise and write results to a mutable slice.

impl ChunkApplyKernel<BinaryArray<i64>> for BinaryChunked

fn apply_kernel(&self, f: &dyn Fn(&LargeBinaryArray) -> ArrayRef) -> Self

Apply kernel and return result as a new ChunkedArray.

fn apply_kernel_cast<S>(
    &self,
    f: &dyn Fn(&LargeBinaryArray) -> ArrayRef
) -> ChunkedArray<S>where
    S: PolarsDataType,

Apply a kernel that outputs an array of different type.

impl ChunkCast for BinaryChunked

fn cast(&self, data_type: &DataType) -> PolarsResult<Series>

Cast a [ChunkedArray] to [DataType]

fn cast_unchecked(&self, data_type: &DataType) -> PolarsResult<Series>

Does not check if the cast is a valid one and may over/underflow

impl ChunkCompare<&[u8]> for BinaryChunked

type Item = ChunkedArray<BooleanType>

fn equal(&self, rhs: &[u8]) -> BooleanChunked

Check for equality.

fn not_equal(&self, rhs: &[u8]) -> BooleanChunked

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl ChunkCompare<&ChunkedArray<BinaryType>> for BinaryChunked

type Item = ChunkedArray<BooleanType>

fn equal(&self, rhs: &BinaryChunked) -> BooleanChunked

Check for equality.

fn not_equal(&self, rhs: &BinaryChunked) -> BooleanChunked

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl ChunkExpandAtIndex<BinaryType> for BinaryChunked

fn new_from_index(&self, index: usize, length: usize) -> BinaryChunked

Create a new ChunkedArray filled with values at that index.

impl ChunkFillNull for BinaryChunked

fn fill_null(&self, strategy: FillNullStrategy) -> PolarsResult<Self>

Replace None values with one of the following strategies:

impl ChunkFillNullValue<&[u8]> for BinaryChunked

fn fill_null_with_values(&self, value: &[u8]) -> PolarsResult<Self>

Replace None values with a give value T.

impl ChunkFilter<BinaryType> for BinaryChunked

fn filter(
    &self,
    filter: &BooleanChunked
) -> PolarsResult<ChunkedArray<BinaryType>>

Filter values in the ChunkedArray with a boolean mask.

impl<'a> ChunkFull<&'a [u8]> for BinaryChunked

fn full(name: &str, value: &'a [u8], length: usize) -> Self

Create a ChunkedArray with a single value.

impl ChunkFullNull for BinaryChunked

fn full_null(name: &str, length: usize) -> Self

impl ChunkReverse<BinaryType> for BinaryChunked

fn reverse(&self) -> Self

Return a reversed version of this array.

impl<'a> ChunkSet<'a, &'a [u8], Vec<u8, Global>> for BinaryChunked

fn set_at_idx<I: IntoIterator<Item = IdxSize>>(
    &'a self,
    idx: I,
    opt_value: Option<&'a [u8]>
) -> PolarsResult<Self>where
    Self: Sized,

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

fn set_at_idx_with<I: IntoIterator<Item = IdxSize>, F>(
    &'a self,
    idx: I,
    f: F
) -> PolarsResult<Self>where
    Self: Sized,
    F: Fn(Option<&'a [u8]>) -> Option<Vec<u8>>,

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

fn set(
    &'a self,
    mask: &BooleanChunked,
    value: Option<&'a [u8]>
) -> PolarsResult<Self>where
    Self: Sized,

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

impl ChunkShift<BinaryType> for BinaryChunked

fn shift(&self, periods: i64) -> Self

impl ChunkShiftFill<BinaryType, Option<&[u8]>> for BinaryChunked

fn shift_and_fill(&self, periods: i64, fill_value: Option<&[u8]>) -> BinaryChunked

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

impl ChunkSort<BinaryType> for BinaryChunked

fn argsort_multiple(
    &self,
    other: &[Series],
    reverse: &[bool]
) -> PolarsResult<IdxCa>

Panics

This function is very opinionated. On the implementation of ChunkedArray<T> for numeric types, we assume that all numeric Series are of the same type.

In this case we assume that all numeric Series are f64 types. The caller needs to uphold this contract. If not, it will panic.

fn sort_with(&self, options: SortOptions) -> ChunkedArray<BinaryType>

fn sort(&self, reverse: bool) -> BinaryChunked

Returned a sorted ChunkedArray.

fn argsort(&self, options: SortOptions) -> IdxCa

Retrieve the indexes needed to sort this array.

impl ChunkTake for BinaryChunked

unsafe fn take_unchecked<I, INulls>(
    &self,
    indices: TakeIdx<'_, I, INulls>
) -> Selfwhere
    Self: Sized,
    I: TakeIterator,
    INulls: TakeIteratorNulls,

Take values from ChunkedArray by index.

fn take<I, INulls>(&self, indices: TakeIdx<'_, I, INulls>) -> PolarsResult<Self>where
    Self: Sized,
    I: TakeIterator,
    INulls: TakeIteratorNulls,

Take values from ChunkedArray by index. Note that the iterator will be cloned, so prefer an iterator that takes the owned memory by reference.

impl ChunkTakeEvery<BinaryType> for BinaryChunked

fn take_every(&self, n: usize) -> BinaryChunked

Traverse and collect every nth element in a new array.

impl ChunkUnique<BinaryType> for BinaryChunked

fn unique(&self) -> PolarsResult<Self>

Get unique values of a ChunkedArray

fn arg_unique(&self) -> PolarsResult<IdxCa>

Get first index of the unique values in a ChunkedArray. This Vec is sorted.

fn is_unique(&self) -> PolarsResult<BooleanChunked>

Get a mask of all the unique values.

fn is_duplicated(&self) -> PolarsResult<BooleanChunked>

Get a mask of all the duplicated values.

fn n_unique(&self) -> PolarsResult<usize>

Number of unique values in the ChunkedArray

fn mode(&self) -> PolarsResult<Self>

Available on crate feature mode only.

The most occurring value(s). Can return multiple Values

impl ChunkZip<BinaryType> for BinaryChunked

Available on crate feature zip_with only.

fn zip_with(
    &self,
    mask: &BooleanChunked,
    other: &BinaryChunked
) -> PolarsResult<BinaryChunked>

Create a new ChunkedArray with values from self where the mask evaluates true and values from other where the mask evaluates false

impl Debug for BinaryChunked

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

Formats the value using the given formatter.

impl From<(&str, BinaryArray<i64>)> for BinaryChunked

fn from(tpl: (&str, BinaryArray<i64>)) -> Self

Converts to this type from the input type.

impl<Ptr> FromIterator<Option<Ptr>> for BinaryChunkedwhere
    Ptr: AsRef<[u8]>,

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

Creates a value from an iterator.

impl<Ptr> FromIterator<Ptr> for BinaryChunkedwhere
    Ptr: PolarsAsRef<[u8]>,

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

Creates a value from an iterator.

impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for BinaryChunkedwhere
    Ptr: AsRef<[u8]>,

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

impl<Ptr> FromTrustedLenIterator<Ptr> for BinaryChunkedwhere
    Ptr: PolarsAsRef<[u8]>,

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

impl IntoGroupsProxy for BinaryChunked

fn group_tuples<'a>(
    &'a self,
    multithreaded: bool,
    sorted: bool
) -> PolarsResult<GroupsProxy>

Create the tuples need for a groupby operation. * The first value in the tuple is the first index of the group. * The second value in the tuple is are the indexes of the groups including the first value.

impl<'a> IntoIterator for &'a BinaryChunked

type Item = Option<&'a [u8]>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<BinaryType> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoTakeRandom<'a> for &'a BinaryChunked

type Item = &'a [u8]

type TakeRandom = TakeRandBranch2<BinaryTakeRandomSingleChunk<'a>, BinaryTakeRandom<'a>>

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

Create a type that implements TakeRandom.

impl IsFirst<BinaryType> for BinaryChunked

Available on crate feature is_first only.

fn is_first(&self) -> PolarsResult<BooleanChunked>

impl IsIn for BinaryChunked

Available on crate feature is_in only.

fn is_in(&self, other: &Series) -> PolarsResult<BooleanChunked>

Check if elements of this array are in the right Series, or List values of the right Series.

impl<'a, T: AsRef<[&'a [u8]]>> NamedFrom<T, [&'a [u8]]> for BinaryChunked

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<'a, T: AsRef<[Cow<'a, [u8]>]>> NamedFrom<T, [Cow<'a, [u8]>]> for BinaryChunked

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<'a, T: AsRef<[Option<&'a [u8]>]>> NamedFrom<T, [Option<&'a [u8]>]> for BinaryChunked

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<'a, T: AsRef<[Option<Cow<'a, [u8]>>]>> NamedFrom<T, [Option<Cow<'a, [u8]>>]> for BinaryChunked

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<B> NewChunkedArray<BinaryType, B> for BinaryChunkedwhere
    B: AsRef<[u8]>,

fn from_iter_values(name: &str, it: impl Iterator<Item = B>) -> Self

Create a new ChunkedArray from an iterator.

fn from_slice(name: &str, v: &[B]) -> Self

fn from_slice_options(name: &str, opt_v: &[Option<B>]) -> Self

fn from_iter_options(name: &str, it: impl Iterator<Item = Option<B>>) -> Self

Create a new ChunkedArray from an iterator.

impl NumOpsDispatch for BinaryChunked

fn add_to(&self, rhs: &Series) -> PolarsResult<Series>

fn subtract(&self, rhs: &Series) -> PolarsResult<Series>

fn multiply(&self, rhs: &Series) -> PolarsResult<Series>

fn divide(&self, rhs: &Series) -> PolarsResult<Series>

fn remainder(&self, rhs: &Series) -> PolarsResult<Series>

impl RepeatBy for BinaryChunked

Available on crate feature repeat_by only.

fn repeat_by(&self, by: &IdxCa) -> ListChunked

Repeat the values n times, where n is determined by the values in by.

impl<'a> TakeRandom for &'a BinaryChunked

type Item = &'a [u8]

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

Get a nullable value by index.

unsafe fn get_unchecked(&self, index: usize) -> Option<Self::Item>where
    Self: Sized,

Get a value by index and ignore the null bit.

impl ValueSize for BinaryChunked

fn get_values_size(&self) -> usize

Useful for a Utf8 or a List to get underlying value size. During a rechunk this is handy

impl VecHash for BinaryChunked

fn vec_hash(&self, random_state: RandomState, buf: &mut Vec<u64>)

Compute the hash for all values in the array.

fn vec_hash_combine(&self, random_state: RandomState, hashes: &mut [u64])

impl ZipOuterJoinColumn for BinaryChunked

fn zip_outer_join_column(
    &self,
    right_column: &Series,
    opt_join_tuples: &[(Option<IdxSize>, Option<IdxSize>)]
) -> Series