Module sql::plan

SQL planning.

SQL planning is the process of taking the abstract syntax tree of a Statement and turning it into a Plan that the dataflow layer can execute.

Statements must be purified before they can be planned. See the pure module for details.

Modules

error
explain	This module houses a pretty printer for HirRelationExpr, which is the SQL-specific relation expression (as opposed to expr::MirRelationExpr). See also expr::explain.
expr	This file houses a representation of a SQL plan that is parallel to that found in src/expr/relation/mod.rs, but represents an earlier phase of planning. It's structurally very similar to that file, with some differences which are noted below. It gets turned into that representation via a call to decorrelate().
lowering	Lowering is the process of transforming a sql::expr::HirRelationExpr into a expr::MirRelationExpr.
plan_utils	Helper code used throughout the planner.
query	SQL Querys are the declarative, computational part of SQL. This module turns Querys into HirRelationExprs - a more explicit, algebraic way of describing computation. Functions named plan_* are typically responsible for handling a single node of the SQL ast. Eg plan_query is responsible for handling sqlparser::ast::Query. plan_* functions which correspond to operations on relations typically return a HirRelationExpr. plan_* functions which correspond to operations on scalars typically return a HirScalarExpr and a ScalarType. (The latter is because it's not always possible to infer from a HirScalarExpr what the intended type is - notably in the case of decimals where the scale/precision are encoded only in the type). Aggregates are particularly twisty. In SQL, a GROUP BY turns any columns not in the group key into vectors of values. Then anywhere later in the scope, an aggregate function can be applied to that group. Inside the arguments of an aggregate function, other normal functions are applied element-wise over the vectors. Thus SELECT sum(foo.x + foo.y) FROM foo GROUP BY x means adding the scalar x to the vector y and summing the results. In HirRelationExpr, aggregates can only be applied immediately at the time of grouping. To deal with this, whenever we see a SQL GROUP BY we look ahead for aggregates and precompute them in the HirRelationExpr::Reduce. When we reach the same aggregates during normal planning later on, we look them up in an ExprContext to find the precomputed versions.
scope	Handles SQL's scoping rules.
statement	Statement planning.
transform_ast	Transformations of SQL ASTs.
transform_expr	Transformations of SQL IR, before decorrelation.
typeconv	Maintains a catalog of valid casts between repr::ScalarTypes, as well as other cast-related functions.

Structs

Aug
CreateSourcePlan
Explanation	An Explanation facilitates pretty-printing of a HirRelationExpr.
Index
Params	A vector of values to which parameter references should be bound.
PlanContext	Controls planning of a SQL query.
QueryContext	The state required when planning a Query.
Sink
Source
StatementContext	Immutable state that applies to the planning of an entire Statement.
StatementDesc	Describes the output of a SQL statement.
Table
Type
View

Enums

CopyFormat
ExecuteTimeout
HirRelationExpr	Just like MirRelationExpr, except where otherwise noted below.
HirScalarExpr	Just like expr::MirScalarExpr, except where otherwise noted below.
IndexOption
IndexOptionName
MutationKind
PeekWhen	Specifies when a Peek should occur.
Plan	Instructions for executing a SQL query.
PlanError
QueryLifetime	Specifies how long a query will live. This impacts whether the query is allowed to reason about the time at which it is running, e.g., by calling the now() function.
TypeInner

Functions

describe	Creates a description of the purified statement stmt.
plan	Produces a Plan from the purified statement stmt.
plan_default_expr
resolve_names
resolve_names_data_type
resolve_names_stmt
scalar_type_from_sql
unwrap_numeric_typ_mod	Returns the first two values provided as typ_mods as u8, which are appropriate values to associate with ScalarType::Decimal's values, precision and scale.