Enum polars_plan::logical_plan::AExpr

pub enum AExpr {
    Explode(Node),
    Alias(Node, Arc<str>),
    Column(Arc<str>),
    Literal(LiteralValue),
    BinaryExpr {
        left: Node,
        op: Operator,
        right: Node,
    },
    Cast {
        expr: Node,
        data_type: DataType,
        strict: bool,
    },
    Sort {
        expr: Node,
        options: SortOptions,
    },
    Gather {
        expr: Node,
        idx: Node,
        returns_scalar: bool,
    },
    SortBy {
        expr: Node,
        by: Vec<Node>,
        descending: Vec<bool>,
    },
    Filter {
        input: Node,
        by: Node,
    },
    Agg(AAggExpr),
    Ternary {
        predicate: Node,
        truthy: Node,
        falsy: Node,
    },
    AnonymousFunction {
        input: Vec<Node>,
        function: SpecialEq<Arc<dyn SeriesUdf>>,
        output_type: GetOutput,
        options: FunctionOptions,
    },
    Function {
        input: Vec<Node>,
        function: FunctionExpr,
        options: FunctionOptions,
    },
    Window {
        function: Node,
        partition_by: Vec<Node>,
        options: WindowType,
    },
    Wildcard,
    Slice {
        input: Node,
        offset: Node,
        length: Node,
    },
    Len,
    Nth(i64),
}

Variants

Explode(Node)

Alias(Node, Arc<str>)

Column(Arc<str>)

Literal(LiteralValue)

BinaryExpr

Fields

left: Node

op: Operator

right: Node

Cast

Fields

expr: Node

data_type: DataType

strict: bool

Sort

Fields

expr: Node

options: SortOptions

Gather

Fields

expr: Node

idx: Node

returns_scalar: bool

SortBy

Fields

expr: Node

by: Vec<Node>

descending: Vec<bool>

Filter

Fields

input: Node

by: Node

Agg(AAggExpr)

Ternary

Fields

predicate: Node

truthy: Node

falsy: Node

AnonymousFunction

Fields

input: Vec<Node>

function: SpecialEq<Arc<dyn SeriesUdf>>

output_type: GetOutput

options: FunctionOptions

Function

Fields

input: Vec<Node>

function arguments

function: FunctionExpr

function to apply

options: FunctionOptions

Window

Fields

function: Node

partition_by: Vec<Node>

options: WindowType

Wildcard

Slice

Fields

input: Node

offset: Node

length: Node

Len

Nth(i64)

Implementations

impl AExpr

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

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

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 Hash for AExpr

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl UpperExp for AExpr

Hack UpperExpr trait to get a kind of formatting that doesn’t traverse the nodes. So we can format with {foo:E}

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

Formats the value using the given formatter.