Enum datafusion::logical_plan::LogicalPlan

pub enum LogicalPlan {
    Projection(Projection),
    Filter(Filter),
    Window(Window),
    Aggregate(Aggregate),
    Sort(Sort),
    Join(Join),
    CrossJoin(CrossJoin),
    Repartition(Repartition),
    Union(Union),
    TableScan(TableScan),
    EmptyRelation(EmptyRelation),
    Subquery(Subquery),
    SubqueryAlias(SubqueryAlias),
    Limit(Limit),
    CreateExternalTable(CreateExternalTable),
    CreateMemoryTable(CreateMemoryTable),
    CreateView(CreateView),
    CreateCatalogSchema(CreateCatalogSchema),
    CreateCatalog(CreateCatalog),
    DropTable(DropTable),
    Values(Values),
    Explain(Explain),
    Analyze(Analyze),
    Extension(Extension),
    Distinct(Distinct),
}

A LogicalPlan represents the different types of relational operators (such as Projection, Filter, etc) and can be created by the SQL query planner and the DataFrame API.

A LogicalPlan represents transforming an input relation (table) to an output relation (table) with a (potentially) different schema. A plan represents a dataflow tree where data flows from leaves up to the root to produce the query result.

Variants

Projection(Projection)

Evaluates an arbitrary list of expressions (essentially a SELECT with an expression list) on its input.

Filter(Filter)

Filters rows from its input that do not match an expression (essentially a WHERE clause with a predicate expression).

Semantically, <predicate> is evaluated for each row of the input; If the value of <predicate> is true, the input row is passed to the output. If the value of <predicate> is false, the row is discarded.

Window(Window)

Window its input based on a set of window spec and window function (e.g. SUM or RANK)

Aggregate(Aggregate)

Aggregates its input based on a set of grouping and aggregate expressions (e.g. SUM).

Sort(Sort)

Sorts its input according to a list of sort expressions.

Join(Join)

Join two logical plans on one or more join columns

CrossJoin(CrossJoin)

Apply Cross Join to two logical plans

Repartition(Repartition)

Repartition the plan based on a partitioning scheme.

Union(Union)

Union multiple inputs

TableScan(TableScan)

Produces rows from a table provider by reference or from the context

EmptyRelation(EmptyRelation)

Produces no rows: An empty relation with an empty schema

Subquery(Subquery)

Subquery

SubqueryAlias(SubqueryAlias)

Aliased relation provides, or changes, the name of a relation.

Limit(Limit)

Skip some number of rows, and then fetch some number of rows.

CreateExternalTable(CreateExternalTable)

Creates an external table.

CreateMemoryTable(CreateMemoryTable)

Creates an in memory table.

CreateView(CreateView)

Creates a new view.

CreateCatalogSchema(CreateCatalogSchema)

Creates a new catalog schema.

CreateCatalog(CreateCatalog)

Creates a new catalog (aka “Database”).

DropTable(DropTable)

Drops a table.

Values(Values)

Values expression. See Postgres VALUES documentation for more details.

Explain(Explain)

Produces a relation with string representations of various parts of the plan

Analyze(Analyze)

Runs the actual plan, and then prints the physical plan with with execution metrics.

Extension(Extension)

Extension operator defined outside of DataFusion

Distinct(Distinct)

Remove duplicate rows from the input

Implementations

impl LogicalPlan

pub fn schema(&self) -> &Arc<DFSchema>

Get a reference to the logical plan’s schema

pub fn all_schemas(&self) -> Vec<&Arc<DFSchema>, Global>

Get a vector of references to all schemas in every node of the logical plan

pub fn explain_schema() -> Arc<Schema>

Returns the (fixed) output schema for explain plans

pub fn expressions(&self) -> Vec<Expr, Global>

returns all expressions (non-recursively) in the current logical plan node. This does not include expressions in any children

pub fn inputs(&self) -> Vec<&LogicalPlan, Global>

returns all inputs of this LogicalPlan node. Does not include inputs to inputs.

