Enum DslPlan 

pub enum DslPlan {
    PythonScan {
        options: PythonOptionsDsl,
    },
    Filter {
        input: Arc<DslPlan>,
        predicate: Expr,
    },
    Cache {
        input: Arc<DslPlan>,
        id: UniqueId,
    },
    Scan {
        sources: ScanSources,
        unified_scan_args: Box<UnifiedScanArgs>,
        scan_type: Box<FileScanDsl>,
        cached_ir: Arc<Mutex<Option<IR>>>,
    },
    DataFrameScan {
        df: Arc<DataFrame>,
        schema: Arc<Schema<DataType, ()>>,
    },
    Select {
        expr: Vec<Expr>,
        input: Arc<DslPlan>,
        options: ProjectionOptions,
    },
    GroupBy {
        input: Arc<DslPlan>,
        keys: Vec<Expr>,
        predicates: Vec<Expr>,
        aggs: Vec<Expr>,
        maintain_order: bool,
        options: Arc<GroupbyOptions>,
        apply: Option<(PlanCallback<DataFrame, DataFrame>, Arc<Schema<DataType, ()>>)>,
    },
    Join {
        input_left: Arc<DslPlan>,
        input_right: Arc<DslPlan>,
        condition: JoinCondition,
        options: Arc<JoinOptions>,
    },
    Gather {
        input: Arc<DslPlan>,
        idxs: Arc<DslPlan>,
        null_on_oob: bool,
    },
    HStack {
        input: Arc<DslPlan>,
        exprs: Vec<Expr>,
        options: ProjectionOptions,
    },
    MatchToSchema {
        input: Arc<DslPlan>,
        match_schema: Arc<Schema<DataType, ()>>,
        per_column: Arc<[MatchToSchemaPerColumn]>,
        extra_columns: ExtraColumnsPolicy,
    },
    PipeWithSchema {
        input: Arc<[DslPlan]>,
        callback: PlanCallback<(Vec<DslPlan>, Vec<Arc<Schema<DataType, ()>>>), DslPlan>,
    },
    Pivot {
        input: Arc<DslPlan>,
        on: Selector,
        on_columns: Arc<DataFrame>,
        index: Selector,
        values: Selector,
        agg: Expr,
        maintain_order: bool,
        separator: PlSmallStr,
        column_naming: PivotColumnNaming,
    },
    Distinct {
        input: Arc<DslPlan>,
        options: DistinctOptionsDSL,
    },
    Sort {
        input: Arc<DslPlan>,
        by_column: Vec<Expr>,
        slice: Option<(i64, usize)>,
        sort_options: SortMultipleOptions,
    },
    Slice {
        input: Arc<DslPlan>,
        offset: i64,
        len: u64,
    },
    MapFunction {
        input: Arc<DslPlan>,
        function: DslFunction,
    },
    Union {
        inputs: Vec<DslPlan>,
        args: UnionArgs,
    },
    HConcat {
        inputs: Vec<DslPlan>,
        options: HConcatOptions,
    },
    Sink {
        input: Arc<DslPlan>,
        payload: SinkType,
    },
    SinkMultiple {
        inputs: Vec<DslPlan>,
    },
    MergeSorted {
        input_left: Arc<DslPlan>,
        input_right: Arc<DslPlan>,
        key: Arc<[PlSmallStr]>,
        maintain_order: bool,
    },
    Recursive {
        anchor: Arc<DslPlan>,
        step: Arc<DslPlan>,
        id: UniqueId,
        round_local_caches: Arc<[UniqueId]>,
    },
    WorkingTable {
        id: UniqueId,
        schema: Arc<Schema<DataType, ()>>,
    },
    SQL {
        query: Arc<String>,
        relations: Vec<(PlSmallStr, DslPlan)>,
        catalog_tables: Vec<(Arc<[PlSmallStr]>, Arc<[PlSmallStr]>, DslPlan)>,
        cached_stmt: CachedSqlStatement,
    },
    IR {
        dsl: Arc<DslPlan>,
        version: u32,
        node: Option<Node>,
        opt_flags: Option<OptFlags>,
    },
    Resolver {
        resolver: Arc<DslResolver>,
        resolver_schema: Arc<Mutex<Option<Arc<Schema<DataType, ()>>>>>,
        resolved_cache: Arc<Mutex<IndexMap<ResolveDslArgs, ResolvedDsl, RandomState>>>,
    },
}

