Trait polars::prelude::PhysicalExpr

source ·

pub trait PhysicalExpr: Send + Sync {
    // Required methods
    fn evaluate(
        &self,
        df: &DataFrame,
        _state: &ExecutionState
    ) -> Result<Series, PolarsError>;
    fn evaluate_on_groups<'a>(
        &self,
        df: &DataFrame,
        groups: &'a GroupsProxy,
        state: &ExecutionState
    ) -> Result<AggregationContext<'a>, PolarsError>;
    fn to_field(&self, input_schema: &Schema) -> Result<Field, PolarsError>;

    // Provided methods
    fn as_expression(&self) -> Option<&Expr> { ... }
    fn as_partitioned_aggregator(&self) -> Option<&dyn PartitionedAggregation> { ... }
    fn as_stats_evaluator(&self) -> Option<&dyn StatsEvaluator> { ... }
    fn is_literal(&self) -> bool { ... }
}

Available on crate feature lazy only.

Expand description

Take a DataFrame and evaluate the expressions. Implement this for Column, lt, eq, etc

Required Methods§

source

fn evaluate( &self, df: &DataFrame, _state: &ExecutionState ) -> Result<Series, PolarsError>

Take a DataFrame and evaluate the expression.

source

fn evaluate_on_groups<'a>( &self, df: &DataFrame, groups: &'a GroupsProxy, state: &ExecutionState ) -> Result<AggregationContext<'a>, PolarsError>

Some expression that are not aggregations can be done per group Think of sort, slice, filter, shift, etc. defaults to ignoring the group

This method is called by an aggregation function.

In case of a simple expr, like ‘column’, the groups are ignored and the column is returned. In case of an expr where group behavior makes sense, this method is called. For a filter operation for instance, a Series is created per groups and filtered.

An implementation of this method may apply an aggregation on the groups only. For instance on a shift, the groups are first aggregated to a ListChunked and the shift is applied per group. The implementation then has to return the Series exploded (because a later aggregation will use the group tuples to aggregate). The group tuples also have to be updated, because aggregation to a list sorts the exploded Series by group.

This has some gotcha’s. An implementation may also change the group tuples instead of the Series.

source