[−][src]Enum datafusion::logical_plan::LogicalPlan
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
Evaluates an arbitrary list of expressions (essentially a SELECT with an expression list) on its input.
Fields of Projection
expr: Vec<Expr>
The list of expressions
input: Arc<LogicalPlan>
The incoming logical plan
schema: DFSchemaRef
The schema description of the output
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.
Fields of Filter
predicate: Expr
The predicate expression, which must have Boolean type.
input: Arc<LogicalPlan>
The incoming logical plan
Aggregates its input based on a set of grouping and aggregate expressions (e.g. SUM).
Fields of Aggregate
input: Arc<LogicalPlan>
The incoming logical plan
group_expr: Vec<Expr>
Grouping expressions
aggr_expr: Vec<Expr>
Aggregate expressions
schema: DFSchemaRef
The schema description of the aggregate output
Sorts its input according to a list of sort expressions.
Fields of Sort
Join two logical plans on one or more join columns
Fields of Join
left: Arc<LogicalPlan>
Left input
right: Arc<LogicalPlan>
Right input
on: Vec<(String, String)>
Equijoin clause expressed as pairs of (left, right) join columns
join_type: JoinType
Join type
schema: DFSchemaRef
The output schema, containing fields from the left and right inputs
Repartition the plan based on a partitioning scheme.
Fields of Repartition
input: Arc<LogicalPlan>
The incoming logical plan
partitioning_scheme: Partitioning
The partitioning scheme
Produces rows from a table provider by reference or from the context
Fields of TableScan
table_name: String
The name of the table
source: Arc<dyn TableProvider + Send + Sync>
The source of the table
projection: Option<Vec<usize>>
Optional column indices to use as a projection
projected_schema: DFSchemaRef
The schema description of the output
filters: Vec<Expr>
Optional expressions to be used as filters by the table provider
Produces no rows: An empty relation with an empty schema
Fields of EmptyRelation
produce_one_row: bool
Whether to produce a placeholder row
schema: DFSchemaRef
The schema description of the output
Produces the first n
tuples from its input and discards the rest.
Fields of Limit
Creates an external table.
Fields of CreateExternalTable
schema: DFSchemaRef
The table schema
name: String
The table name
location: String
The physical location
file_type: FileType
The file type of physical file
has_header: bool
Whether the CSV file contains a header
Produces a relation with string representations of various parts of the plan
Fields of Explain
verbose: bool
Should extra (detailed, intermediate plans) be included?
plan: Arc<LogicalPlan>
The logical plan that is being EXPLAIN'd
stringified_plans: Vec<StringifiedPlan>
Represent the various stages plans have gone through
schema: DFSchemaRef
The output schema of the explain (2 columns of text)
Extension operator defined outside of DataFusion
Fields of Extension
node: Arc<dyn UserDefinedLogicalNode + Send + Sync>
The runtime extension operator
Implementations
impl LogicalPlan
[src]
pub fn schema(&self) -> &DFSchemaRef
[src]
Get a reference to the logical plan's schema
pub fn explain_schema() -> SchemaRef
[src]
Returns the (fixed) output schema for explain plans
impl LogicalPlan
[src]
pub fn accept<V>(&self, visitor: &mut V) -> Result<bool, V::Error> where
V: PlanVisitor,
[src]
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
[src]
pub fn display_indent(&self) -> impl Display + '_
[src]
Return a format
able structure that produces a single line
per node. For example:
Projection: #id
Filter: #state Eq Utf8(\"CO\")\
CsvScan: employee.csv projection=Some([0, 3])
use arrow::datatypes::{Field, Schema, DataType}; use datafusion::logical_plan::{lit, col, LogicalPlanBuilder}; let schema = Schema::new(vec![ Field::new("id", DataType::Int32, false), ]); let plan = LogicalPlanBuilder::scan_empty("foo.csv", &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: #id Eq Int32(5)\ \n TableScan: foo.csv projection=None", display_string);
pub fn display_indent_schema(&self) -> impl Display + '_
[src]
Return a format
able structure that produces a single line
per node that includes the output schema. For example:
Projection: #id [id:Int32]\
Filter: #state Eq Utf8(\"CO\") [id:Int32, state:Utf8]\
TableScan: employee.csv projection=Some([0, 3]) [id:Int32, state:Utf8]";
use arrow::datatypes::{Field, Schema, DataType}; use datafusion::logical_plan::{lit, col, LogicalPlanBuilder}; let schema = Schema::new(vec![ Field::new("id", DataType::Int32, false), ]); let plan = LogicalPlanBuilder::scan_empty("foo.csv", &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: #id Eq Int32(5) [id:Int32]\ \n TableScan: foo.csv projection=None [id:Int32]", display_string);
pub fn display_graphviz(&self) -> impl Display + '_
[src]
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::logical_plan::{lit, col, LogicalPlanBuilder}; let schema = Schema::new(vec![ Field::new("id", DataType::Int32, false), ]); let plan = LogicalPlanBuilder::scan_empty("foo.csv", &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 + '_
[src]
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::logical_plan::{lit, col, LogicalPlanBuilder}; let schema = Schema::new(vec![ Field::new("id", DataType::Int32, false), ]); let plan = LogicalPlanBuilder::scan_empty("foo.csv", &schema, None).unwrap() .build().unwrap(); // Format using display let display_string = format!("{}", plan.display()); assert_eq!("TableScan: foo.csv projection=None", display_string);
Trait Implementations
impl Clone for LogicalPlan
[src]
fn clone(&self) -> LogicalPlan
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for LogicalPlan
[src]
Auto Trait Implementations
impl !RefUnwindSafe for LogicalPlan
[src]
impl Send for LogicalPlan
[src]
impl Sync for LogicalPlan
[src]
impl Unpin for LogicalPlan
[src]
impl !UnwindSafe for LogicalPlan
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
pub unsafe fn drop(ptr: usize)
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,