Variants

PythonScan

Available on crate feature python only.

Fields

options: PythonOptionsDsl

Filter

Filter on a boolean mask

Fields

input: Arc<DslPlan>

predicate: Expr

Cache

Cache the input at this point in the LP

Fields

input: Arc<DslPlan>

id: UniqueId

Scan

Fields

sources: ScanSources

unified_scan_args: Box<UnifiedScanArgs>

scan_type: Box<FileScanDsl>

cached_ir: Arc<Mutex<Option<IR>>>

Local use cases often repeatedly collect the same LazyFrame (e.g. in interactive notebook use-cases), so we cache the IR conversion here, as the path expansion can be quite slow (especially for cloud paths). We don’t have the arena, as this is always a source node.

DataFrameScan

In memory DataFrame

Fields

df: Arc<DataFrame>

schema: Arc<Schema<DataType, ()>>

Select

Polars’ select operation, this can mean projection, but also full data access.

Fields

expr: Vec<Expr>

input: Arc<DslPlan>

options: ProjectionOptions

GroupBy

Groupby aggregation

Fields

input: Arc<DslPlan>

keys: Vec<Expr>

predicates: Vec<Expr>

aggs: Vec<Expr>

maintain_order: bool

options: Arc<GroupbyOptions>

apply: Option<(PlanCallback<DataFrame, DataFrame>, Arc<Schema<DataType, ()>>)>

Join

Join operation

Fields

input_left: Arc<DslPlan>

input_right: Arc<DslPlan>

condition: JoinCondition

options: Arc<JoinOptions>

Gather

Gathers from this table with the given indices.

Fields

input: Arc<DslPlan>

idxs: Arc<DslPlan>

null_on_oob: bool

HStack

Adding columns to the table without a Join

Fields

input: Arc<DslPlan>

exprs: Vec<Expr>

options: ProjectionOptions

MatchToSchema

Match / Evolve into a schema

Fields

input: Arc<DslPlan>

match_schema: Arc<Schema<DataType, ()>>

The schema to match to.

This is also always the output schema.

per_column: Arc<[MatchToSchemaPerColumn]>

extra_columns: ExtraColumnsPolicy

PipeWithSchema

Fields

input: Arc<[DslPlan]>

callback: PlanCallback<(Vec<DslPlan>, Vec<Arc<Schema<DataType, ()>>>), DslPlan>

Pivot

Available on crate feature pivot only.

Fields

input: Arc<DslPlan>

on: Selector

on_columns: Arc<DataFrame>

index: Selector

values: Selector

agg: Expr

maintain_order: bool

separator: PlSmallStr

column_naming: PivotColumnNaming

Distinct

Remove duplicates from the table

Fields

input: Arc<DslPlan>

options: DistinctOptionsDSL

Sort

Sort the table

Fields

input: Arc<DslPlan>

by_column: Vec<Expr>

slice: Option<(i64, usize)>

sort_options: SortMultipleOptions

Slice

Slice the table

Fields

input: Arc<DslPlan>

offset: i64

len: u64

MapFunction

A (User Defined) Function

Fields

input: Arc<DslPlan>

function: DslFunction

Union

Vertical concatenation

Fields

inputs: Vec<DslPlan>

args: UnionArgs

HConcat

Horizontal concatenation of multiple plans

Fields

inputs: Vec<DslPlan>

options: HConcatOptions

Sink

Fields

input: Arc<DslPlan>

payload: SinkType

SinkMultiple

Fields

inputs: Vec<DslPlan>

MergeSorted

Available on crate feature merge_sorted only.

Fields

input_left: Arc<DslPlan>

