Struct Logical 

pub struct Logical<Logical, Physical>
where
    Logical: PolarsDataType,
    Physical: PolarsDataType,
{
    pub phys: ChunkedArray<Physical>,
    pub dtype: DataType,
    /* private fields */
}

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.

Fields

phys: ChunkedArray<Physical>

dtype: DataType

Implementations

impl<T> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

pub fn sort_with( &self, options: SortOptions, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

pub fn sort( &self, descending: bool, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

Returned a sorted ChunkedArray.

pub fn arg_sort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

impl Logical<DecimalType, Int128Type>

pub fn precision(&self) -> usize

pub fn scale(&self) -> usize

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

pub fn into_phys_with_prec_scale_or_sentinel( &self, prec: usize, scale: usize, sentinel: i128, ) -> ChunkedArray<Int128Type>

Converts self to a physical representation with the given precision and scale, returning the given sentinel value instead for values which don’t fit in the given precision and scale. This can be useful for comparisons.

impl<T> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

pub fn is_enum(&self) -> bool

pub fn uses_lexical_ordering(&self) -> bool

Return whether or not the CategoricalChunked uses the lexical order of the string values when sorting.

pub fn full_null_with_dtype( name: PlSmallStr, length: usize, dtype: DataType, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

pub fn from_cats_and_dtype( cat_ids: ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>, dtype: DataType, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

Create a CategoricalChunked from a physical array and dtype.

Checks that all the category ids are valid, mapping invalid ones to nulls.

pub unsafe fn from_cats_and_dtype_unchecked( cat_ids: ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>, dtype: DataType, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

Create a CategoricalChunked from a physical array and dtype.

Safety

It’s not checked that the indices are in-bounds or that the dtype is correct.

pub fn get_mapping(&self) -> &Arc<CategoricalMapping>

Get a reference to the mapping of categorical types to the string values.

pub fn iter_str(&self) -> impl PolarsIterator

Create an Iterator that iterates over the &str values of the CategoricalChunked.

pub fn from_str_iter<'a, I>( name: PlSmallStr, dtype: DataType, strings: I, ) -> Result<Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, PolarsError>

where I: IntoIterator<Item = Option<&'a str>>,

Converts from strings to this CategoricalChunked.

If this dtype is an Enum any non-existing strings get mapped to null.

pub fn to_arrow( &self, compat_level: CompatLevel, ) -> DictionaryArray<<T as PolarsCategoricalType>::Native>

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

where K: PolarsDataType, T: PolarsDataType,

pub unsafe fn new_logical( phys: ChunkedArray<T>, dtype: DataType, ) -> Logical<K, T>

Safety

You must uphold the logical types’ invariants.

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

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

pub fn name(&self) -> &PlSmallStr

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

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn null_count(&self) -> usize

pub fn has_nulls(&self) -> bool

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

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

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

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

pub fn field(&self) -> Field

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

pub fn physical_mut(&mut self) -> &mut ChunkedArray<T>

pub fn into_physical(self) -> ChunkedArray<T>

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

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: TimeZone) -> 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: TimeZone, ) -> 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.

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<T> ChunkAggSeries for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: ChunkAgg<<T as PolarsCategoricalType>::Native>,

fn min_reduce(&self) -> Scalar

Get the min 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 sum_reduce(&self) -> Scalar

Get the sum 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<T> ChunkCompareEq<&ChunkedArray<StringType>> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: for<'a> ChunkCompareEq<<T as PolarsCategoricalType>::Native, Item = ChunkedArray<BooleanType>>,

type Item = ChunkedArray<BooleanType>

fn equal( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&ChunkedArray<StringType>>>::Item

Check for equality.

fn equal_missing( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&ChunkedArray<StringType>>>::Item

Check for equality where None == None.

fn not_equal( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&ChunkedArray<StringType>>>::Item

Check for inequality.

fn not_equal_missing( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&ChunkedArray<StringType>>>::Item

Check for inequality where None == None.

impl<T> ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: for<'a> ChunkCompareEq<&'a ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>, Item = ChunkedArray<BooleanType>>,

type Item = Result<ChunkedArray<BooleanType>, PolarsError>

fn equal( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Check for equality.

fn equal_missing( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Check for equality where None == None.

fn not_equal( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Check for inequality.

fn not_equal_missing( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Check for inequality where None == None.

impl<T> ChunkCompareEq<&str> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: for<'a> ChunkCompareEq<<T as PolarsCategoricalType>::Native, Item = ChunkedArray<BooleanType>>,

type Item = ChunkedArray<BooleanType>

fn equal( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&str>>::Item

Check for equality.

fn equal_missing( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&str>>::Item

Check for equality where None == None.

fn not_equal( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&str>>::Item

Check for inequality.

fn not_equal_missing( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&str>>::Item

Check for inequality where None == None.

impl<T> ChunkCompareIneq<&ChunkedArray<StringType>> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

type Item = Result<ChunkedArray<BooleanType>, PolarsError>

fn gt( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&ChunkedArray<StringType>>>::Item

Greater than comparison.

fn gt_eq( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&ChunkedArray<StringType>>>::Item

Greater than or equal comparison.

fn lt( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&ChunkedArray<StringType>>>::Item

Less than comparison.

fn lt_eq( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&ChunkedArray<StringType>>>::Item

Less than or equal comparison

impl<T> ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: for<'a> ChunkCompareIneq<&'a ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>, Item = ChunkedArray<BooleanType>>,

type Item = Result<ChunkedArray<BooleanType>, PolarsError>

fn gt( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Greater than comparison.

fn gt_eq( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Greater than or equal comparison.

fn lt( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Less than comparison.

fn lt_eq( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Less than or equal comparison

impl<T> ChunkCompareIneq<&str> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

type Item = ChunkedArray<BooleanType>

fn gt( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&str>>::Item

Greater than comparison.

fn gt_eq( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&str>>::Item

Greater than or equal comparison.

fn lt( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&str>>::Item

Less than comparison.

fn lt_eq( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&str>>::Item

Less than or equal comparison

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

where K: PolarsDataType, T: PolarsDataType,

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

Returns a duplicate 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 days_in_month(&self) -> ChunkedArray<Int8Type>

Returns the number of days in the month of the underlying NaiveDate representation.

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 days_in_month(&self) -> ChunkedArray<Int8Type>

Returns the number of days in the month of the underlying NaiveDateTime representation.

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<TimeZone>, name: PlSmallStr, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

Construct a datetime ChunkedArray from individual time components.

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<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<T> IntoSeries for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

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<T> LogicalType for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

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