Enum polars::prelude::Expr

pub enum Expr {
    Alias(Box<Expr, Global>, Arc<String>),
    Column(Arc<String>),
    Literal(ScalarValue),
    BinaryExpr {
        left: Box<Expr, Global>,
        op: Operator,
        right: Box<Expr, Global>,
    },
    Not(Box<Expr, Global>),
    IsNotNull(Box<Expr, Global>),
    IsNull(Box<Expr, Global>),
    Cast {
        expr: Box<Expr, Global>,
        data_type: DataType,
    },
    Sort {
        expr: Box<Expr, Global>,
        reverse: bool,
    },
    Agg(AggExpr),
    Ternary {
        predicate: Box<Expr, Global>,
        truthy: Box<Expr, Global>,
        falsy: Box<Expr, Global>,
    },
    Udf {
        input: Box<Expr, Global>,
        function: Arc<dyn SeriesUdf + 'static>,
        output_type: Option<DataType>,
    },
    Shift {
        input: Box<Expr, Global>,
        periods: i32,
    },
    Reverse(Box<Expr, Global>),
    Duplicated(Box<Expr, Global>),
    Unique(Box<Expr, Global>),
    Explode(Box<Expr, Global>),
    Window {
        function: Box<Expr, Global>,
        partition_by: Box<Expr, Global>,
        order_by: Option<Box<Expr, Global>>,
    },
    Wildcard,
    Slice {
        input: Box<Expr, Global>,
        offset: isize,
        length: usize,
    },
    BinaryFunction {
        input_a: Box<Expr, Global>,
        input_b: Box<Expr, Global>,
        function: Arc<dyn SeriesBinaryUdf + 'static>,
        output_field: Arc<dyn BinaryUdfOutputField + 'static>,
    },
}

Queries consists of multiple expressions.

Variants

Alias(Box<Expr, Global>, Arc<String>)

Column(Arc<String>)

Literal(ScalarValue)

BinaryExpr

Fields of BinaryExpr

left: Box<Expr, Global>op: Operatorright: Box<Expr, Global>

Not(Box<Expr, Global>)

IsNotNull(Box<Expr, Global>)

IsNull(Box<Expr, Global>)

Cast

Fields of Cast

expr: Box<Expr, Global>data_type: DataType

Sort

Fields of Sort

expr: Box<Expr, Global>reverse: bool

Agg(AggExpr)

Ternary

Fields of Ternary

predicate: Box<Expr, Global>truthy: Box<Expr, Global>falsy: Box<Expr, Global>

Udf

Fields of Udf

input: Box<Expr, Global>function: Arc<dyn SeriesUdf + 'static>output_type: Option<DataType>

Shift

Fields of Shift

input: Box<Expr, Global>periods: i32

Reverse(Box<Expr, Global>)

Duplicated(Box<Expr, Global>)

Unique(Box<Expr, Global>)

Explode(Box<Expr, Global>)

Window

See postgres window functions

Fields of Window

function: Box<Expr, Global>

Also has the input. i.e. avg("foo")

partition_by: Box<Expr, Global>order_by: Option<Box<Expr, Global>>

Wildcard

Slice

Fields of Slice

input: Box<Expr, Global>offset: isize

length is not yet known so we accept negative offsets

length: usize

BinaryFunction

Fields of BinaryFunction

input_a: Box<Expr, Global>input_b: Box<Expr, Global>function: Arc<dyn SeriesBinaryUdf + 'static>output_field: Arc<dyn BinaryUdfOutputField + 'static>

Delays output type evaluation until input schema is known.

Implementations

impl Expr

pub fn get_type(
    &self,
    schema: &Schema,
    context: Context
) -> Result<DataType, PolarsError>

Get DataType result of the expression. The schema is the input data.

impl Expr

pub fn eq(self, other: Expr) -> Expr

Compare Expr with other Expr on equality

pub fn neq(self, other: Expr) -> Expr

Compare Expr with other Expr on non-equality

pub fn lt(self, other: Expr) -> Expr

Check if Expr < Expr

pub fn gt(self, other: Expr) -> Expr

Check if Expr > Expr

pub fn gt_eq(self, other: Expr) -> Expr

Check if Expr >= Expr

pub fn lt_eq(self, other: Expr) -> Expr

Check if Expr <= Expr

pub fn not(self) -> Expr

Negate Expr

pub fn alias(self, name: &str) -> Expr

Rename Column.

pub fn is_null(self) -> Expr

Run is_null operation on Expr.

pub fn is_not_null(self) -> Expr

Run is_not_null operation on Expr.

pub fn min(self) -> Expr

Reduce groups to minimal value.

pub fn max(self) -> Expr

Reduce groups to maximum value.

pub fn mean(self) -> Expr

Reduce groups to the mean value.

pub fn median(self) -> Expr

Reduce groups to the median value.

pub fn sum(self) -> Expr

Reduce groups to the sum of all the values.

pub fn n_unique(self) -> Expr

Get the number of unique values in the groups.

pub fn first(self) -> Expr

Get the first value in the group.

pub fn last(self) -> Expr

Get the last value in the group.

pub fn list(self) -> Expr

Aggregate the group to a Series

pub fn quantile(self, quantile: f64) -> Expr

Compute the quantile per group.

pub fn agg_groups(self) -> Expr

Get the group indexes of the group by operation.

pub fn explode(self) -> Expr

Explode the utf8/ list column

