Enum polars_plan::logical_plan::LogicalPlan

pub enum LogicalPlan {
    PythonScan {
        options: PythonOptions,
    },
    Selection {
        input: Box<LogicalPlan>,
        predicate: Expr,
    },
    Cache {
        input: Box<LogicalPlan>,
        id: usize,
        count: usize,
    },
    Scan {
        paths: Arc<[PathBuf]>,
        file_info: FileInfo,
        predicate: Option<Expr>,
        file_options: FileScanOptions,
        scan_type: FileScan,
    },
    DataFrameScan {
        df: Arc<DataFrame>,
        schema: SchemaRef,
        output_schema: Option<SchemaRef>,
        projection: Option<Arc<Vec<String>>>,
        selection: Option<Expr>,
    },
    Projection {
        expr: Vec<Expr>,
        input: Box<LogicalPlan>,
        schema: SchemaRef,
        options: ProjectionOptions,
    },
    Aggregate {
        input: Box<LogicalPlan>,
        keys: Arc<Vec<Expr>>,
        aggs: Vec<Expr>,
        schema: SchemaRef,
        apply: Option<Arc<dyn DataFrameUdf>>,
        maintain_order: bool,
        options: Arc<GroupbyOptions>,
    },
    Join {
        input_left: Box<LogicalPlan>,
        input_right: Box<LogicalPlan>,
        schema: SchemaRef,
        left_on: Vec<Expr>,
        right_on: Vec<Expr>,
        options: Arc<JoinOptions>,
    },
    HStack {
        input: Box<LogicalPlan>,
        exprs: Vec<Expr>,
        schema: SchemaRef,
        options: ProjectionOptions,
    },
    Distinct {
        input: Box<LogicalPlan>,
        options: DistinctOptions,
    },
    Sort {
        input: Box<LogicalPlan>,
        by_column: Vec<Expr>,
        args: SortArguments,
    },
    Slice {
        input: Box<LogicalPlan>,
        offset: i64,
        len: IdxSize,
    },
    MapFunction {
        input: Box<LogicalPlan>,
        function: FunctionNode,
    },
    Union {
        inputs: Vec<LogicalPlan>,
        options: UnionOptions,
    },
    HConcat {
        inputs: Vec<LogicalPlan>,
        schema: SchemaRef,
        options: HConcatOptions,
    },
    Error {
        input: Box<LogicalPlan>,
        err: ErrorState,
    },
    ExtContext {
        input: Box<LogicalPlan>,
        contexts: Vec<LogicalPlan>,
        schema: SchemaRef,
    },
    Sink {
        input: Box<LogicalPlan>,
        payload: SinkType,
    },
}

Variants

PythonScan

Fields

options: PythonOptions

Available on crate feature python only.

Selection

Fields

input: Box<LogicalPlan>

predicate: Expr

Filter on a boolean mask

Cache

Fields

input: Box<LogicalPlan>

id: usize

count: usize

Cache the input at this point in the LP

Scan

Fields

paths: Arc<[PathBuf]>

file_info: FileInfo

predicate: Option<Expr>

file_options: FileScanOptions

scan_type: FileScan

DataFrameScan

Fields

df: Arc<DataFrame>

schema: SchemaRef

output_schema: Option<SchemaRef>

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

selection: Option<Expr>

In memory DataFrame

Projection

Fields

expr: Vec<Expr>

input: Box<LogicalPlan>

schema: SchemaRef

options: ProjectionOptions

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: Arc<GroupbyOptions>

Groupby aggregation

Join

Fields

input_left: Box<LogicalPlan>

input_right: Box<LogicalPlan>

schema: SchemaRef

left_on: Vec<Expr>

right_on: Vec<Expr>

options: Arc<JoinOptions>

Join operation

HStack

Fields

input: Box<LogicalPlan>

exprs: Vec<Expr>

schema: SchemaRef

options: ProjectionOptions

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

Slice

Fields

input: Box<LogicalPlan>

offset: i64

len: IdxSize

Slice the table

MapFunction

Fields

input: Box<LogicalPlan>

function: FunctionNode

A (User Defined) Function

Union

Fields

inputs: Vec<LogicalPlan>

options: UnionOptions

HConcat

Fields

inputs: Vec<LogicalPlan>

schema: SchemaRef

options: HConcatOptions

Horizontal concatenation of multiple plans

Error

Fields

input: Box<LogicalPlan>

err: ErrorState

Catches errors and throws them later

ExtContext

Fields

input: Box<LogicalPlan>

contexts: Vec<LogicalPlan>

schema: SchemaRef

This allows expressions to access other tables

Sink

Fields

input: Box<LogicalPlan>

payload: SinkType

Implementations

impl LogicalPlan

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

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.

impl LogicalPlan

pub fn schema(&self) -> PolarsResult<Cow<'_, SchemaRef>>

impl LogicalPlan

pub fn describe(&self) -> String

pub fn describe_tree_format(&self) -> String

pub fn to_alp(self) -> PolarsResult<(Node, Arena<ALogicalPlan>, Arena<AExpr>)>

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<'de> Deserialize<'de> for LogicalPlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<LogicalPlan> for LogicalPlanBuilder

fn from(lp: LogicalPlan) -> Self

Converts to this type from the input type.

impl Serialize for LogicalPlan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.