Struct Logical

pub struct Logical<Logical, Physical>(pub ChunkedArray<Physical>, _, pub Option<DataType>)
where
    Logical: PolarsDataType,
    Physical: PolarsDataType;

Maps a logical type to a chunked array implementation of the physical type. This saves a lot of compiler bloat and allows us to reuse functionality.

Tuple Fields

0: ChunkedArray<Physical>

2: Option<DataType>

Implementations

impl Logical<DecimalType, Int128Type>

pub fn precision(&self) -> Option<usize>

pub fn scale(&self) -> usize

pub fn to_scale( &self, scale: usize, ) -> Result<Cow<'_, Logical<DecimalType, Int128Type>>, PolarsError>

impl<K, T> Logical<K, T>

where K: PolarsDataType, T: PolarsDataType,

pub fn new_logical<J>(ca: ChunkedArray<T>) -> Logical<J, T>

where J: PolarsDataType,

impl<K, T> Logical<K, T>

where K: PolarsDataType, T: PolarsDataType, Logical<K, T>: LogicalType,

pub fn physical(&self) -> &ChunkedArray<T>

pub fn field(&self) -> Field

impl Logical<DateType, Int32Type>

pub fn as_date_iter(&self) -> impl TrustedLen

pub fn from_naive_date<I>( name: PlSmallStr, v: I, ) -> Logical<DateType, Int32Type>

where I: IntoIterator<Item = NaiveDate>,

Construct a new DateChunked from an iterator over NaiveDate.

