Type Alias polars_core::datatypes::BinaryOffsetChunked

pub type BinaryOffsetChunked = ChunkedArray<BinaryOffsetType>;

Aliased Type

struct BinaryOffsetChunked { /* private fields */ }

Trait Implementations

impl ChunkAnyValue for BinaryOffsetChunked

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 ChunkCast for BinaryOffsetChunked

fn cast(&self, data_type: &DataType) -> 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

impl ChunkExpandAtIndex<BinaryOffsetType> for BinaryOffsetChunked

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

Create a new ChunkedArray filled with values at that index.

impl ChunkFilter<BinaryOffsetType> for BinaryOffsetChunked

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

Filter values in the ChunkedArray with a boolean mask.

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

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

Create a ChunkedArray with a single value.

impl ChunkFullNull for BinaryOffsetChunked

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

impl ChunkReverse for BinaryOffsetChunked

fn reverse(&self) -> Self

Return a reversed version of this array.

impl ChunkShift<BinaryOffsetType> for BinaryOffsetChunked

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

impl ChunkShiftFill<BinaryOffsetType, Option<&[u8]>> for BinaryOffsetChunked

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

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

impl ChunkSort<BinaryOffsetType> for BinaryOffsetChunked

fn arg_sort_multiple( &self, by: &[Series], options: &SortMultipleOptions ) -> 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) -> BinaryOffsetChunked

fn sort(&self, descending: bool) -> BinaryOffsetChunked

Returned a sorted ChunkedArray.

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

Retrieve the indexes needed to sort this array.

impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for BinaryOffsetChunked

where Ptr: AsRef<[u8]>,

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

impl<Ptr> FromTrustedLenIterator<Ptr> for BinaryOffsetChunked

where Ptr: PolarsAsRef<[u8]>,

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

impl IntoGroupsProxy for BinaryOffsetChunked

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 BinaryOffsetChunked

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

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<BinaryOffsetType> 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 ValueSize for BinaryOffsetChunked

fn get_values_size(&self) -> usize

Get the values size that is still “visible” to the underlying array. E.g. take the offsets into account.

impl VecHash for BinaryOffsetChunked

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