Enum LogicalPlan 

pub enum LogicalPlan {
    DataFrameScan {
        df: DataFrame,
    },
    CsvScan {
        path: PathBuf,
        predicate: Option<Expr>,
        projection: Option<Vec<String>>,
    },
    ParquetScan {
        path: PathBuf,
        predicate: Option<Expr>,
        projection: Option<Vec<String>>,
    },
    Concat {
        inputs: Vec<LogicalPlan>,
        schema: Option<SchemaRef>,
    },
    Projection {
        input: Box<LogicalPlan>,
        exprs: Vec<Expr>,
        kind: ProjectionKind,
    },
    Filter {
        input: Box<LogicalPlan>,
        predicate: Expr,
    },
    Aggregate {
        input: Box<LogicalPlan>,
        group_by: Vec<Expr>,
        aggs: Vec<Expr>,
    },
    Join {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        keys: JoinKeys,
        how: JoinType,
    },
    Sort {
        input: Box<LogicalPlan>,
        options: SortOptions,
    },
    Slice {
        input: Box<LogicalPlan>,
        offset: usize,
        len: usize,
        from_end: bool,
    },
    Unique {
        input: Box<LogicalPlan>,
        subset: Option<Vec<String>>,
    },
    FillNull {
        input: Box<LogicalPlan>,
        fill: FillNull,
    },
    DropNulls {
        input: Box<LogicalPlan>,
        subset: Option<Vec<String>>,
    },
    NullCount {
        input: Box<LogicalPlan>,
    },
    Explode {
        input: Box<LogicalPlan>,
        column: String,
    },
    Implode {
        input: Box<LogicalPlan>,
    },
}

Logical plan nodes and projection kinds. Logical query plan nodes for LazyFrame.

Variants

DataFrameScan

Scan an in-memory DataFrame.

Fields

df: DataFrame

CsvScan

Scan a CSV file (predicate/projection may be pushed down).

Fields

path: PathBuf

predicate: Option<Expr>

projection: Option<Vec<String>>

ParquetScan

Scan a Parquet file (predicate/projection may be pushed down).

Fields

path: PathBuf

predicate: Option<Expr>

projection: Option<Vec<String>>

Concat

Strict vertical concatenation of two or more compatible inputs.

Fields

inputs: Vec<LogicalPlan>

Inputs in declared output order.

schema: Option<SchemaRef>

Validated common schema, or deferred until bounded source preflight for lazy scans.

Projection

Projection node (select or with_columns).

Fields

input: Box<LogicalPlan>

exprs: Vec<Expr>

kind: ProjectionKind

Filter

Filter node.

Fields

input: Box<LogicalPlan>

predicate: Expr

Aggregate

Aggregate node (group keys and aggregations).

Fields

input: Box<LogicalPlan>

group_by: Vec<Expr>

aggs: Vec<Expr>

Join

Join two inputs.

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

keys: JoinKeys

how: JoinType

Sort

Sort input rows.

Fields

input: Box<LogicalPlan>

options: SortOptions

Slice

Slice rows (used for head/tail).

Fields

input: Box<LogicalPlan>

offset: usize

len: usize

from_end: bool

Unique

Remove duplicate rows.

Fields

input: Box<LogicalPlan>

subset: Option<Vec<String>>

FillNull

Fill nulls using a scalar or strategy.

Fields

input: Box<LogicalPlan>

fill: FillNull

DropNulls

Drop rows containing nulls.

Fields

input: Box<LogicalPlan>

subset: Option<Vec<String>>

NullCount

Count nulls per column.

Fields

input: Box<LogicalPlan>

Explode

Explode one list column.

Fields

input: Box<LogicalPlan>

column: String

Implode

Implode columns into one row of list columns.

Fields

input: Box<LogicalPlan>

Implementations

impl LogicalPlan

pub fn concat(inputs: Vec<(LogicalPlan, SchemaRef)>) -> Result<Self>

Construct a strict vertical concat plan from schema-known inputs.

All input schemas must have identical field names, order, data types, and nullability. The check happens before execution and no implicit coercion is attempted.

pub fn concat_deferred(inputs: Vec<LogicalPlan>) -> Result<Self>

Construct a concat whose source schemas are intentionally unavailable until bounded open.

The streaming executor preflights every child schema before publishing its first result.

pub fn display(&self) -> String

Render this plan as a readable string (used by explain() and tests).

Trait Implementations

impl Clone for LogicalPlan

fn clone(&self) -> LogicalPlan

Returns a duplicate 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.