Enum datafusion_expr::LogicalPlan
source · [−]pub enum LogicalPlan {
Show 25 variants
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),
}
Expand description
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
sourceimpl LogicalPlan
impl LogicalPlan
sourcepub fn schema(&self) -> &DFSchemaRef
pub fn schema(&self) -> &DFSchemaRef
Get a reference to the logical plan’s schema
sourcepub fn all_schemas(&self) -> Vec<&DFSchemaRef>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
pub fn all_schemas(&self) -> Vec<&DFSchemaRef>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Get a vector of references to all schemas in every node of the logical plan
sourcepub fn explain_schema() -> SchemaRef
pub fn explain_schema() -> SchemaRef
Returns the (fixed) output schema for explain plans
sourcepub fn expressions(self: &LogicalPlan) -> Vec<Expr>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
pub fn expressions(self: &LogicalPlan) -> Vec<Expr>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
returns all expressions (non-recursively) in the current logical plan node. This does not include expressions in any children
sourcepub fn inputs(self: &LogicalPlan) -> Vec<&LogicalPlan>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
pub fn inputs(self: &LogicalPlan) -> Vec<&LogicalPlan>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
returns all inputs of this LogicalPlan
node. Does not
include inputs to inputs.
sourcepub fn using_columns(&self) -> Result<Vec<HashSet<Column>>, DataFusionError>
pub fn using_columns(&self) -> Result<Vec<HashSet<Column>>, DataFusionError>
returns all Using
join columns in a logical plan
sourceimpl LogicalPlan
impl LogicalPlan
sourceimpl LogicalPlan
impl LogicalPlan
sourcepub fn display_indent(&self) -> impl Display + '_
pub fn display_indent(&self) -> impl Display + '_
Return a format
able 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);
sourcepub fn display_indent_schema(&self) -> impl Display + '_
pub fn display_indent_schema(&self) -> impl Display + '_
Return a format
able 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);
sourcepub fn display_graphviz(&self) -> impl Display + '_
pub fn display_graphviz(&self) -> impl Display + '_
Return a format
able 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
sourcepub fn display(&self) -> impl Display + '_
pub fn display(&self) -> impl Display + '_
Return a format
able 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
sourceimpl Clone for LogicalPlan
impl Clone for LogicalPlan
sourcefn clone(&self) -> LogicalPlan
fn clone(&self) -> LogicalPlan
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl Debug for LogicalPlan
impl Debug for LogicalPlan
sourceimpl ToStringifiedPlan for LogicalPlan
impl ToStringifiedPlan for LogicalPlan
sourcefn to_stringified(&self, plan_type: PlanType) -> StringifiedPlan
fn to_stringified(&self, plan_type: PlanType) -> StringifiedPlan
Create a stringified plan with the specified type
Auto Trait Implementations
impl !RefUnwindSafe for LogicalPlan
impl Send for LogicalPlan
impl Sync for LogicalPlan
impl Unpin for LogicalPlan
impl !UnwindSafe for LogicalPlan
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more