pub fn using_columns(
    &self
) -> Result<Vec<HashSet<Column, RandomState>, Global>, DataFusionError>

returns all Using join columns in a logical plan

impl LogicalPlan

pub fn accept<V>(
    &self,
    visitor: &mut V
) -> Result<bool, <V as PlanVisitor>::Error> where
    V: PlanVisitor, 

returns all inputs in the logical plan. Returns Ok(true) if all nodes were visited, and Ok(false) if any call to pre_visit or post_visit returned Ok(false) and may have cut short the recursion

impl LogicalPlan

pub fn display_indent(&self) -> impl Display

Return a formatable structure that produces a single line per node. For example:

Projection: #employee.id
   Filter: #employee.state Eq Utf8(\"CO\")\
      CsvScan: employee projection=Some([0, 3])

use arrow::datatypes::{Field, Schema, DataType};
use datafusion_expr::{lit, col, LogicalPlanBuilder, logical_plan::table_scan};
let schema = Schema::new(vec![
    Field::new("id", DataType::Int32, false),
]);
let plan = table_scan(Some("t1"), &schema, None).unwrap()
    .filter(col("id").eq(lit(5))).unwrap()
    .build().unwrap();

// Format using display_indent
let display_string = format!("{}", plan.display_indent());

assert_eq!("Filter: #t1.id = Int32(5)\n  TableScan: t1",
            display_string);

pub fn display_indent_schema(&self) -> impl Display

Return a formatable structure that produces a single line per node that includes the output schema. For example:

Projection: #employee.id [id:Int32]\
   Filter: #employee.state = Utf8(\"CO\") [id:Int32, state:Utf8]\
     TableScan: employee projection=[0, 3] [id:Int32, state:Utf8]";

use arrow::datatypes::{Field, Schema, DataType};
use datafusion_expr::{lit, col, LogicalPlanBuilder, logical_plan::table_scan};
let schema = Schema::new(vec![
    Field::new("id", DataType::Int32, false),
]);
let plan = table_scan(Some("t1"), &schema, None).unwrap()
    .filter(col("id").eq(lit(5))).unwrap()
    .build().unwrap();

// Format using display_indent_schema
let display_string = format!("{}", plan.display_indent_schema());

assert_eq!("Filter: #t1.id = Int32(5) [id:Int32]\
            \n  TableScan: t1 [id:Int32]",
            display_string);

pub fn display_graphviz(&self) -> impl Display

Return a formatable structure that produces lines meant for graphical display using the DOT language. This format can be visualized using software from graphviz

This currently produces two graphs – one with the basic structure, and one with additional details such as schema.

use arrow::datatypes::{Field, Schema, DataType};
use datafusion_expr::{lit, col, LogicalPlanBuilder, logical_plan::table_scan};
let schema = Schema::new(vec![
    Field::new("id", DataType::Int32, false),
]);
let plan = table_scan(Some("t1"), &schema, None).unwrap()
    .filter(col("id").eq(lit(5))).unwrap()
    .build().unwrap();

// Format using display_graphviz
let graphviz_string = format!("{}", plan.display_graphviz());

If graphviz string is saved to a file such as /tmp/example.dot, the following commands can be used to render it as a pdf:

  dot -Tpdf < /tmp/example.dot  > /tmp/example.pdf

pub fn display(&self) -> impl Display

Return a formatable structure with the a human readable description of this LogicalPlan node per node, not including children. For example:

Projection: #id

use arrow::datatypes::{Field, Schema, DataType};
use datafusion_expr::{lit, col, LogicalPlanBuilder, logical_plan::table_scan};
let schema = Schema::new(vec![
    Field::new("id", DataType::Int32, false),
]);
let plan = table_scan(Some("t1"), &schema, None).unwrap()
    .build().unwrap();

// Format using display
let display_string = format!("{}", plan.display());

assert_eq!("TableScan: t1", display_string);

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 ToStringifiedPlan for LogicalPlan

fn to_stringified(&self, plan_type: PlanType) -> StringifiedPlan

Create a stringified plan with the specified type