pub fn to_string( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Date into String with the given format. See chrono strftime/strptime.

pub fn strftime( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Date into String with the given format. See chrono strftime/strptime.

Alias for to_string.

pub fn from_naive_date_options<I>( name: PlSmallStr, v: I, ) -> Logical<DateType, Int32Type>

where I: IntoIterator<Item = Option<NaiveDate>>,

Construct a new DateChunked from an iterator over optional NaiveDate.

impl Logical<DatetimeType, Int64Type>

pub fn as_datetime_iter(&self) -> impl TrustedLen

pub fn time_unit(&self) -> TimeUnit

pub fn time_zone(&self) -> &Option<PlSmallStr>

pub fn to_string( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Datetime into String with the given format. See chrono strftime/strptime.

pub fn strftime( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Datetime into String with the given format. See chrono strftime/strptime.

Alias for to_string.

pub fn from_naive_datetime<I>( name: PlSmallStr, v: I, tu: TimeUnit, ) -> Logical<DatetimeType, Int64Type>

where I: IntoIterator<Item = NaiveDateTime>,

Construct a new DatetimeChunked from an iterator over NaiveDateTime.

pub fn from_naive_datetime_options<I>( name: PlSmallStr, v: I, tu: TimeUnit, ) -> Logical<DatetimeType, Int64Type>

where I: IntoIterator<Item = Option<NaiveDateTime>>,

pub fn cast_time_unit(&self, tu: TimeUnit) -> Logical<DatetimeType, Int64Type>

Change the underlying TimeUnit. And update the data accordingly.

pub fn set_time_unit(&mut self, time_unit: TimeUnit)

Change the underlying TimeUnit. This does not modify the data.

pub fn set_time_zone( &mut self, time_zone: PlSmallStr, ) -> Result<(), PolarsError>

Change the underlying TimeZone. This does not modify the data. This does not validate the time zone - it’s up to the caller to verify that it’s already been validated.

pub fn set_time_unit_and_time_zone( &mut self, time_unit: TimeUnit, time_zone: PlSmallStr, ) -> Result<(), PolarsError>

Change the underlying TimeUnit and TimeZone. This does not modify the data. This does not validate the time zone - it’s up to the caller to verify that it’s already been validated.

impl Logical<DurationType, Int64Type>

pub fn time_unit(&self) -> TimeUnit

pub fn cast_time_unit(&self, tu: TimeUnit) -> Logical<DurationType, Int64Type>

Change the underlying TimeUnit. And update the data accordingly.

pub fn set_time_unit(&mut self, tu: TimeUnit)

Change the underlying TimeUnit. This does not modify the data.

pub fn to_string( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Duration to String; note that strftime format strings are not supported, only the specifiers ‘iso’ and ‘polars’.

pub fn from_duration<I>( name: PlSmallStr, v: I, tu: TimeUnit, ) -> Logical<DurationType, Int64Type>

where I: IntoIterator<Item = TimeDelta>,

Construct a new DurationChunked from an iterator over ChronoDuration.

pub fn from_duration_options<I>( name: PlSmallStr, v: I, tu: TimeUnit, ) -> Logical<DurationType, Int64Type>

where I: IntoIterator<Item = Option<TimeDelta>>,

Construct a new DurationChunked from an iterator over optional ChronoDuration.

impl Logical<TimeType, Int64Type>

pub fn to_string(&self, format: &str) -> ChunkedArray<StringType>

Convert from Time into String with the given format. See chrono strftime/strptime.

pub fn strftime(&self, format: &str) -> ChunkedArray<StringType>

Convert from Time into String with the given format. See chrono strftime/strptime.

Alias for to_string.

pub fn as_time_iter(&self) -> impl TrustedLen

pub fn from_naive_time<I>( name: PlSmallStr, v: I, ) -> Logical<TimeType, Int64Type>

where I: IntoIterator<Item = NaiveTime>,

Construct a new TimeChunked from an iterator over NaiveTime.

pub fn from_naive_time_options<I>( name: PlSmallStr, v: I, ) -> Logical<TimeType, Int64Type>

where I: IntoIterator<Item = Option<NaiveTime>>,

Construct a new TimeChunked from an iterator over optional NaiveTime.

Methods from Deref<Target = ChunkedArray<T>>

pub fn append(&mut self, other: &ChunkedArray<T>) -> Result<(), PolarsError>

Append in place. This is done by adding the chunks of other to this ChunkedArray.

See also extend for appends to the underlying memory

pub fn append_owned( &mut self, other: ChunkedArray<T>, ) -> Result<(), PolarsError>

Append in place. This is done by adding the chunks of other to this ChunkedArray.

See also extend for appends to the underlying memory

pub fn apply_nonnull_values_generic<'a, U, K, F>( &'a self, dtype: DataType, op: F, ) -> ChunkedArray<U>

where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> K, <U as PolarsDataType>::Array: ArrayFromIterDtype<K> + ArrayFromIterDtype<Option<K>>,

Applies a function only to the non-null elements, propagating nulls.

pub fn try_apply_nonnull_values_generic<'a, U, K, F, E>( &'a self, op: F, ) -> Result<ChunkedArray<U>, E>

where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> Result<K, E>, <U as PolarsDataType>::Array: ArrayFromIter<K> + ArrayFromIter<Option<K>>,

Applies a function only to the non-null elements, propagating nulls.

pub fn apply_into_string_amortized<'a, F>( &'a self, f: F, ) -> ChunkedArray<StringType>

where F: FnMut(<T as PolarsDataType>::Physical<'a>, &mut String),

pub fn try_apply_into_string_amortized<'a, F, E>( &'a self, f: F, ) -> Result<ChunkedArray<StringType>, E>

where F: FnMut(<T as PolarsDataType>::Physical<'a>, &mut String) -> Result<(), E>,

pub fn cast_and_apply_in_place<F, S>(&self, f: F) -> ChunkedArray<S>

where F: Fn(<S as PolarsNumericType>::Native) -> <S as PolarsNumericType>::Native + Copy, S: PolarsNumericType,

Cast a numeric array to another numeric data type and apply a function in place. This saves an allocation.

pub fn apply_mut<F>(&mut self, f: F)

where F: Fn(<T as PolarsNumericType>::Native) -> <T as PolarsNumericType>::Native + Copy,

pub fn len(&self) -> usize

Get the length of the ChunkedArray

pub fn null_count(&self) -> usize

Return the number of null values in the ChunkedArray.

pub unsafe fn set_null_count(&mut self, null_count: usize)

Set the null count directly.

This can be useful after mutably adjusting the validity of the underlying arrays.

Safety

The new null count must match the total null count of the underlying arrays.

pub fn is_empty(&self) -> bool

Check if ChunkedArray is empty.

pub fn rechunk(&self) -> Cow<'_, ChunkedArray<T>>

Rechunks this ChunkedArray, returning a new Cow::Owned ChunkedArray if it was rechunked or simply a Cow::Borrowed of itself if it was already a single chunk.

pub fn rechunk_mut(&mut self)

Rechunks this ChunkedArray in-place.

pub fn rechunk_validity(&self) -> Option<Bitmap>

pub fn with_validities(&mut self, validities: &[Option<Bitmap>])

pub fn split_at(&self, offset: i64) -> (ChunkedArray<T>, ChunkedArray<T>)

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

When offset is negative it will be counted from the end of the array. This method will never error, and will slice the best match when offset, or length is out of bounds

pub fn slice(&self, offset: i64, length: usize) -> ChunkedArray<T>

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

When offset is negative it will be counted from the end of the array. This method will never error, and will slice the best match when offset, or length is out of bounds

pub fn limit(&self, num_elements: usize) -> ChunkedArray<T>

where ChunkedArray<T>: Sized,

Take a view of top n elements

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

where ChunkedArray<T>: Sized,

Get the head of the ChunkedArray

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

where ChunkedArray<T>: Sized,

Get the tail of the ChunkedArray

pub fn prune_empty_chunks(&mut self)

Remove empty chunks.

pub fn extend(&mut self, other: &ChunkedArray<T>) -> Result<(), PolarsError>

Extend the memory backed by this array with the values from other.

Different from ChunkedArray::append which adds chunks to this ChunkedArray extend appends the data from other to the underlying PrimitiveArray and thus may cause a reallocation.

However if this does not cause a reallocation, the resulting data structure will not have any extra chunks and thus will yield faster queries.

Prefer extend over append when you want to do a query after a single append. For instance during online operations where you add n rows and rerun a query.

Prefer append over extend when you want to append many times before doing a query. For instance when you read in multiple files and when to store them in a single DataFrame. In the latter case finish the sequence of append operations with a rechunk.

pub fn for_each<'a, F>(&'a self, op: F)

where F: FnMut(Option<<T as PolarsDataType>::Physical<'a>>),

pub fn is_null(&self) -> ChunkedArray<BooleanType>

Get a mask of the null values.

pub fn is_not_null(&self) -> ChunkedArray<BooleanType>

Get a mask of the valid values.

pub fn rolling_map_float<F>( &self, window_size: usize, f: F, ) -> Result<ChunkedArray<T>, PolarsError>

where F: FnMut(&mut ChunkedArray<T>) -> Option<<T as PolarsNumericType>::Native>,

Apply a rolling custom function. This is pretty slow because of dynamic dispatch.

pub fn is_nan(&self) -> ChunkedArray<BooleanType>

pub fn is_not_nan(&self) -> ChunkedArray<BooleanType>

pub fn is_finite(&self) -> ChunkedArray<BooleanType>

pub fn is_infinite(&self) -> ChunkedArray<BooleanType>

pub fn none_to_nan(&self) -> ChunkedArray<T>

Convert missing values to NaN values.

pub fn to_canonical(&self) -> ChunkedArray<T>

pub fn iter(&self) -> impl PolarsIterator

pub fn to_ndarray( &self, ) -> Result<ArrayBase<ViewRepr<&<T as PolarsNumericType>::Native>, Dim<[usize; 1]>>, PolarsError>

If data is aligned in a single chunk and has no Null values a zero copy view is returned as an ndarray

pub fn to_bytes_hashes<'a>( &'a self, multithreaded: bool, hb: RandomState, ) -> Vec<Vec<BytesHash<'a>>>

pub unsafe fn with_chunks(&self, chunks: Vec<Box<dyn Array>>) -> ChunkedArray<T>

Safety

The Arrow datatype of all chunks must match the PolarsDataType T.

pub fn sample_n( &self, n: usize, with_replacement: bool, shuffle: bool, seed: Option<u64>, ) -> Result<ChunkedArray<T>, PolarsError>

Sample n datapoints from this ChunkedArray.

pub fn sample_frac( &self, frac: f64, with_replacement: bool, shuffle: bool, seed: Option<u64>, ) -> Result<ChunkedArray<T>, PolarsError>

Sample a fraction between 0.0-1.0 of this ChunkedArray.

pub fn to_vec(&self) -> Vec<Option<<T as PolarsNumericType>::Native>>

Convert to a Vec of Option<T::Native>.

pub fn to_vec_null_aware( &self, ) -> Either<Vec<<T as PolarsNumericType>::Native>, Vec<Option<<T as PolarsNumericType>::Native>>>

Convert to a Vec but don’t return Option<T::Native> if there are no null values

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

Series to ChunkedArray<T>

pub fn unset_fast_explode_list(&mut self)

pub fn set_fast_explode_list(&mut self, value: bool)

pub fn get_fast_explode_list(&self) -> bool

pub fn get_flags(&self) -> StatisticsFlags

pub fn is_sorted_flag(&self) -> IsSorted

pub fn retain_flags_from<U>( &mut self, from: &ChunkedArray<U>, retain_flags: StatisticsFlags, )

where U: PolarsDataType,

pub fn set_sorted_flag(&mut self, sorted: IsSorted)

Set the ‘sorted’ bit meta info.

pub fn with_sorted_flag(&self, sorted: IsSorted) -> ChunkedArray<T>

Set the ‘sorted’ bit meta info.

pub fn first_non_null(&self) -> Option<usize>

Get the index of the first non null value in this ChunkedArray.

pub fn last_non_null(&self) -> Option<usize>

Get the index of the last non null value in this ChunkedArray.

pub fn drop_nulls(&self) -> ChunkedArray<T>

pub fn iter_validities( &self, ) -> Map<Iter<'_, Box<dyn Array>>, fn(&Box<dyn Array>) -> Option<&Bitmap>>

Get the buffer of bits representing null values

pub fn has_nulls(&self) -> bool

Return if any the chunks in this ChunkedArray have nulls.

pub fn shrink_to_fit(&mut self)

Shrink the capacity of this array to fit its length.

pub fn clear(&self) -> ChunkedArray<T>

pub fn chunk_lengths( &self, ) -> Map<Iter<'_, Box<dyn Array>>, fn(&Box<dyn Array>) -> usize>

Returns an iterator over the lengths of the chunks of the array.

pub fn chunks(&self) -> &Vec<Box<dyn Array>>

A reference to the chunks

pub unsafe fn chunks_mut(&mut self) -> &mut Vec<Box<dyn Array>>

A mutable reference to the chunks

Safety

The caller must ensure to not change the DataType or length of any of the chunks. And the null_count remains correct.

pub fn is_optimal_aligned(&self) -> bool

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

pub fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

pub fn name(&self) -> &PlSmallStr

Name of the ChunkedArray.

pub fn ref_field(&self) -> &Field

Get a reference to the field.

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

Rename this ChunkedArray.

pub fn get(&self, idx: usize) -> Option<<T as PolarsDataType>::Physical<'_>>

Get a single value from this ChunkedArray. If the return values is None this indicates a NULL value.

Panics

This function will panic if idx is out of bounds.

pub unsafe fn get_unchecked( &self, idx: usize, ) -> Option<<T as PolarsDataType>::Physical<'_>>

Get a single value from this ChunkedArray. If the return values is None this indicates a NULL value.

Safety

It is the callers responsibility that the idx < self.len().

pub unsafe fn value_unchecked( &self, idx: usize, ) -> <T as PolarsDataType>::Physical<'_>

Get a single value from this ChunkedArray. Null values are ignored and the returned value could be garbage if it was masked out by NULL. Note that the value always is initialized.

Safety

It is the callers responsibility that the idx < self.len().

pub fn first(&self) -> Option<<T as PolarsDataType>::Physical<'_>>

pub fn last(&self) -> Option<<T as PolarsDataType>::Physical<'_>>

pub fn layout(&self) -> ChunkedArrayLayout<'_, T>

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

Returns the values of the array as a contiguous slice.

pub fn data_views(&self) -> impl DoubleEndedIterator

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 into_no_null_iter( &self, ) -> impl Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen

pub unsafe fn group_tuples_perfect( &self, num_groups: usize, multithreaded: bool, group_capacity: usize, ) -> GroupsType

Use the indexes as perfect groups.

Safety

This ChunkedArray must contain each value in [0..num_groups) at least once, and nothing outside this range.

pub fn lhs_sub<N>(&self, lhs: N) -> ChunkedArray<T>

where N: Num + NumCast,

Apply lhs - self

pub fn lhs_div<N>(&self, lhs: N) -> ChunkedArray<T>

where N: Num + NumCast,

Apply lhs / self

pub fn lhs_rem<N>(&self, lhs: N) -> ChunkedArray<T>

where N: Num + NumCast,

Apply lhs % self

Trait Implementations

impl Add for &Logical<DecimalType, Int128Type>

type Output = Result<Logical<DecimalType, Int128Type>, PolarsError>

The resulting type after applying the + operator.

fn add( self, rhs: &Logical<DecimalType, Int128Type>, ) -> <&Logical<DecimalType, Int128Type> as Add>::Output

Performs the + operation.

impl<K, T> Clone for Logical<K, T>

where K: PolarsDataType, T: PolarsDataType,

fn clone(&self) -> Logical<K, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DateMethods for Logical<DateType, Int32Type>

fn parse_from_str_slice( name: PlSmallStr, v: &[&str], fmt: &str, ) -> Logical<DateType, Int32Type>

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

Extract month from underlying NaiveDate representation. Returns the year number in the calendar date.

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

Extract year from underlying NaiveDate representation. Returns whether the year is a leap year.

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

This year number might not match the calendar year number.

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

Extract month from underlying NaiveDateTime representation. Quarters range from 1 to 4.

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

Extract month from underlying NaiveDateTime representation. Returns the month number starting from 1.

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

Returns the ISO week number starting from 1. The return value ranges from 1 to 53. (The last week of year differs by years.)

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

Extract day from underlying NaiveDate representation. Returns the day of month starting from 1.

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

Returns the day of year starting from 1.

fn new_from_parts( year: &ChunkedArray<Int32Type>, month: &ChunkedArray<Int8Type>, day: &ChunkedArray<Int8Type>, name: PlSmallStr, ) -> Result<Logical<DateType, Int32Type>, PolarsError>

Construct a date ChunkedArray from individual time components.

impl DatetimeMethods for Logical<DatetimeType, Int64Type>

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

Extract month from underlying NaiveDateTime representation. Returns the year number in the calendar date.

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

Extract year from underlying NaiveDate representation. Returns whether the year is a leap year.

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

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

Extract quarter from underlying NaiveDateTime representation. Quarters range from 1 to 4.

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

Extract month from underlying NaiveDateTime representation. Returns the month number starting from 1.

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

Extract ISO weekday from underlying NaiveDateTime representation. Returns the weekday number where monday = 1 and sunday = 7

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

Returns the ISO week number starting from 1. The return value ranges from 1 to 53. (The last week of year differs by years.)

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

Extract day from underlying NaiveDateTime representation. Returns the day of month starting from 1.

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

Extract hour from underlying NaiveDateTime representation. Returns the hour number from 0 to 23.

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

Extract minute from underlying NaiveDateTime representation. Returns the minute number from 0 to 59.

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

Extract second from underlying NaiveDateTime representation. Returns the second number from 0 to 59.

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

Extract second from underlying NaiveDateTime representation. Returns the number of nanoseconds since the whole non-leap second. The range from 1,000,000,000 to 1,999,999,999 represents the leap second.

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

Returns the day of year starting from 1.

fn parse_from_str_slice( name: PlSmallStr, v: &[&str], fmt: &str, tu: TimeUnit, ) -> Logical<DatetimeType, Int64Type>

fn new_from_parts( year: &ChunkedArray<Int32Type>, month: &ChunkedArray<Int8Type>, day: &ChunkedArray<Int8Type>, hour: &ChunkedArray<Int8Type>, minute: &ChunkedArray<Int8Type>, second: &ChunkedArray<Int8Type>, nanosecond: &ChunkedArray<Int32Type>, ambiguous: &ChunkedArray<StringType>, time_unit: &TimeUnit, time_zone: Option<&str>, name: PlSmallStr, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

Construct a datetime ChunkedArray from individual time components.

impl<K, T> Default for Logical<K, T>

where K: PolarsDataType, T: PolarsDataType,

fn default() -> Logical<K, T>

Returns the “default value” for a type.

impl<K, T> Deref for Logical<K, T>

where K: PolarsDataType, T: PolarsDataType,

type Target = ChunkedArray<T>

The resulting type after dereferencing.

fn deref(&self) -> &<Logical<K, T> as Deref>::Target

Dereferences the value.

impl<K, T> DerefMut for Logical<K, T>

where K: PolarsDataType, T: PolarsDataType,

fn deref_mut(&mut self) -> &mut <Logical<K, T> as Deref>::Target

Mutably dereferences the value.

impl Div for &Logical<DecimalType, Int128Type>

type Output = Result<Logical<DecimalType, Int128Type>, PolarsError>

The resulting type after applying the / operator.

fn div( self, rhs: &Logical<DecimalType, Int128Type>, ) -> <&Logical<DecimalType, Int128Type> as Div>::Output

Performs the / operation.

impl DurationMethods for Logical<DurationType, Int64Type>

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

Extract the hours from a Duration

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

Extract the days from a Duration

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

Extract the seconds from a Duration

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

Extract the seconds from a Duration

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

Extract the milliseconds from a Duration

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

Extract the microseconds from a Duration

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

Extract the nanoseconds from a Duration

impl From<ChunkedArray<Int32Type>> for Logical<DateType, Int32Type>

fn from(ca: ChunkedArray<Int32Type>) -> Logical<DateType, Int32Type>

Converts to this type from the input type.

impl From<ChunkedArray<Int64Type>> for Logical<TimeType, Int64Type>

fn from(ca: ChunkedArray<Int64Type>) -> Logical<TimeType, Int64Type>

Converts to this type from the input type.

impl From<Logical<DateType, Int32Type>> for Series

fn from(a: Logical<DateType, Int32Type>) -> Series

Converts to this type from the input type.

impl From<Logical<DatetimeType, Int64Type>> for Series

fn from(a: Logical<DatetimeType, Int64Type>) -> Series

Converts to this type from the input type.

impl From<Logical<DurationType, Int64Type>> for Series

fn from(a: Logical<DurationType, Int64Type>) -> Series

Converts to this type from the input type.

impl From<Logical<TimeType, Int64Type>> for Series

fn from(a: Logical<TimeType, Int64Type>) -> Series

Converts to this type from the input type.

impl IntoSeries for Logical<DateType, Int32Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for Logical<DatetimeType, Int64Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for Logical<DecimalType, Int128Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for Logical<DurationType, Int64Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for Logical<TimeType, Int64Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl LogicalType for Logical<DateType, Int32Type>

fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

fn get_any_value(&self, i: usize) -> Result<AnyValue<'_>, PolarsError>

Gets AnyValue from LogicalType

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

Safety

fn cast_with_options( &self, dtype: &DataType, cast_options: CastOptions, ) -> Result<Series, PolarsError>

fn cast(&self, dtype: &DataType) -> Result<Series, PolarsError>

impl LogicalType for Logical<DatetimeType, Int64Type>

fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

fn get_any_value(&self, i: usize) -> Result<AnyValue<'_>, PolarsError>

Gets AnyValue from LogicalType

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

Safety

fn cast_with_options( &self, dtype: &DataType, cast_options: CastOptions, ) -> Result<Series, PolarsError>

fn cast(&self, dtype: &DataType) -> Result<Series, PolarsError>

impl LogicalType for Logical<DecimalType, Int128Type>

fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

fn get_any_value(&self, i: usize) -> Result<AnyValue<'_>, PolarsError>

Gets AnyValue from LogicalType

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

Safety

fn cast_with_options( &self, dtype: &DataType, cast_options: CastOptions, ) -> Result<Series, PolarsError>

fn cast(&self, dtype: &DataType) -> Result<Series, PolarsError>

impl LogicalType for Logical<DurationType, Int64Type>

fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

fn get_any_value(&self, i: usize) -> Result<AnyValue<'_>, PolarsError>

Gets AnyValue from LogicalType

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

Safety

fn cast_with_options( &self, dtype: &DataType, cast_options: CastOptions, ) -> Result<Series, PolarsError>

fn cast(&self, dtype: &DataType) -> Result<Series, PolarsError>

impl LogicalType for Logical<TimeType, Int64Type>

fn dtype(&self) -> &'static DataType

Get data type of ChunkedArray.

fn get_any_value(&self, i: usize) -> Result<AnyValue<'_>, PolarsError>

Gets AnyValue from LogicalType

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

Safety

fn cast_with_options( &self, dtype: &DataType, cast_options: CastOptions, ) -> Result<Series, PolarsError>

fn cast(&self, dtype: &DataType) -> Result<Series, PolarsError>

impl Mul for &Logical<DecimalType, Int128Type>

type Output = Result<Logical<DecimalType, Int128Type>, PolarsError>

The resulting type after applying the * operator.

fn mul( self, rhs: &Logical<DecimalType, Int128Type>, ) -> <&Logical<DecimalType, Int128Type> as Mul>::Output

Performs the * operation.

impl<T> NamedFrom<T, [NaiveDate]> for Logical<DateType, Int32Type>

where T: AsRef<[NaiveDate]>,

fn new(name: PlSmallStr, v: T) -> Logical<DateType, Int32Type>

Initialize by name and values.

impl<T> NamedFrom<T, [NaiveDateTime]> for Logical<DatetimeType, Int64Type>

where T: AsRef<[NaiveDateTime]>,

fn new(name: PlSmallStr, v: T) -> Logical<DatetimeType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [NaiveTime]> for Logical<TimeType, Int64Type>

where T: AsRef<[NaiveTime]>,

fn new(name: PlSmallStr, v: T) -> Logical<TimeType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<NaiveDate>]> for Logical<DateType, Int32Type>

where T: AsRef<[Option<NaiveDate>]>,

fn new(name: PlSmallStr, v: T) -> Logical<DateType, Int32Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<NaiveDateTime>]> for Logical<DatetimeType, Int64Type>

where T: AsRef<[Option<NaiveDateTime>]>,

fn new(name: PlSmallStr, v: T) -> Logical<DatetimeType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<NaiveTime>]> for Logical<TimeType, Int64Type>

