Enum polars_lazy::prelude::LogicalPlan

pub enum LogicalPlan {
    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: Arc<Schema>,
        output_schema: Option<Arc<Schema>>,
        projection: Option<Arc<Vec<String>>>,
        selection: Option<Expr>,
    },
    Projection {
        expr: Vec<Expr>,
        input: Box<LogicalPlan>,
        schema: Arc<Schema>,
        options: ProjectionOptions,
    },
    Aggregate {
        input: Box<LogicalPlan>,
        keys: Arc<Vec<Expr>>,
        aggs: Vec<Expr>,
        schema: Arc<Schema>,
        apply: Option<Arc<dyn DataFrameUdf>>,
        maintain_order: bool,
        options: Arc<GroupbyOptions>,
    },
    Join {
        input_left: Box<LogicalPlan>,
        input_right: Box<LogicalPlan>,
        schema: Arc<Schema>,
        left_on: Vec<Expr>,
        right_on: Vec<Expr>,
        options: Arc<JoinOptions>,
    },
    HStack {
        input: Box<LogicalPlan>,
        exprs: Vec<Expr>,
        schema: Arc<Schema>,
        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: u64,
    },
    MapFunction {
        input: Box<LogicalPlan>,
        function: FunctionNode,
    },
    Union {
        inputs: Vec<LogicalPlan>,
        options: UnionOptions,
    },
    Error {
        input: Box<LogicalPlan>,
        err: ErrorStateSync,
    },
    ExtContext {
        input: Box<LogicalPlan>,
        contexts: Vec<LogicalPlan>,
        schema: Arc<Schema>,
    },
    Sink {
        input: Box<LogicalPlan>,
        payload: SinkType,
    },
}

Variants

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

output_schema: Option<Arc<Schema>>

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

selection: Option<Expr>

In memory DataFrame

Projection

Fields

expr: Vec<Expr>

input: Box<LogicalPlan>

schema: Arc<Schema>

options: ProjectionOptions

Column selection

Aggregate

Fields

input: Box<LogicalPlan>

keys: Arc<Vec<Expr>>

aggs: Vec<Expr>

schema: Arc<Schema>

apply: Option<Arc<dyn DataFrameUdf>>

maintain_order: bool

options: Arc<GroupbyOptions>

Groupby aggregation

Join

Fields

input_left: Box<LogicalPlan>

input_right: Box<LogicalPlan>

schema: Arc<Schema>

left_on: Vec<Expr>

right_on: Vec<Expr>

options: Arc<JoinOptions>

Join operation

HStack

Fields

input: Box<LogicalPlan>

exprs: Vec<Expr>

schema: Arc<Schema>

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: u64

Slice the table

MapFunction

Fields

input: Box<LogicalPlan>

function: FunctionNode

A (User Defined) Function

Union

Fields

inputs: Vec<LogicalPlan>

options: UnionOptions

Error

Fields

input: Box<LogicalPlan>

err: ErrorStateSync

Catches errors and throws them later

ExtContext

Fields

input: Box<LogicalPlan>

contexts: Vec<LogicalPlan>

schema: Arc<Schema>

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 HashMap<String, String, RandomState> ) -> 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.

impl LogicalPlan

pub fn schema(&self) -> Result<Cow<'_, Arc<Schema>>, PolarsError>

impl LogicalPlan

pub fn describe(&self) -> String

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

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<(), Error>

Formats the value using the given formatter.

impl Default for LogicalPlan

fn default() -> LogicalPlan

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LogicalPlan

fn deserialize<__D>( __deserializer: __D ) -> Result<LogicalPlan, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<LogicalPlan> for LazyFrame

fn from(plan: LogicalPlan) -> Self

Converts to this type from the input type.

impl Serialize for LogicalPlan

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

Serialize this value into the given Serde serializer.