Struct datafusion_expr::logical_plan::builder::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) -> Self

Create a builder from an existing plan

pub fn schema(&self) -> &DFSchemaRef

Return the output schema of the plan build so far

pub fn empty(produce_one_row: bool) -> Self

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>>) -> Result<Self>

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.

pub fn scan(
    table_name: impl Into<String>,
    table_source: Arc<dyn TableSource>,
    projection: Option<Vec<usize>>
) -> Result<Self>

Convert a table provider into a builder with a TableScan

pub fn scan_with_filters(
    table_name: impl Into<String>,
    table_source: Arc<dyn TableSource>,
    projection: Option<Vec<usize>>,
    filters: Vec<Expr>
) -> Result<Self>

Convert a table provider into a builder with a TableScan

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

Wrap a plan in a window

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

Apply a projection without alias.

pub fn project_with_alias(
    &self,
    expr: impl IntoIterator<Item = impl Into<Expr>>,
    alias: Option<String>
) -> Result<Self>

Apply a projection with alias

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

Apply a filter

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

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: &str) -> Result<Self>

Apply an alias

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

Apply a sort

pub fn union(&self, plan: LogicalPlan) -> Result<Self>

Apply a union, preserving duplicate rows

pub fn union_distinct(&self, plan: LogicalPlan) -> Result<Self>

Apply a union, removing duplicate rows

pub fn distinct(&self) -> Result<Self>

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

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

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>>, Vec<impl Into<Column>>),
    filter: Option<Expr>,
    null_equals_null: bool
) -> Result<Self>

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>
) -> Result<Self>

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

pub fn cross_join(&self, right: &LogicalPlan) -> Result<Self>

Apply a cross join

pub fn repartition(&self, partitioning_scheme: Partitioning) -> Result<Self>

Repartition

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

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<Self>

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<Self>

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>

Process intersect set operator

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

Process except set operator

pub fn build(&self) -> Result<LogicalPlan>

Build the plan