Trait polars_core::chunked_array::ops::ChunkCompare

pub trait ChunkCompare<Rhs> {
    fn eq_missing(&self, rhs: Rhs) -> BooleanChunked;
    fn eq(&self, rhs: Rhs) -> BooleanChunked;
    fn neq(&self, rhs: Rhs) -> BooleanChunked;
    fn gt(&self, rhs: Rhs) -> BooleanChunked;
    fn gt_eq(&self, rhs: Rhs) -> BooleanChunked;
    fn lt(&self, rhs: Rhs) -> BooleanChunked;
    fn lt_eq(&self, rhs: Rhs) -> BooleanChunked;
}

Compare Series and ChunkedArray’s and get a boolean mask that can be used to filter rows.

Example

use polars_core::prelude::*;
fn filter_all_ones(df: &DataFrame) -> Result<DataFrame> {
    let mask = df
    .column("column_a")?
    .eq(1);

    df.filter(&mask)
}

Required methods

fn eq_missing(&self, rhs: Rhs) -> BooleanChunked

Check for equality and regard missing values as equal.

fn eq(&self, rhs: Rhs) -> BooleanChunked

Check for equality.

fn neq(&self, rhs: Rhs) -> BooleanChunked

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

Implementors

impl ChunkCompare<&'_ str> for Series

fn eq_missing(&self, rhs: &str) -> BooleanChunked

fn eq(&self, rhs: &str) -> BooleanChunked

fn neq(&self, rhs: &str) -> BooleanChunked

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

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

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

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

impl ChunkCompare<&'_ str> for Utf8Chunked

fn eq_missing(&self, rhs: &str) -> BooleanChunked

fn eq(&self, rhs: &str) -> BooleanChunked

fn neq(&self, rhs: &str) -> BooleanChunked

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

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

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

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

impl ChunkCompare<&'_ Series> for Series

fn eq(&self, rhs: &Series) -> BooleanChunked

Create a boolean mask by checking for equality.

fn neq(&self, rhs: &Series) -> BooleanChunked

Create a boolean mask by checking for inequality.

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

Create a boolean mask by checking if lhs > rhs.

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

Create a boolean mask by checking if lhs >= rhs.

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

Create a boolean mask by checking if lhs < rhs.

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

Create a boolean mask by checking if lhs <= rhs.

fn eq_missing(&self, rhs: &Series) -> BooleanChunked

impl ChunkCompare<&'_ ChunkedArray<BooleanType>> for BooleanChunked

fn eq_missing(&self, rhs: &BooleanChunked) -> BooleanChunked

fn eq(&self, rhs: &BooleanChunked) -> BooleanChunked

fn neq(&self, rhs: &BooleanChunked) -> BooleanChunked

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

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

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

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

impl ChunkCompare<&'_ ChunkedArray<ListType>> for ListChunked

fn eq_missing(&self, rhs: &ListChunked) -> BooleanChunked

fn eq(&self, rhs: &ListChunked) -> BooleanChunked

fn neq(&self, rhs: &ListChunked) -> BooleanChunked

fn gt(&self, _rhs: &ListChunked) -> BooleanChunked

fn gt_eq(&self, _rhs: &ListChunked) -> BooleanChunked

fn lt(&self, _rhs: &ListChunked) -> BooleanChunked

fn lt_eq(&self, _rhs: &ListChunked) -> BooleanChunked

impl ChunkCompare<&'_ ChunkedArray<Utf8Type>> for Utf8Chunked

fn eq_missing(&self, rhs: &Utf8Chunked) -> BooleanChunked

fn eq(&self, rhs: &Utf8Chunked) -> BooleanChunked

fn neq(&self, rhs: &Utf8Chunked) -> BooleanChunked

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

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

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

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

impl<Rhs> ChunkCompare<Rhs> for Series where
    Rhs: NumComp, 

fn eq_missing(&self, rhs: Rhs) -> BooleanChunked

fn eq(&self, rhs: Rhs) -> BooleanChunked

fn neq(&self, rhs: Rhs) -> BooleanChunked

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

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

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

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

impl<T> ChunkCompare<&'_ ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumComp, 

fn eq_missing(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

fn eq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

fn neq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

fn gt(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

fn gt_eq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

fn lt(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

fn lt_eq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

impl<T, Rhs> ChunkCompare<Rhs> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumCast,
    Rhs: NumComp + ToPrimitive, 

fn eq_missing(&self, rhs: Rhs) -> BooleanChunked

fn eq(&self, rhs: Rhs) -> BooleanChunked

fn neq(&self, rhs: Rhs) -> BooleanChunked

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

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

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

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