Enum polars::prelude::LogicalPlan

[−]

pub enum LogicalPlan {
Show 21 variants    AnonymousScan {
        function: Arc<dyn AnonymousScan + 'static>,
        schema: Arc<Schema>,
        predicate: Option<Expr>,
        options: AnonymousScanOptions,
    },
    Selection {
        input: Box<LogicalPlan, Global>,
        predicate: Expr,
    },
    Cache {
        input: Box<LogicalPlan, Global>,
        id: usize,
        count: usize,
    },
    CsvScan {
        path: PathBuf,
        schema: Arc<Schema>,
        options: CsvParserOptions,
        predicate: Option<Expr>,
    },
    ParquetScan {
        path: PathBuf,
        schema: Arc<Schema>,
        predicate: Option<Expr>,
        options: ParquetOptions,
    },
    IpcScan {
        path: PathBuf,
        schema: Arc<Schema>,
        options: IpcScanOptionsInner,
        predicate: Option<Expr>,
    },
    DataFrameScan {
        df: Arc<DataFrame>,
        schema: Arc<Schema>,
        output_schema: Option<Arc<Schema>>,
        projection: Option<Arc<Vec<String, 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>>,
        maintain_order: bool,
        options: GroupbyOptions,
    },
    Join {
        input_left: Box<LogicalPlan, Global>,
        input_right: Box<LogicalPlan, Global>,
        schema: Arc<Schema>,
        left_on: Vec<Expr, Global>,
        right_on: Vec<Expr, Global>,
        options: JoinOptions,
    },
    HStack {
        input: Box<LogicalPlan, Global>,
        exprs: Vec<Expr, Global>,
        schema: Arc<Schema>,
    },
    Distinct {
        input: Box<LogicalPlan, Global>,
        options: DistinctOptions,
    },
    Sort {
        input: Box<LogicalPlan, Global>,
        by_column: Vec<Expr, Global>,
        args: SortArguments,
    },
    Explode {
        input: Box<LogicalPlan, Global>,
        columns: Vec<String, Global>,
        schema: Arc<Schema>,
    },
    Slice {
        input: Box<LogicalPlan, Global>,
        offset: i64,
        len: u32,
    },
    Melt {
        input: Box<LogicalPlan, Global>,
        args: Arc<MeltArgs>,
        schema: Arc<Schema>,
    },
    MapFunction {
        input: Box<LogicalPlan, Global>,
        function: FunctionNode,
    },
    Union {
        inputs: Vec<LogicalPlan, Global>,
        options: UnionOptions,
    },
    Error {
        input: Box<LogicalPlan, Global>,
        err: Arc<Mutex<Option<PolarsError>>>,
    },
    ExtContext {
        input: Box<LogicalPlan, Global>,
        contexts: Vec<LogicalPlan, Global>,
        schema: Arc<Schema>,
    },
}

Variants

`AnonymousScan`

Fields

function: Arc<dyn AnonymousScan + 'static>

schema: Arc<Schema>

predicate: Option<Expr>

options: AnonymousScanOptions

`Selection`

Fields

input: Box<LogicalPlan, Global>

predicate: Expr

Filter on a boolean mask

`Cache`

Fields

input: Box<LogicalPlan, Global>

id: usize

count: usize

Cache the input at this point in the LP

`CsvScan`

Fields

path: PathBuf

schema: Arc<Schema>

options: CsvParserOptions

predicate: Option<Expr>

Filters at the scan level

Scan a CSV file

`ParquetScan`

Fields

path: PathBuf

schema: Arc<Schema>

predicate: Option<Expr>

options: ParquetOptions

Scan a Parquet file

`IpcScan`

Fields

path: PathBuf

schema: Arc<Schema>

options: IpcScanOptionsInner

predicate: Option<Expr>

`DataFrameScan`

Fields

df: Arc<DataFrame>

schema: Arc<Schema>

output_schema: Option<Arc<Schema>>

projection: Option<Arc<Vec<String, Global>>>

selection: Option<Expr>

In memory DataFrame

`LocalProjection`

Fields

expr: Vec<Expr, Global>

input: Box<LogicalPlan, Global>

schema: Arc<Schema>

`Projection`

Fields

expr: Vec<Expr, Global>

input: Box<LogicalPlan, Global>

schema: Arc<Schema>

Column selection

`Aggregate`

Fields

input: Box<LogicalPlan, Global>

keys: Arc<Vec<Expr, Global>>

aggs: Vec<Expr, Global>

schema: Arc<Schema>

apply: Option<Arc<dyn DataFrameUdf + 'static>>

maintain_order: bool

options: GroupbyOptions

Groupby aggregation

`Join`

Fields

input_left: Box<LogicalPlan, Global>

input_right: Box<LogicalPlan, Global>

schema: Arc<Schema>

left_on: Vec<Expr, Global>

right_on: Vec<Expr, Global>

options: JoinOptions

Join operation

`HStack`

Fields

input: Box<LogicalPlan, Global>

exprs: Vec<Expr, Global>

schema: Arc<Schema>

Adding columns to the table without a Join

`Distinct`

Fields

input: Box<LogicalPlan, Global>

options: DistinctOptions

Remove duplicates from the table

`Sort`

Fields

input: Box<LogicalPlan, Global>

by_column: Vec<Expr, Global>

args: SortArguments

Sort the table

`Explode`

Fields

input: Box<LogicalPlan, Global>

columns: Vec<String, Global>

schema: Arc<Schema>

An explode operation

`Slice`

Fields

input: Box<LogicalPlan, Global>

offset: i64

len: u32

Slice the table

`Melt`

Fields

input: Box<LogicalPlan, Global>

args: Arc<MeltArgs>

schema: Arc<Schema>

A Melt operation

`MapFunction`

Fields

input: Box<LogicalPlan, Global>

function: FunctionNode

A (User Defined) Function

`Union`

Fields

inputs: Vec<LogicalPlan, Global>

options: UnionOptions

`Error`

Fields

input: Box<LogicalPlan, Global>

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

Catches errors and throws them later

`ExtContext`

Fields

input: Box<LogicalPlan, Global>

contexts: Vec<LogicalPlan, Global>

schema: Arc<Schema>

This allows expressions to access other tables

Implementations

impl LogicalPlan

pub fn dot(
 &self,
 acc_str: &mut String,
 id: (usize, usize),
 prev_node: DotNode<'_>,
 id_map: &mut HashMap<String, String, RandomState, Global>
) -> Result<(), Error>

Arguments

id - (branch, id) Used to make sure that the dot boxes are distinct. branch is an id per join/union branch id is incremented by the depth traversal of the tree.