pub fn slice(self, offset: isize, length: usize) -> Expr

Slice the Series.

pub fn head(self, length: Option<usize>) -> Expr

Get the first n elements of the Expr result

pub fn tail(self, length: Option<usize>) -> Expr

Get the last n elements of the Expr result

pub fn cast(self, data_type: DataType) -> Expr

Cast expression to another data type.

pub fn sort(self, reverse: bool) -> Expr

Sort expression. See the eager implementation.

pub fn reverse(self) -> Expr

Reverse column

pub fn map<F>(self, function: F, output_type: Option<DataType>) -> Expr where
    F: SeriesUdf + 'static, 

Apply a function/closure once the logical plan get executed. It is the responsibility of the caller that the schema is correct by giving the correct output_type. If None given the output type of the input expr is used.

pub fn is_finite(self) -> Expr

Get mask of finite values if dtype is Float

pub fn is_infinite(self) -> Expr

Get mask of infinite values if dtype is Float

pub fn is_nan(self) -> Expr

Get mask of NaN values if dtype is Float

pub fn is_not_nan(self) -> Expr

Get inverse mask of NaN values if dtype is Float

pub fn shift(self, periods: i32) -> Expr

Shift the values in the array by some period. See the eager implementation.

pub fn cum_sum(self, reverse: bool) -> Expr

Get an array with the cumulative sum computed at every element

pub fn cum_min(self, reverse: bool) -> Expr

Get an array with the cumulative min computed at every element

pub fn cum_max(self, reverse: bool) -> Expr

Get an array with the cumulative max computed at every element

pub fn over(self, partition_by: Expr) -> Expr

Apply window function over a subgroup. This is similar to a groupby + aggregation + self join. Or similar to window functions in Postgres.

Example

#[macro_use] extern crate polars_core;
use polars_core::prelude::*;
use polars_lazy::prelude::*;

fn example() -> Result<()> {
    let df = df! {
            "groups" => &[1, 1, 2, 2, 1, 2, 3, 3, 1],
            "values" => &[1, 2, 3, 4, 5, 6, 7, 8, 8]
        }?;

    let out = df
     .lazy()
     .select(&[
         col("groups"),
         sum("values").over(col("groups")),
     ])
     .collect()?;
    dbg!(&out);
    Ok(())
}

Outputs:

╭────────┬────────╮
│ groups ┆ values │
│ ---    ┆ ---    │
│ i32    ┆ i32    │
╞════════╪════════╡
│ 1      ┆ 16     │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1      ┆ 16     │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 2      ┆ 13     │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 2      ┆ 13     │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ ...    ┆ ...    │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1      ┆ 16     │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 2      ┆ 13     │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 3      ┆ 15     │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 3      ┆ 15     │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1      ┆ 16     │
╰────────┴────────╯

pub fn fill_none(self, fill_value: Expr) -> Expr

Shift the values in the array by some period. See the eager implementation.

pub fn count(self) -> Expr

Count the values of the Series or Get counts of the group by operation.

pub fn std(self) -> Expr

Standard deviation of the values of the Series

pub fn var(self) -> Expr

Variance of the values of the Series

pub fn is_duplicated(self) -> Expr

Get a mask of duplicated values

pub fn is_unique(self) -> Expr

Get a mask of unique values

pub fn and(self, expr: Expr) -> Expr

and operation

pub fn or(self, expr: Expr) -> Expr

or operation

pub fn pow(self, exponent: f64) -> Expr

Raise expression to the power exponent

pub fn year(self) -> Expr

Get the year of a Date32/Date64

pub fn month(self) -> Expr

Get the month of a Date32/Date64

pub fn day(self) -> Expr

Get the month of a Date32/Date64

pub fn ordinal_day(self) -> Expr

Get the ordinal_day of a Date32/Date64

pub fn hour(self) -> Expr

Get the hour of a Date64/Time64

pub fn minute(self) -> Expr

Get the minute of a Date64/Time64

pub fn second(self) -> Expr

Get the second of a Date64/Time64

pub fn nanosecond(self) -> Expr

Get the nanosecond of a Time64

Trait Implementations

impl Add<Expr> for Expr

type Output = Expr

The resulting type after applying the + operator.

pub fn add(self, rhs: Expr) -> <Expr as Add<Expr>>::Output

Performs the + operation.

impl AsRef<Expr> for AggExpr

pub fn as_ref(&self) -> &Expr

Performs the conversion.

impl Clone for Expr

pub fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Div<Expr> for Expr

type Output = Expr

The resulting type after applying the / operator.

pub fn div(self, rhs: Expr) -> <Expr as Div<Expr>>::Output

Performs the / operation.

impl From<AggExpr> for Expr

pub fn from(agg: AggExpr) -> Expr

Performs the conversion.

impl Mul<Expr> for Expr

type Output = Expr

The resulting type after applying the * operator.

pub fn mul(self, rhs: Expr) -> <Expr as Mul<Expr>>::Output

Performs the * operation.

impl PartialEq<Expr> for Expr

pub fn eq(&self, other: &Expr) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Rem<Expr> for Expr

type Output = Expr

The resulting type after applying the % operator.

pub fn rem(self, rhs: Expr) -> <Expr as Rem<Expr>>::Output

Performs the % operation.

impl Sub<Expr> for Expr

type Output = Expr

The resulting type after applying the - operator.

pub fn sub(self, rhs: Expr) -> <Expr as Sub<Expr>>::Output

Performs the - operation.