input_right: Arc<DslPlan>

key: Arc<[PlSmallStr]>

maintain_order: bool

Recursive

Recursive query (SQL WITH RECURSIVE). The output is the anchor rows followed by the rows of each round: a round runs step with the WorkingTable of id holding the rows of the round before. It ends when a round has no rows.

Fields

anchor: Arc<DslPlan>

step: Arc<DslPlan>

id: UniqueId

round_local_caches: Arc<[UniqueId]>

The caches in step that are computed again in every round.

WorkingTable

The rows of the round before, inside the step of the Recursive with this id.

Fields

id: UniqueId

schema: Arc<Schema<DataType, ()>>

SQL

A SQL query that is resolved during DSL -> IR conversion.

Fields

query: Arc<String>

relations: Vec<(PlSmallStr, DslPlan)>

The named relations that the query may reference.

catalog_tables: Vec<(Arc<[PlSmallStr]>, Arc<[PlSmallStr]>, DslPlan)>

The catalog tables the query reads: the name the query wrote, the table’s full name (catalog, namespace, table) and its scan.

cached_stmt: CachedSqlStatement

IR

Fields

dsl: Arc<DslPlan>

version: u32

node: Option<Node>

opt_flags: Option<OptFlags>

Resolver

Fields

resolver: Arc<DslResolver>

resolver_schema: Arc<Mutex<Option<Arc<Schema<DataType, ()>>>>>

resolved_cache: Arc<Mutex<IndexMap<ResolveDslArgs, ResolvedDsl, RandomState>>>

Implementations

impl DslPlan

pub fn describe(&self) -> Result<String, PolarsError>

pub fn describe_tree_format(&self) -> Result<String, PolarsError>

pub fn display(&self) -> Result<impl Display, PolarsError>

pub fn to_alp(self) -> Result<IRPlan, PolarsError>

pub fn serialize_json_into( &self, writer: &mut dyn Write, ) -> Result<(), PolarsError>

Available on crate feature serde only.

pub fn deserialize_json_from_str(json: &str) -> Result<DslPlan, PolarsError>

Available on crate feature serde only.

pub fn serialize_versioned<W>( &self, writer: W, ctx: PlanSerializationContext, ) -> Result<(), PolarsError>

where W: Write,

Available on crate feature serde only.

pub fn deserialize_versioned<R>(reader: R) -> Result<DslPlan, PolarsError>

where R: Read,

Available on crate feature serde only.

impl DslPlan

pub fn compute_schema(&self) -> Result<Arc<Schema<DataType, ()>>, PolarsError>

Compute the schema. This requires conversion to [IR] and type-resolving.

Trait Implementations

impl Clone for DslPlan

fn clone(&self) -> DslPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DslPlan

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

Formats the value using the given formatter.

impl Default for DslPlan

fn default() -> DslPlan

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DslPlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<DslPlan> for DslBuilder

fn from(lp: DslPlan) -> DslBuilder

Converts to this type from the input type.

impl From<DslPlan> for LazyFrame

fn from(plan: DslPlan) -> Self

Converts to this type from the input type.

impl<'a> IntoIterator for &'a DslPlan

type Item = &'a DslPlan

The type of the elements being iterated over.

type IntoIter = DslPlanIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a DslPlan as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PlanCallbackArgs for DslPlan

fn into_pyany<'py>(self, _py: Python<'py>) -> Result<Py<PyAny>, PyErr>

Available on crate feature python only.

impl PlanCallbackOut for DslPlan

fn from_pyany<'py>(pyany: Py<PyAny>, _py: Python<'py>) -> Result<DslPlan, PyErr>

Available on crate feature python only.

impl Serialize for DslPlan

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.

impl TryFrom<&SerializableDslPlan> for DslPlan

type Error = PolarsError

The type returned in the event of a conversion error.

fn try_from( ser_dsl_plan: &SerializableDslPlan, ) -> Result<DslPlan, <DslPlan as TryFrom<&SerializableDslPlan>>::Error>

Performs the conversion.