Enum polars_lazy::logical_plan::LogicalPlan[−][src]

pub enum LogicalPlan {
Show 16 variants    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,
        with_columns: Option<Vec<String>>,
        predicate: Option<Expr>,
        aggregate: Vec<Expr>,
        stop_after_n_rows: Option<usize>,
        cache: bool,
    },
    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,
    },
    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>,
        maintain_order: bool,
        subset: Arc<Option<Vec<String>>>,
    },
    Sort {
        input: Box<LogicalPlan>,
        by_column: Vec<Expr>,
        reverse: Vec<bool>,
    },
    Explode {
        input: Box<LogicalPlan>,
        columns: Vec<String>,
    },
    Slice {
        input: Box<LogicalPlan>,
        offset: i64,
        len: usize,
    },
    Melt {
        input: Box<LogicalPlan>,
        id_vars: Arc<Vec<String>>,
        value_vars: Arc<Vec<String>>,
        schema: SchemaRef,
    },
    Udf {
        input: Box<LogicalPlan>,
        function: Arc<dyn DataFrameUdf>,
        predicate_pd: bool,
        projection_pd: bool,
        schema: Option<SchemaRef>,
    },
}

This is supported on crate feature compile only.

Variants

Selection

Filter on a boolean mask

Fields of Selection

input: Box<LogicalPlan>predicate: Expr

Cache

Cache the input at this point in the LP

Fields of Cache

input: Box<LogicalPlan>

CsvScan

This is supported on crate feature csv-file only.

Scan a CSV file

Fields of CsvScan

path: PathBufschema: SchemaRefoptions: CsvParserOptionspredicate: Option<Expr>

Filters at the scan level

aggregate: Vec<Expr>

Aggregations at the scan level

ParquetScan

This is supported on crate feature parquet only.

Scan a Parquet file

Fields of ParquetScan

path: PathBufschema: SchemaRefwith_columns: Option<Vec<String>>predicate: Option<Expr>aggregate: Vec<Expr>stop_after_n_rows: Option<usize>cache: bool

DataFrameScan

In memory DataFrame