Enum polars::prelude::LogicalPlan

pub enum LogicalPlan {
    Selection {
        input: Box<LogicalPlan, Global>,
        predicate: Expr,
    },
    Cache {
        input: Box<LogicalPlan, Global>,
    },
    CsvScan {
        path: PathBuf,
        schema: Arc<Schema>,
        has_header: bool,
        delimiter: u8,
        ignore_errors: bool,
        skip_rows: usize,
        stop_after_n_rows: Option<usize>,
        with_columns: Option<Vec<String, Global>>,
        predicate: Option<Expr>,
        aggregate: Vec<Expr, Global>,
        cache: bool,
    },
    ParquetScan {
        path: PathBuf,
        schema: Arc<Schema>,
        with_columns: Option<Vec<String, Global>>,
        predicate: Option<Expr>,
        aggregate: Vec<Expr, Global>,
        stop_after_n_rows: Option<usize>,
        cache: bool,
    },
    DataFrameScan {
        df: Arc<DataFrame>,
        schema: Arc<Schema>,
        projection: Option<Vec<Expr, Global>>,
        selection: Option<Expr>,
    },
    LocalProjection {
        expr: Vec<Expr, Global>,
        input: Box<LogicalPlan, Global>,
        schema: Arc<Schema>,
    },
    Projection {
        expr: Vec<Expr, Global>,
        input: Box<LogicalPlan, Global>,
        schema: Arc<Schema>,
    },
    Aggregate {
        input: Box<LogicalPlan, Global>,
        keys: Arc<Vec<Expr, Global>>,
        aggs: Vec<Expr, Global>,
        schema: Arc<Schema>,
        apply: Option<Arc<dyn DataFrameUdf + 'static>>,
    },
    Join {
        input_left: Box<LogicalPlan, Global>,
        input_right: Box<LogicalPlan, Global>,
        schema: Arc<Schema>,
        how: JoinType,
        left_on: Vec<Expr, Global>,
        right_on: Vec<Expr, Global>,
        allow_par: bool,
        force_par: bool,
    },
    HStack {
        input: Box<LogicalPlan, Global>,
        exprs: Vec<Expr, Global>,
        schema: Arc<Schema>,
    },
    Distinct {
        input: Box<LogicalPlan, Global>,
        maintain_order: bool,
        subset: Arc<Option<Vec<String, Global>>>,
    },
    Sort {
        input: Box<LogicalPlan, Global>,
        by_column: String,
        reverse: bool,
    },
    Explode {
        input: Box<LogicalPlan, Global>,
        columns: Vec<String, Global>,
    },
    Slice {
        input: Box<LogicalPlan, Global>,
        offset: i64,
        len: usize,
    },
    Melt {
        input: Box<LogicalPlan, Global>,
        id_vars: Arc<Vec<String, Global>>,
        value_vars: Arc<Vec<String, Global>>,
        schema: Arc<Schema>,
    },
    Udf {
        input: Box<LogicalPlan, Global>,
        function: Arc<dyn DataFrameUdf + 'static>,
        predicate_pd: bool,
        projection_pd: bool,
        schema: Option<Arc<Schema>>,
    },
}

Variants

Selection

Filter on a boolean mask

Fields of Selection

input: Box<LogicalPlan, Global>predicate: Expr

Cache

Cache the input at this point in the LP

Fields of Cache

input: Box<LogicalPlan, Global>

CsvScan

Scan a CSV file

Fields of CsvScan

path: PathBufschema: Arc<Schema>has_header: booldelimiter: u8ignore_errors: boolskip_rows: usizestop_after_n_rows: Option<usize>with_columns: Option<Vec<String, Global>>predicate: Option<Expr>

Filters at the scan level

aggregate: Vec<Expr, Global>

Aggregations at the scan level

cache: bool

ParquetScan

Scan a Parquet file

Fields of ParquetScan

path: PathBufschema: Arc<Schema>with_columns: Option<Vec<String, Global>>predicate: Option<Expr>aggregate: Vec<Expr, Global>stop_after_n_rows: Option<usize>cache: bool

DataFrameScan

In memory DataFrame

Fields of DataFrameScan

df: Arc<DataFrame>schema: Arc<Schema>projection: Option<Vec<Expr, Global>>selection: Option<Expr>

LocalProjection

Fields of LocalProjection

expr: Vec<Expr, Global>input: Box<LogicalPlan, Global>schema: Arc<Schema>

Projection

Column selection

Fields of Projection

expr: Vec<Expr, Global>input: Box<LogicalPlan, Global>schema: Arc<Schema>

Aggregate

Groupby aggregation

Fields of Aggregate

input: Box<LogicalPlan, Global>keys: Arc<Vec<Expr, Global>>aggs: Vec<Expr, Global>schema: Arc<Schema>apply: Option<Arc<dyn DataFrameUdf + 'static>>

Join

Join operation

Fields of Join

input_left: Box<LogicalPlan, Global>input_right: Box<LogicalPlan, Global>schema: Arc<Schema>how: JoinTypeleft_on: Vec<Expr, Global>right_on: Vec<Expr, Global>allow_par: boolforce_par: bool

HStack

Adding columns to the table without a Join

Fields of HStack

input: Box<LogicalPlan, Global>exprs: Vec<Expr, Global>schema: Arc<Schema>

Distinct

Remove duplicates from the table

Fields of Distinct

input: Box<LogicalPlan, Global>maintain_order: boolsubset: Arc<Option<Vec<String, Global>>>

Sort

Sort the table

Fields of Sort

input: Box<LogicalPlan, Global>by_column: Stringreverse: bool

Explode

An explode operation

Fields of Explode

input: Box<LogicalPlan, Global>columns: Vec<String, Global>

Slice

Slice the table

Fields of Slice

input: Box<LogicalPlan, Global>offset: i64len: usize

Melt

A Melt operation

Fields of Melt

input: Box<LogicalPlan, Global>id_vars: Arc<Vec<String, Global>>value_vars: Arc<Vec<String, Global>>schema: Arc<Schema>

Udf

A User Defined Function

Fields of Udf

input: Box<LogicalPlan, Global>function: Arc<dyn DataFrameUdf + 'static>predicate_pd: bool

allow predicate pushdown optimizations

projection_pd: bool

allow projection pushdown optimizations

schema: Option<Arc<Schema>>

Implementations

impl LogicalPlan

pub fn describe(&self) -> String

Trait Implementations

impl Clone for LogicalPlan

pub fn clone(&self) -> LogicalPlan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalPlan

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

Formats the value using the given formatter.

impl Default for LogicalPlan

pub fn default() -> LogicalPlan

Returns the “default value” for a type.

impl From<LogicalPlan> for LazyFrame

pub fn from(plan: LogicalPlan) -> LazyFrame

Performs the conversion.

impl From<LogicalPlan> for LogicalPlanBuilder

pub fn from(lp: LogicalPlan) -> LogicalPlanBuilder

Performs the conversion.