Enum datafusion::logical_expr::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),
    Statement(Statement),
    Values(Values),
    Explain(Explain),
    Analyze(Analyze),
    Extension(Extension),
    Distinct(Distinct),
    Prepare(Prepare),
    Dml(DmlStatement),
    Ddl(DdlStatement),
    DescribeTable(DescribeTable),
    Unnest(Unnest),
}

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.

Statement(Statement)

Statement

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

Prepare(Prepare)

Prepare a statement

Dml(DmlStatement)

Insert / Update / Delete

Ddl(DdlStatement)

CREATE / DROP TABLES / VIEWS / SCHEMAs

DescribeTable(DescribeTable)

Describe the schema of table

Unnest(Unnest)

Unnest a column that contains a nested list type.

Implementations

impl LogicalPlan

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

Get a reference to the logical plan’s schema

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

Used for normalizing columns, as the fallback schemas to the main schema of the plan.

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

👎Deprecated since 20.0.0

Get all meaningful schemas of a plan and its children plan.

pub fn explain_schema() -> Arc<Schema, Global>

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 all_out_ref_exprs(&self) -> Vec<Expr, Global>

Returns all the out reference(correlated) expressions (recursively) in the current logical plan nodes and all its descendant nodes.

pub fn inspect_expressions<F, E>(&self, f: F) -> Result<(), E>where F: FnMut(&Expr) -> Result<(), E>,

Calls f on 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, or subqueries.

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

returns all Using join columns in a logical plan

pub fn head_output_expr(&self) -> Result<Option<Expr>, DataFusionError>

returns the first output expression of this LogicalPlan node.

pub fn with_new_inputs( &self, inputs: &[LogicalPlan] ) -> Result<LogicalPlan, DataFusionError>

pub fn with_param_values( self, param_values: Vec<ScalarValue, Global> ) -> Result<LogicalPlan, DataFusionError>

Convert a prepared LogicalPlan into its inner logical plan with all params replaced with their corresponding values

pub fn max_rows(&self) -> Option<usize>

Returns the maximum number of rows that this plan can output, if known.

If None, the plan can return any number of rows. If Some(n) then the plan can return at most n rows but may return fewer.

impl LogicalPlan

pub fn replace_params_with_values( &self, param_values: &[ScalarValue] ) -> Result<LogicalPlan, DataFusionError>

Return a logical plan with all placeholders/params (e.g $1 $2, …) replaced with corresponding values provided in the params_values

pub fn get_parameter_types( &self ) -> Result<HashMap<String, Option<DataType>, RandomState>, DataFusionError>

Walk the logical plan, find any PlaceHolder tokens, and return a map of their IDs and DataTypes

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

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<LogicalPlan> for LogicalPlan

fn eq(&self, other: &LogicalPlan) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToStringifiedPlan for LogicalPlan

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

Create a stringified plan with the specified type

impl TreeNode for LogicalPlan

fn visit<V>(&self, visitor: &mut V) -> Result<VisitRecursion, DataFusionError>where V: TreeNodeVisitor<N = LogicalPlan>,

To use, define a struct that implements the trait TreeNodeVisitor and then invoke LogicalPlan::visit.

For example, for a logical plan like:

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

The sequence of visit operations would be:

visitor.pre_visit(Projection)
visitor.pre_visit(Filter)
visitor.pre_visit(CsvScan)
visitor.post_visit(CsvScan)
visitor.post_visit(Filter)
visitor.post_visit(Projection)

fn apply<F>(&self, op: &mut F) -> Result<VisitRecursion, DataFusionError>where F: FnMut(&LogicalPlan) -> Result<VisitRecursion, DataFusionError>,

Use preorder to iterate the node on the tree so that we can stop fast for some cases.

fn apply_children<F>( &self, op: &mut F ) -> Result<VisitRecursion, DataFusionError>where F: FnMut(&LogicalPlan) -> Result<VisitRecursion, DataFusionError>,

Apply the closure F to the node’s children

fn map_children<F>(self, transform: F) -> Result<LogicalPlan, DataFusionError>where F: FnMut(LogicalPlan) -> Result<LogicalPlan, DataFusionError>,

Apply transform F to the node’s children, the transform F might have a direction(Preorder or Postorder)

fn transform<F>(self, op: &F) -> Result<Self, DataFusionError>where F: Fn(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given op to the node tree. When op does not apply to a given node, it is left unchanged. The default tree traversal direction is transform_up(Postorder Traversal).

fn transform_down<F>(self, op: &F) -> Result<Self, DataFusionError>where F: Fn(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given ‘op’ to the node and all of its children(Preorder Traversal). When the op does not apply to a given node, it is left unchanged.

fn transform_up<F>(self, op: &F) -> Result<Self, DataFusionError>where F: Fn(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given ‘op’ first to all of its children and then itself(Postorder Traversal). When the op does not apply to a given node, it is left unchanged.

fn rewrite<R>(self, rewriter: &mut R) -> Result<Self, DataFusionError>where R: TreeNodeRewriter<N = Self>,

Transform the tree node using the given TreeNodeRewriter It performs a depth first walk of an node and its children.

impl Eq for LogicalPlan

impl StructuralEq for LogicalPlan

impl StructuralPartialEq for LogicalPlan