where T: AsRef<[Option<NaiveTime>]>,

fn new(name: PlSmallStr, v: T) -> Logical<TimeType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<TimeDelta>]> for Logical<DurationType, Int64Type>

where T: AsRef<[Option<TimeDelta>]>,

fn new(name: PlSmallStr, v: T) -> Logical<DurationType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [TimeDelta]> for Logical<DurationType, Int64Type>

where T: AsRef<[TimeDelta]>,

fn new(name: PlSmallStr, v: T) -> Logical<DurationType, Int64Type>

Initialize by name and values.

impl PolarsRound for Logical<DateType, Int32Type>

fn round( &self, every: &ChunkedArray<StringType>, _tz: Option<&Tz>, ) -> Result<Logical<DateType, Int32Type>, PolarsError>

impl PolarsRound for Logical<DatetimeType, Int64Type>

fn round( &self, every: &ChunkedArray<StringType>, tz: Option<&Tz>, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

impl PolarsTruncate for Logical<DateType, Int32Type>

fn truncate( &self, _tz: Option<&Tz>, every: &ChunkedArray<StringType>, ) -> Result<Logical<DateType, Int32Type>, PolarsError>

impl PolarsTruncate for Logical<DatetimeType, Int64Type>

fn truncate( &self, tz: Option<&Tz>, every: &ChunkedArray<StringType>, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

impl Sub for &Logical<DecimalType, Int128Type>

type Output = Result<Logical<DecimalType, Int128Type>, PolarsError>

The resulting type after applying the - operator.

fn sub( self, rhs: &Logical<DecimalType, Int128Type>, ) -> <&Logical<DecimalType, Int128Type> as Sub>::Output

Performs the - operation.

impl TimeMethods for Logical<TimeType, Int64Type>

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

Extract hour from underlying NaiveDateTime representation. Returns the hour number from 0 to 23.

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

Extract minute from underlying NaiveDateTime representation. Returns the minute number from 0 to 59.

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

Extract second from underlying NaiveDateTime representation. Returns the second number from 0 to 59.

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

Extract second from underlying NaiveDateTime representation. Returns the number of nanoseconds since the whole non-leap second. The range from 1,000,000,000 to 1,999,999,999 represents the leap second.

fn parse_from_str_slice( name: PlSmallStr, v: &[&str], fmt: &str, ) -> Logical<TimeType, Int64Type>