Enum polars_lazy::logical_plan::LogicalPlan

pub enum LogicalPlan {
    Selection {
        input: Box<LogicalPlan>,
        predicate: Expr,
    },
    Cache {
        input: Box<LogicalPlan>,
    },
    CsvScan {
        path: PathBuf,
        schema: SchemaRef,
        options: CsvParserOptions,
        predicate: Option<Expr>,
        aggregate: Vec<Expr>,
    },
    ParquetScan {
        path: PathBuf,
        schema: SchemaRef,
        predicate: Option<Expr>,
        aggregate: Vec<Expr>,
        options: ParquetOptions,
    },
    IpcScan {
        path: PathBuf,
        schema: SchemaRef,
        options: IpcScanOptions,
        predicate: Option<Expr>,
        aggregate: Vec<Expr>,
    },
    DataFrameScan {
        df: Arc<DataFrame>,
        schema: SchemaRef,
        projection: Option<Vec<Expr>>,
        selection: Option<Expr>,
    },
    LocalProjection {
        expr: Vec<Expr>,
        input: Box<LogicalPlan>,
        schema: SchemaRef,
    },
    Projection {
        expr: Vec<Expr>,
        input: Box<LogicalPlan>,
        schema: SchemaRef,
    },
    Aggregate {
        input: Box<LogicalPlan>,
        keys: Arc<Vec<Expr>>,
        aggs: Vec<Expr>,
        schema: SchemaRef,
        apply: Option<Arc<dyn DataFrameUdf>>,
        maintain_order: bool,
        options: GroupbyOptions,
    },
    Join {
        input_left: Box<LogicalPlan>,
        input_right: Box<LogicalPlan>,
        schema: SchemaRef,
        left_on: Vec<Expr>,
        right_on: Vec<Expr>,
        options: JoinOptions,
    },
    HStack {
        input: Box<LogicalPlan>,
        exprs: Vec<Expr>,
        schema: SchemaRef,
    },
    Distinct {
        input: Box<LogicalPlan>,
        options: DistinctOptions,
    },
    Sort {
        input: Box<LogicalPlan>,
        by_column: Vec<Expr>,
        args: SortArguments,
    },
    Explode {
        input: Box<LogicalPlan>,
        columns: Vec<String>,
    },
    Slice {
        input: Box<LogicalPlan>,
        offset: i64,
        len: u32,
    },
    Melt {
        input: Box<LogicalPlan>,
        id_vars: Arc<Vec<String>>,
        value_vars: Arc<Vec<String>>,
        schema: SchemaRef,
    },
    Udf {
        input: Box<LogicalPlan>,
        function: Arc<dyn DataFrameUdf>,
        options: LogicalPlanUdfOptions,
        schema: Option<SchemaRef>,
    },
    Union {
        inputs: Vec<LogicalPlan>,
        options: UnionOptions,
    },
    Error {
        input: Box<LogicalPlan>,
        err: Arc<Mutex<Option<PolarsError>>>,
    },
}

Variants

Selection

Fields

input: Box<LogicalPlan>

predicate: Expr

Filter on a boolean mask

Cache

Fields

input: Box<LogicalPlan>

Cache the input at this point in the LP

CsvScan

Fields

path: PathBuf

schema: SchemaRef

options: CsvParserOptions

predicate: Option<Expr>

Filters at the scan level

aggregate: Vec<Expr>

Aggregations at the scan level

Scan a CSV file

ParquetScan

Fields

path: PathBuf

schema: SchemaRef

predicate: Option<Expr>

aggregate: Vec<Expr>

options: ParquetOptions

Scan a Parquet file

IpcScan

Fields

path: PathBuf

schema: SchemaRef

options: IpcScanOptions

predicate: Option<Expr>

aggregate: Vec<Expr>

DataFrameScan

Fields

df: Arc<DataFrame>

schema: SchemaRef

projection: Option<Vec<Expr>>

selection: Option<Expr>

In memory DataFrame

LocalProjection

Fields

expr: Vec<Expr>

input: Box<LogicalPlan>

schema: SchemaRef

Projection

Fields

expr: Vec<Expr>

input: Box<LogicalPlan>

schema: SchemaRef

Column selection

Aggregate

Fields

input: Box<LogicalPlan>

keys: Arc<Vec<Expr>>

aggs: Vec<Expr>

schema: SchemaRef

apply: Option<Arc<dyn DataFrameUdf>>

maintain_order: bool

options: GroupbyOptions

Groupby aggregation

Join

Fields

input_left: Box<LogicalPlan>

input_right: Box<LogicalPlan>

schema: SchemaRef

left_on: Vec<Expr>

right_on: Vec<Expr>

options: JoinOptions

Join operation

HStack

Fields

input: Box<LogicalPlan>

exprs: Vec<Expr>

schema: SchemaRef

Adding columns to the table without a Join

Distinct

Fields

input: Box<LogicalPlan>

options: DistinctOptions

Remove duplicates from the table

Sort

Fields

input: Box<LogicalPlan>

by_column: Vec<Expr>

args: SortArguments

Sort the table

Explode

Fields

input: Box<LogicalPlan>

columns: Vec<String>

An explode operation

Slice

Fields

input: Box<LogicalPlan>

offset: i64

len: u32

Slice the table

Melt

Fields

input: Box<LogicalPlan>

id_vars: Arc<Vec<String>>

value_vars: Arc<Vec<String>>

schema: SchemaRef

A Melt operation

Udf

Fields

input: Box<LogicalPlan>

function: Arc<dyn DataFrameUdf>

options: LogicalPlanUdfOptions

schema: Option<SchemaRef>

A User Defined Function

Union

Fields

inputs: Vec<LogicalPlan>

options: UnionOptions

Error

Fields

input: Box<LogicalPlan>

err: Arc<Mutex<Option<PolarsError>>>

Catches errors and throws them later

Implementations

impl LogicalPlan

pub fn describe(&self) -> String

Trait Implementations

impl Clone for LogicalPlan

fn clone(&self) -> LogicalPlan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalPlan

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

Formats the value using the given formatter.

impl Default for LogicalPlan

fn default() -> Self

Returns the “default value” for a type.

impl From<LogicalPlan> for LazyFrame

fn from(plan: LogicalPlan) -> Self

Performs the conversion.