Enum polars_plan::logical_plan::ALogicalPlan

source · [−]

pub enum ALogicalPlan {
Show 21 variants    AnonymousScan {
        function: Arc<dyn AnonymousScan>,
        schema: SchemaRef,
        output_schema: Option<SchemaRef>,
        predicate: Option<Node>,
        options: AnonymousScanOptions,
    },
    PythonScan {
        options: PythonOptions,
    },
    Melt {
        input: Node,
        args: Arc<MeltArgs>,
        schema: SchemaRef,
    },
    Slice {
        input: Node,
        offset: i64,
        len: IdxSize,
    },
    Selection {
        input: Node,
        predicate: Node,
    },
    CsvScan {
        path: PathBuf,
        schema: SchemaRef,
        output_schema: Option<SchemaRef>,
        options: CsvParserOptions,
        predicate: Option<Node>,
    },
    IpcScan {
        path: PathBuf,
        schema: SchemaRef,
        output_schema: Option<SchemaRef>,
        options: IpcScanOptionsInner,
        predicate: Option<Node>,
    },
    ParquetScan {
        path: PathBuf,
        schema: SchemaRef,
        output_schema: Option<SchemaRef>,
        predicate: Option<Node>,
        options: ParquetOptions,
    },
    DataFrameScan {
        df: Arc<DataFrame>,
        schema: SchemaRef,
        output_schema: Option<SchemaRef>,
        projection: Option<Arc<Vec<String>>>,
        selection: Option<Node>,
    },
    Projection {
        input: Node,
        expr: Vec<Node>,
        schema: SchemaRef,
    },
    LocalProjection {
        expr: Vec<Node>,
        input: Node,
        schema: SchemaRef,
    },
    Sort {
        input: Node,
        by_column: Vec<Node>,
        args: SortArguments,
    },
    Explode {
        input: Node,
        columns: Vec<String>,
        schema: SchemaRef,
    },
    Cache {
        input: Node,
        id: usize,
        count: usize,
    },
    Aggregate {
        input: Node,
        keys: Vec<Node>,
        aggs: Vec<Node>,
        schema: SchemaRef,
        apply: Option<Arc<dyn DataFrameUdf>>,
        maintain_order: bool,
        options: GroupbyOptions,
    },
    Join {
        input_left: Node,
        input_right: Node,
        schema: SchemaRef,
        left_on: Vec<Node>,
        right_on: Vec<Node>,
        options: JoinOptions,
    },
    HStack {
        input: Node,
        exprs: Vec<Node>,
        schema: SchemaRef,
    },
    Distinct {
        input: Node,
        options: DistinctOptions,
    },
    MapFunction {
        input: Node,
        function: FunctionNode,
    },
    Union {
        inputs: Vec<Node>,
        options: UnionOptions,
    },
    ExtContext {
        input: Node,
        contexts: Vec<Node>,
        schema: SchemaRef,
    },
}

Expand description

ALogicalPlan is a representation of LogicalPlan with Nodes which are allocated in an Arena

Variants

`AnonymousScan`

Fields

function: Arc<dyn AnonymousScan>

schema: SchemaRef

output_schema: Option<SchemaRef>

predicate: Option<Node>

options: AnonymousScanOptions

`PythonScan`

Fields

options: PythonOptions

`Melt`

Fields

input: Node

args: Arc<MeltArgs>

schema: SchemaRef

`Slice`

Fields

input: Node

offset: i64

len: IdxSize

`Selection`

Fields

input: Node

predicate: Node

`CsvScan`

Fields

path: PathBuf

schema: SchemaRef

output_schema: Option<SchemaRef>

options: CsvParserOptions

predicate: Option<Node>

`IpcScan`

Fields

path: PathBuf

schema: SchemaRef

output_schema: Option<SchemaRef>

options: IpcScanOptionsInner

predicate: Option<Node>

`ParquetScan`

Fields

path: PathBuf

schema: SchemaRef

output_schema: Option<SchemaRef>

predicate: Option<Node>

options: ParquetOptions

`DataFrameScan`

Fields

df: Arc<DataFrame>

schema: SchemaRef

output_schema: Option<SchemaRef>

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

selection: Option<Node>

`Projection`

Fields

input: Node

expr: Vec<Node>

schema: SchemaRef

`LocalProjection`

Fields

expr: Vec<Node>

input: Node

schema: SchemaRef

`Sort`

Fields

input: Node

by_column: Vec<Node>

args: SortArguments

`Explode`

Fields

input: Node

columns: Vec<String>

schema: SchemaRef

`Cache`

Fields

input: Node

id: usize

count: usize

`Aggregate`

Fields

input: Node

keys: Vec<Node>

aggs: Vec<Node>

schema: SchemaRef

apply: Option<Arc<dyn DataFrameUdf>>

maintain_order: bool

options: GroupbyOptions

`Join`

Fields

input_left: Node

input_right: Node

schema: SchemaRef

left_on: Vec<Node>

right_on: Vec<Node>

options: JoinOptions

`HStack`

Fields

input: Node

exprs: Vec<Node>

schema: SchemaRef

`Distinct`

Fields

input: Node

options: DistinctOptions

`MapFunction`

Fields

input: Node

function: FunctionNode

`Union`

Fields

inputs: Vec<Node>

options: UnionOptions

`ExtContext`

Fields

input: Node

contexts: Vec<Node>

schema: SchemaRef

Implementations

source

impl ALogicalPlan

source

pub fn schema<'a>(&'a self, arena: &'a Arena<ALogicalPlan>) -> Cow<'a, SchemaRef>

Get the schema of the logical plan node.

source

impl ALogicalPlan

source

pub fn with_exprs_and_input(
 &self,
 exprs: Vec<Node>,
 inputs: Vec<Node>
) -> ALogicalPlan

Takes the expressions of an LP node and the inputs of that node and reconstruct

source

pub fn copy_exprs(&self, container: &mut Vec<Node>)

Copy the exprs in this LP node to an existing container.

source

pub fn get_exprs(&self) -> Vec<Node>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

Get expressions in this node.

source

pub fn copy_inputs<T>(&self, container: &mut T)where
T: PushNode,

Push inputs of the LP in of this node to an existing container. Most plans have typically one input. A join has two and a scan (CsvScan) or an in-memory DataFrame has none. A Union has multiple.

source