Enum AExpr

pub enum AExpr {
    Explode(Node),
    Alias(Node, PlSmallStr),
    Column(PlSmallStr),
    Literal(LiteralValue),
    BinaryExpr {
        left: Node,
        op: Operator,
        right: Node,
    },
    Cast {
        expr: Node,
        dtype: DataType,
        options: CastOptions,
    },
    Sort {
        expr: Node,
        options: SortOptions,
    },
    Gather {
        expr: Node,
        idx: Node,
        returns_scalar: bool,
    },
    SortBy {
        expr: Node,
        by: Vec<Node>,
        sort_options: SortMultipleOptions,
    },
    Filter {
        input: Node,
        by: Node,
    },
    Agg(IRAggExpr),
    Ternary {
        predicate: Node,
        truthy: Node,
        falsy: Node,
    },
    AnonymousFunction {
        input: Vec<ExprIR>,
        function: OpaqueColumnUdf,
        output_type: GetOutput,
        options: FunctionOptions,
    },
    Function {
        input: Vec<ExprIR>,
        function: FunctionExpr,
        options: FunctionOptions,
    },
    Window {
        function: Node,
        partition_by: Vec<Node>,
        order_by: Option<(Node, SortOptions)>,
        options: WindowType,
    },
    Slice {
        input: Node,
        offset: Node,
        length: Node,
    },
    Len,
}

IR expression node that is allocated in an Arena.

Variants

Explode(Node)

Alias(Node, PlSmallStr)

Column(PlSmallStr)

Literal(LiteralValue)

BinaryExpr

Fields

left: Node

op: Operator

right: Node

Cast

Fields

expr: Node

dtype: DataType

options: CastOptions

Sort

Fields

expr: Node

options: SortOptions

Gather

Fields

expr: Node

idx: Node

returns_scalar: bool

SortBy

Fields

expr: Node

by: Vec<Node>

sort_options: SortMultipleOptions

Filter

Fields

input: Node

by: Node

Agg(IRAggExpr)

Ternary

Fields

predicate: Node

truthy: Node

falsy: Node

AnonymousFunction

Fields

input: Vec<ExprIR>

function: OpaqueColumnUdf

output_type: GetOutput

options: FunctionOptions

Function

Fields

input: Vec<ExprIR>

Function arguments Some functions rely on aliases, for instance assignment of struct fields. Therefor we need [ExprIr].

function: FunctionExpr

function to apply

options: FunctionOptions

Window

Fields

function: Node

partition_by: Vec<Node>

order_by: Option<(Node, SortOptions)>

options: WindowType

Slice

Fields

input: Node

offset: Node

length: Node

Len

Implementations

impl AExpr

pub fn to_dtype( &self, schema: &Schema, ctx: Context, arena: &Arena<AExpr>, ) -> PolarsResult<DataType>

pub fn to_field( &self, schema: &Schema, ctx: Context, arena: &Arena<AExpr>, ) -> PolarsResult<Field>

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

pub fn to_field_and_validate( &self, schema: &Schema, ctx: Context, arena: &Arena<AExpr>, ) -> PolarsResult<Field>

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

pub fn to_field_impl( &self, ctx: &mut ToFieldContext<'_>, agg_list: &mut bool, ) -> PolarsResult<Field>

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

This is taken as &mut bool as for some expressions this is determined by the upper node (e.g. alias, cast).

impl AExpr

pub fn inputs_rev<E>(&self, container: &mut E)

where E: Extend<Node>,

Push the inputs of this node to the given container, in reverse order. This ensures the primary node responsible for the name is pushed last.

pub fn replace_inputs(self, inputs: &[Node]) -> Self

impl AExpr

pub fn get_type( &self, schema: &Schema, ctxt: Context, arena: &Arena<AExpr>, ) -> PolarsResult<DataType>

This should be a 1 on 1 copy of the get_type method of Expr until Expr is completely phased out.

Trait Implementations

impl Clone for AExpr

fn clone(&self) -> AExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AExpr

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

Formats the value using the given formatter.

impl Default for AExpr

fn default() -> AExpr

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AExpr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AExpr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.