Struct datafusion::logical_expr::LogicalPlanBuilder

pub struct LogicalPlanBuilder { /* private fields */ }

Builder for logical plans

// Create a plan similar to
// SELECT last_name
// FROM employees
// WHERE salary < 1000
let plan = table_scan(
             Some("employee"),
             &employee_schema(),
             None,
           )?
           // Keep only rows where salary < 1000
           .filter(col("salary").lt_eq(lit(1000)))?
           // only show "last_name" in the final results
           .project(vec![col("last_name")])?
           .build()?;

Implementations

impl LogicalPlanBuilder

pub fn from(plan: LogicalPlan) -> LogicalPlanBuilder

Create a builder from an existing plan

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

Return the output schema of the plan build so far

pub fn empty(produce_one_row: bool) -> LogicalPlanBuilder

Create an empty relation.

produce_one_row set to true means this empty node needs to produce a placeholder row.

pub fn values( values: Vec<Vec<Expr, Global>, Global> ) -> Result<LogicalPlanBuilder, DataFusionError>

Create a values list based relation, and the schema is inferred from data, consuming value. See the Postgres VALUES documentation for more details.

By default, it assigns the names column1, column2, etc. to the columns of a VALUES table. The column names are not specified by the SQL standard and different database systems do it differently, so it’s usually better to override the default names with a table alias list.

If the values include params/binders such as $1, $2, $3, etc, then the param_data_types should be provided.

pub fn scan( table_name: impl Into<TableReference<'static>>, table_source: Arc<dyn TableSource, Global>, projection: Option<Vec<usize, Global>> ) -> Result<LogicalPlanBuilder, DataFusionError>

Convert a table provider into a builder with a TableScan

Note that if you pass a string as table_name, it is treated as a SQL identifier, as described on TableReference and thus is normalized

Example:

// Scan table_source with the name "mytable" (after normalization)
let scan = LogicalPlanBuilder::scan("MyTable", table, None);

// Scan table_source with the name "MyTable" by enclosing in quotes
let scan = LogicalPlanBuilder::scan(r#""MyTable""#, table, None);

// Scan table_source with the name "MyTable" by forming the table reference
let table_reference = TableReference::bare("MyTable");
let scan = LogicalPlanBuilder::scan(table_reference, table, None);

pub fn insert_into( input: LogicalPlan, table_name: impl Into<TableReference<'static>>, table_schema: &Schema ) -> Result<LogicalPlanBuilder, DataFusionError>

Create a DmlStatement for inserting the contents of this builder into the named table

pub fn scan_with_filters( table_name: impl Into<TableReference<'static>>, table_source: Arc<dyn TableSource, Global>, projection: Option<Vec<usize, Global>>, filters: Vec<Expr, Global> ) -> Result<LogicalPlanBuilder, DataFusionError>

Convert a table provider into a builder with a TableScan

pub fn window_plan( input: LogicalPlan, window_exprs: Vec<Expr, Global> ) -> Result<LogicalPlan, DataFusionError>

Wrap a plan in a window

pub fn project( self, expr: impl IntoIterator<Item = impl Into<Expr>> ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a projection without alias.

pub fn select( self, indices: impl IntoIterator<Item = usize> ) -> Result<LogicalPlanBuilder, DataFusionError>

Select the given column indices

pub fn filter( self, expr: impl Into<Expr> ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a filter

pub fn prepare( self, name: String, data_types: Vec<DataType, Global> ) -> Result<LogicalPlanBuilder, DataFusionError>

Make a builder for a prepare logical plan from the builder’s plan

pub fn limit( self, skip: usize, fetch: Option<usize> ) -> Result<LogicalPlanBuilder, DataFusionError>

Limit the number of rows returned

skip - Number of rows to skip before fetch any row.

fetch - Maximum number of rows to fetch, after skipping skip rows, if specified.

pub fn alias( self, alias: impl Into<TableReference<'static>> ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply an alias

pub fn sort( self, exprs: impl IntoIterator<Item = impl Into<Expr>> + Clone ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a sort

pub fn union( self, plan: LogicalPlan ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a union, preserving duplicate rows

pub fn union_distinct( self, plan: LogicalPlan ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a union, removing duplicate rows

pub fn distinct(self) -> Result<LogicalPlanBuilder, DataFusionError>

Apply deduplication: Only distinct (different) values are returned)

pub fn join( self, right: LogicalPlan, join_type: JoinType, join_keys: (Vec<impl Into<Column>, Global>, Vec<impl Into<Column>, Global>), filter: Option<Expr> ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a join with on constraint.

Filter expression expected to contain non-equality predicates that can not be pushed down to any of join inputs. In case of outer join, filter applied to only matched rows.

pub fn join_detailed( self, right: LogicalPlan, join_type: JoinType, join_keys: (Vec<impl Into<Column>, Global>, Vec<impl Into<Column>, Global>), filter: Option<Expr>, null_equals_null: bool ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a join with on constraint and specified null equality If null_equals_null is true then null == null, else null != null

pub fn join_using( self, right: LogicalPlan, join_type: JoinType, using_keys: Vec<impl Into<Column> + Clone, Global> ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a join with using constraint, which duplicates all join columns in output schema.

pub fn cross_join( self, right: LogicalPlan ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a cross join

pub fn repartition( self, partitioning_scheme: Partitioning ) -> Result<LogicalPlanBuilder, DataFusionError>

Repartition

pub fn window( self, window_expr: impl IntoIterator<Item = impl Into<Expr>> ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a window functions to extend the schema

pub fn aggregate( self, group_expr: impl IntoIterator<Item = impl Into<Expr>>, aggr_expr: impl IntoIterator<Item = impl Into<Expr>> ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply an aggregate: grouping on the group_expr expressions and calculating aggr_expr aggregates for each distinct value of the group_expr;

pub fn explain( self, verbose: bool, analyze: bool ) -> Result<LogicalPlanBuilder, DataFusionError>

Create an expression to represent the explanation of the plan

if analyze is true, runs the actual plan and produces information about metrics during run.

if verbose is true, prints out additional details.

pub fn intersect( left_plan: LogicalPlan, right_plan: LogicalPlan, is_all: bool ) -> Result<LogicalPlan, DataFusionError>

Process intersect set operator

pub fn except( left_plan: LogicalPlan, right_plan: LogicalPlan, is_all: bool ) -> Result<LogicalPlan, DataFusionError>

Process except set operator

pub fn build(self) -> Result<LogicalPlan, DataFusionError>

Build the plan

pub fn join_with_expr_keys( self, right: LogicalPlan, join_type: JoinType, equi_exprs: (Vec<impl Into<Expr>, Global>, Vec<impl Into<Expr>, Global>), filter: Option<Expr> ) -> Result<LogicalPlanBuilder, DataFusionError>

Apply a join with the expression on constraint.

equi_exprs are “equijoin” predicates expressions on the existing and right inputs, respectively.

filter: any other filter expression to apply during the join. equi_exprs predicates are likely to be evaluated more quickly than the filter expressions

pub fn unnest_column( self, column: impl Into<Column> ) -> Result<LogicalPlanBuilder, DataFusionError>

Unnest the given column.

Trait Implementations

impl Clone for LogicalPlanBuilder

fn clone(&self) -> LogicalPlanBuilder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalPlanBuilder

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

Formats the value using the given formatter.