Enum polars_plan::logical_plan::ALogicalPlan

pub enum ALogicalPlan {
    PythonScan {
        options: PythonOptions,
        predicate: Option<Node>,
    },
    Slice {
        input: Node,
        offset: i64,
        len: IdxSize,
    },
    Selection {
        input: Node,
        predicate: Node,
    },
    Scan {
        paths: Arc<[PathBuf]>,
        file_info: FileInfo,
        predicate: Option<Node>,
        output_schema: Option<SchemaRef>,
        scan_type: FileScan,
        file_options: FileScanOptions,
    },
    DataFrameScan {
        df: Arc<DataFrame>,
        schema: SchemaRef,
        output_schema: Option<SchemaRef>,
        projection: Option<Arc<Vec<String>>>,
        selection: Option<Node>,
    },
    Projection {
        input: Node,
        expr: ProjectionExprs,
        schema: SchemaRef,
        options: ProjectionOptions,
    },
    Sort {
        input: Node,
        by_column: Vec<Node>,
        args: SortArguments,
    },
    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: Arc<GroupbyOptions>,
    },
    Join {
        input_left: Node,
        input_right: Node,
        schema: SchemaRef,
        left_on: Vec<Node>,
        right_on: Vec<Node>,
        options: Arc<JoinOptions>,
    },
    HStack {
        input: Node,
        exprs: ProjectionExprs,
        schema: SchemaRef,
        options: ProjectionOptions,
    },
    Distinct {
        input: Node,
        options: DistinctOptions,
    },
    MapFunction {
        input: Node,
        function: FunctionNode,
    },
    Union {
        inputs: Vec<Node>,
        options: UnionOptions,
    },
    HConcat {
        inputs: Vec<Node>,
        schema: SchemaRef,
        options: HConcatOptions,
    },
    ExtContext {
        input: Node,
        contexts: Vec<Node>,
        schema: SchemaRef,
    },
    Sink {
        input: Node,
        payload: SinkType,
    },
}

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

Variants

PythonScan

Fields

options: PythonOptions

predicate: Option<Node>

Available on crate feature python only.

Slice

Fields

input: Node

offset: i64

len: IdxSize

Selection

Fields

input: Node

predicate: Node

Scan

Fields

paths: Arc<[PathBuf]>

file_info: FileInfo

predicate: Option<Node>

output_schema: Option<SchemaRef>

schema of the projected file

scan_type: FileScan

file_options: FileScanOptions

generic options that can be used for all file types.

DataFrameScan

Fields

df: Arc<DataFrame>

schema: SchemaRef

output_schema: Option<SchemaRef>

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

selection: Option<Node>

Projection

Fields

input: Node

expr: ProjectionExprs

schema: SchemaRef

options: ProjectionOptions

Sort

Fields

input: Node

by_column: Vec<Node>

args: SortArguments

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

Join

Fields

input_left: Node

input_right: Node

schema: SchemaRef

left_on: Vec<Node>

right_on: Vec<Node>

options: Arc<JoinOptions>

HStack

Fields

input: Node

exprs: ProjectionExprs

schema: SchemaRef

options: ProjectionOptions

Distinct

Fields

input: Node

options: DistinctOptions

MapFunction

Fields

input: Node

function: FunctionNode

Union

Fields

inputs: Vec<Node>

options: UnionOptions

HConcat

Fields

inputs: Vec<Node>

schema: SchemaRef

options: HConcatOptions

ExtContext

Fields

input: Node

contexts: Vec<Node>

schema: SchemaRef

Sink

Fields

input: Node

payload: SinkType

Implementations

impl ALogicalPlan

pub fn name(&self) -> &'static str

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

Get the schema of the logical plan node.

impl ALogicalPlan

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

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

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

pub fn get_exprs(&self) -> Vec<Node>

Get expressions in this node.

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.

pub fn get_inputs(&self) -> Vec<Node>

Trait Implementations

impl Clone for ALogicalPlan

fn clone(&self) -> ALogicalPlan

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ALogicalPlan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ALogicalPlan

fn default() -> Self

Returns the “default value” for a type.