Type Alias polars_core::datatypes::BinaryChunked

pub type BinaryChunked = ChunkedArray<BinaryType>;

Aliased Type

struct BinaryChunked { /* private fields */ }

Implementations

impl BinaryChunked

pub fn apply_mut<'a, F>(&'a self, f: F) -> Self

where F: FnMut(&'a [u8]) -> &'a [u8],

impl BinaryChunked

pub unsafe fn to_string_unchecked(&self) -> StringChunked

Safety

String is not validated

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

Available on crate feature algorithm_group_by only.

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

Safety

impl ChunkAggSeries for BinaryChunked

fn sum_reduce(&self) -> Scalar

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

fn max_reduce(&self) -> Scalar

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

fn min_reduce(&self) -> Scalar

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

fn prod_reduce(&self) -> Scalar

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]> for BinaryChunked

type FuncRet = Cow<'a, [u8]>

fn apply_values<F>(&'a self, f: F) -> Self

where 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 apply<F>(&'a self, f: F) -> Self

where F: Fn(Option<&'a [u8]>) -> Option<Cow<'a, [u8]>> + Copy,

Apply a closure elementwise including null values.

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<BinaryViewArrayGeneric<[u8]>> for BinaryChunked

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

Apply kernel and return result as a new ChunkedArray.

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

where S: PolarsDataType,

Apply a kernel that outputs an array of different type.

impl ChunkCast for BinaryChunked

fn cast_with_options( &self, data_type: &DataType, options: CastOptions ) -> PolarsResult<Series>

Cast a ChunkedArray to DataType

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

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

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

Cast a ChunkedArray to DataType

impl ChunkCompare<&[u8]> for BinaryChunked

type Item = ChunkedArray<BooleanType>

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

Check for equality.

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

Check for equality where None == None.

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

Check for inequality.

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

Check for inequality where None == None.

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 equal_missing(&self, rhs: &BinaryChunked) -> BooleanChunked

Check for equality where None == None.

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

Check for inequality.

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

Check for inequality where None == None.

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

Less than comparison.

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

Less than or equal comparison

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

Greater than comparison.

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

Greater 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 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 for BinaryChunked

fn reverse(&self) -> Self

Return a reversed version of this array.

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

fn scatter_single<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 scatter_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 sort_with(&self, options: SortOptions) -> ChunkedArray<BinaryType>

fn sort(&self, descending: bool) -> ChunkedArray<BinaryType>

Returned a sorted ChunkedArray.

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

Retrieve the indexes needed to sort this array.

fn arg_sort_multiple( &self, by: &[Series], options: &SortMultipleOptions ) -> PolarsResult<IdxCa>

Retrieve the indexes need to sort this and the other arrays.

impl ChunkTakeUnchecked<ChunkedArray<UInt32Type>> for BinaryChunked

unsafe fn take_unchecked(&self, indices: &IdxCa) -> Self

Gather values from ChunkedArray by index.

impl<I: AsRef<[IdxSize]> + ?Sized> ChunkTakeUnchecked<I> for BinaryChunked

unsafe fn take_unchecked(&self, indices: &I) -> Self

Gather values from ChunkedArray by index.

impl ChunkUnique for BinaryChunked

Available on crate feature algorithm_group_by only.

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 n_unique(&self) -> PolarsResult<usize>

Number of unique values in the ChunkedArray

impl Debug for BinaryChunked

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

Formats the value using the given formatter.

impl<Ptr> FromIterator<Option<Ptr>> for BinaryChunked

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

where Ptr: PolarsAsRef<[u8]>,

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

Creates a value from an iterator.

impl<Ptr> FromParallelIterator<Option<Ptr>> for BinaryChunked

where Ptr: AsRef<[u8]> + Send + Sync,

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

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

impl<Ptr> FromParallelIterator<Ptr> for BinaryChunked

where Ptr: PolarsAsRef<[u8]> + Send + Sync + NoOption,

fn from_par_iter<I: IntoParallelIterator<Item = Ptr>>(iter: I) -> Self

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

impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for BinaryChunked

where Ptr: AsRef<[u8]>,

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

impl<Ptr> FromTrustedLenIterator<Ptr> for BinaryChunked

where Ptr: PolarsAsRef<[u8]>,

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

impl IntoGroupsProxy for BinaryChunked

Available on crate feature algorithm_group_by only.

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

Create the tuples need for a group_by operation. * The first value in the tuple is the first index of the group. * The second value in the tuple is 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>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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 BinaryChunked

where 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 VecHash for BinaryChunked

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

Compute the hash for all values in the array.

fn vec_hash_combine( &self, random_state: RandomState, hashes: &mut [u64] ) -> PolarsResult<()>