org.apache.calcite.sql2rel

Class SqlToRelConverter

java.lang.Object

org.apache.calcite.sql2rel.SqlToRelConverter

public class SqlToRelConverter
extends Object

Converts a SQL parse tree (consisting of SqlNode objects) into a relational algebra expression (consisting of RelNode objects).

The public entry points are: convertQuery(org.apache.calcite.sql.SqlNode, boolean, boolean), convertExpression(SqlNode).

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	SqlToRelConverter.AggConverter Converts expressions to aggregates.
protected class	SqlToRelConverter.Blackboard Workspace for translating an individual SELECT statement (or sub-SELECT).

Field Summary

Fields

Modifier and Type	Field and Description
protected Prepare.CatalogReader	catalogReader
protected RelOptCluster	cluster
protected List<RelNode>	leaves
protected RexBuilder	rexBuilder
protected static Logger	SQL2REL_LOGGER
protected RelDataTypeFactory	typeFactory
protected SqlValidator	validator
RelOptTable.ViewExpander	viewExpander

Constructor Summary

Constructors

Constructor and Description
SqlToRelConverter(RelOptTable.ViewExpander viewExpander, SqlValidator validator, Prepare.CatalogReader catalogReader, RelOptPlanner planner, RexBuilder rexBuilder, SqlRexConvertletTable convertletTable) Creates a converter.

Method Summary

Methods

Modifier and Type	Method and Description
void	addConvertedNonCorrSubqs(Map<SqlNode,RexNode> alreadyConvertedNonCorrSubqs) Adds to the current map of non-correlated converted subqueries the elements from another map that contains non-correlated subqueries that have been converted by another SqlToRelConverter.
protected RexNode	adjustInputRef(SqlToRelConverter.Blackboard bb, RexInputRef inputRef) Adjusts the type of a reference to an input field to account for nulls introduced by outer joins; and adjusts the offset to match the physical implementation.
protected void	afterTableFunction(SqlToRelConverter.Blackboard bb, SqlCall call, LogicalTableFunctionScan callRel)
protected boolean	checkConvertedRowType(SqlNode query, RelDataType convertedRowType)
protected void	collectInsertTargets(SqlInsert call, RexNode sourceRef, List<String> targetColumnNames, List<RexNode> columnExprs) Given an INSERT statement, collects the list of names to be populated and the expressions to put in them.
protected void	convertAgg(SqlToRelConverter.Blackboard bb, SqlSelect select, List<SqlNode> orderExprList) Converts the SELECT, GROUP BY and HAVING clauses of an aggregate query.
protected void	convertCollectionTable(SqlToRelConverter.Blackboard bb, SqlCall call)
protected RelNode	convertColumnList(SqlInsert call, RelNode sourceRel) Creates a source for an INSERT statement.
RexDynamicParam	convertDynamicParam(SqlDynamicParam dynamicParam)
RexNode	convertExpression(SqlNode node) Converts an expression from SqlNode to RexNode format.
RexNode	convertExpression(SqlNode node, Map<String,RexNode> nameToNodeMap) Converts an expression from SqlNode to RexNode format, mapping identifier references to predefined expressions.
protected RexNode	convertExtendedExpression(SqlNode node, SqlToRelConverter.Blackboard bb) Converts a non-standard expression.
protected void	convertFrom(SqlToRelConverter.Blackboard bb, SqlNode from) Converts a FROM clause into a relational expression.
protected RelNode	convertInsert(SqlInsert call)
protected void	convertOrder(SqlSelect select, SqlToRelConverter.Blackboard bb, RelCollation collation, List<SqlNode> orderExprList, SqlNode offset, SqlNode fetch) Converts a query's ORDER BY clause, if any.
protected RelFieldCollation	convertOrderItem(SqlSelect select, SqlNode orderItem, List<SqlNode> extraExprs, RelFieldCollation.Direction direction, RelFieldCollation.NullDirection nullDirection)
RelNode	convertQuery(SqlNode query, boolean needsValidation, boolean top) Converts an unvalidated query's parse tree into a relational expression.
protected RelNode	convertQueryRecursive(SqlNode query, boolean top, RelDataType targetRowType) Recursively converts a query to a relational expression.
RelNode	convertSelect(SqlSelect select) Converts a SELECT statement's parse tree into a relational expression.
protected void	convertSelectImpl(SqlToRelConverter.Blackboard bb, SqlSelect select) Implementation of convertSelect(SqlSelect); derived class may override.
protected RelNode	convertSetOp(SqlCall call) Converts a set operation (UNION, INTERSECT, MINUS) into relational expressions.
RelNode	convertToSingleValueSubq(SqlNode query, RelNode plan) Converts the RelNode tree for a select statement to a select that produces a single value.
RelNode	convertValues(SqlCall values, RelDataType targetRowType) Converts a SELECT statement's parse tree into a relational expression.
RelNode	convertWith(SqlWith with) Converts a WITH sub-query into a relational expression.
protected void	createAggImpl(SqlToRelConverter.Blackboard bb, SqlToRelConverter.AggConverter aggConverter, SqlNodeList selectList, SqlNodeList groupList, SqlNode having, List<SqlNode> orderExprList)
protected RelNode	createAggregate(SqlToRelConverter.Blackboard bb, boolean indicator, ImmutableBitSet groupSet, com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Creates an Aggregate.
protected SqlToRelConverter.Blackboard	createBlackboard(SqlValidatorScope scope, Map<String,RexNode> nameToNodeMap) Factory method for creating translation workspace.
protected RelNode	createJoin(RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped) Factory method that creates a join.
protected RelNode	createJoin(SqlToRelConverter.Blackboard bb, RelNode leftRel, RelNode rightRel, RexNode joinCond, JoinRelType joinType)
RelNode	decorrelate(SqlNode query, RelNode rootRel) If subquery is correlated and decorrelation is enabled, performs decorrelation.
protected RelNode	decorrelateQuery(RelNode rootRel)
protected boolean	enableDecorrelation()
void	enableTableAccessConversion(boolean enabled) Controls whether table access references are converted to physical rels immediately.
void	enableValuesRelCreation(boolean enabled) Controls whether instances of LogicalValues are generated.
protected void	extraSelectItems(SqlToRelConverter.Blackboard bb, SqlSelect select, List<RexNode> exprList, List<String> nameList, Collection<String> aliasList, List<SqlMonotonicity> columnMonotonicityList) Adds extra select items.
RelNode	flattenTypes(RelNode rootRel, boolean restructure)
protected void	gatherOrderExprs(SqlToRelConverter.Blackboard bb, SqlSelect select, SqlNodeList orderList, List<SqlNode> extraOrderExprs, List<RelFieldCollation> collationList) Creates a list of collations required to implement the ORDER BY clause, if there is one.
RelOptCluster	getCluster()
int	getDynamicParamCount() Returns the number of dynamic parameters encountered during translation; this must only be called after convertQuery(org.apache.calcite.sql.SqlNode, boolean, boolean).
int	getDynamicParamCountInExplain(boolean increment) Returns the current count of the number of dynamic parameters in an EXPLAIN PLAN statement.
RelDataType	getDynamicParamType(int index) Returns the type inferred for a dynamic parameter.
protected int	getInSubqueryThreshold() Gets the list size threshold under which convertInToOr(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard, java.util.List<org.apache.calcite.rex.RexNode>, org.apache.calcite.sql.SqlNodeList, boolean) is used.
Map<SqlNode,RexNode>	getMapConvertedNonCorrSubqs()
RexBuilder	getRexBuilder() Returns the row-expression builder.
protected List<RelDataTypeField>	getSystemFields() Returns a list of fields to be prefixed to each relational expression.
protected RelOptTable	getTargetTable(SqlNode call)
boolean	isTrimUnusedFields() Returns whether to trim unused fields as part of the conversion process.
protected RelFieldTrimmer	newFieldTrimmer() Creates a RelFieldTrimmer.
void	setDefaultValueFactory(DefaultValueFactory factory) Set a new DefaultValueFactory.
void	setIsExplain(int nDynamicParams) Indicates that the current statement is part of an EXPLAIN PLAN statement
void	setSubqueryConverter(SubqueryConverter converter) Sets a new SubqueryConverter.
void	setTrimUnusedFields(boolean trim) Sets whether to trim unused fields as part of the conversion process.
RelNode	toRel(RelOptTable table)
RelNode	trimUnusedFields(RelNode rootRel) Walks over a tree of relational expressions, replacing each RelNode with a 'slimmed down' relational expression that projects only the fields required by its consumer.
protected RelDataType	uniquifyFields(RelDataType rowType)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

SQL2REL_LOGGER

protected static final Logger SQL2REL_LOGGER

validator

protected final SqlValidator validator

rexBuilder

protected final RexBuilder rexBuilder

catalogReader

protected final Prepare.CatalogReader catalogReader

cluster

protected final RelOptCluster cluster

leaves

protected final List<RelNode> leaves

typeFactory

protected final RelDataTypeFactory typeFactory

viewExpander

public final RelOptTable.ViewExpander viewExpander

Constructor Detail

SqlToRelConverter

public SqlToRelConverter(RelOptTable.ViewExpander viewExpander,
                 SqlValidator validator,
                 Prepare.CatalogReader catalogReader,
                 RelOptPlanner planner,
                 RexBuilder rexBuilder,
                 SqlRexConvertletTable convertletTable)

Creates a converter.

Parameters:

viewExpander - Preparing statement

validator - Validator

catalogReader - Schema

planner - Planner

rexBuilder - Rex builder

convertletTable - Expression converter

Method Detail

getCluster

public RelOptCluster getCluster()

Returns:

the RelOptCluster in use.

getRexBuilder

public RexBuilder getRexBuilder()

Returns the row-expression builder.

getDynamicParamCount

public int getDynamicParamCount()

Returns the number of dynamic parameters encountered during translation; this must only be called after convertQuery(org.apache.calcite.sql.SqlNode, boolean, boolean).

Returns:

number of dynamic parameters

getDynamicParamType

public RelDataType getDynamicParamType(int index)

Returns the type inferred for a dynamic parameter.

Parameters:

index - 0-based index of dynamic parameter

Returns:

inferred type, never null

getDynamicParamCountInExplain

public int getDynamicParamCountInExplain(boolean increment)

Returns the current count of the number of dynamic parameters in an EXPLAIN PLAN statement.

Parameters:

increment - if true, increment the count

Returns:

the current count before the optional increment

getMapConvertedNonCorrSubqs

public Map<SqlNode,RexNode> getMapConvertedNonCorrSubqs()

Returns:

mapping of non-correlated subqueries that have been converted to the constants that they evaluate to

addConvertedNonCorrSubqs

public void addConvertedNonCorrSubqs(Map<SqlNode,RexNode> alreadyConvertedNonCorrSubqs)

Adds to the current map of non-correlated converted subqueries the elements from another map that contains non-correlated subqueries that have been converted by another SqlToRelConverter.

Parameters:

alreadyConvertedNonCorrSubqs - the other map

setDefaultValueFactory

public void setDefaultValueFactory(DefaultValueFactory factory)

Set a new DefaultValueFactory. To have any effect, this must be called before any convert method.

Parameters:

factory - new DefaultValueFactory

setSubqueryConverter

public void setSubqueryConverter(SubqueryConverter converter)

Sets a new SubqueryConverter. To have any effect, this must be called before any convert method.

Parameters:

converter - new SubqueryConverter

setIsExplain

public void setIsExplain(int nDynamicParams)

Indicates that the current statement is part of an EXPLAIN PLAN statement

Parameters:

nDynamicParams - number of dynamic parameters in the statement

enableTableAccessConversion

public void enableTableAccessConversion(boolean enabled)

Controls whether table access references are converted to physical rels immediately. The optimizer doesn't like leaf rels to have Convention.NONE. However, if we are doing further conversion passes (e.g. RelStructuredTypeFlattener), then we may need to defer conversion. To have any effect, this must be called before any convert method.

Parameters:

enabled - true for immediate conversion (the default); false to generate logical LogicalTableScan instances

enableValuesRelCreation

public void enableValuesRelCreation(boolean enabled)

Controls whether instances of LogicalValues are generated. These may not be supported by all physical implementations. To have any effect, this must be called before any convert method.

Parameters:

enabled - true to allow LogicalValues to be generated (the default); false to force substitution of Project+OneRow instead

flattenTypes

public RelNode flattenTypes(RelNode rootRel,
                   boolean restructure)

decorrelate

public RelNode decorrelate(SqlNode query,
                  RelNode rootRel)

If subquery is correlated and decorrelation is enabled, performs decorrelation.

Parameters:

query - Query

rootRel - Root relational expression

Returns:

New root relational expression after decorrelation

trimUnusedFields

public RelNode trimUnusedFields(RelNode rootRel)

Walks over a tree of relational expressions, replacing each RelNode with a 'slimmed down' relational expression that projects only the fields required by its consumer.

This may make things easier for the optimizer, by removing crud that would expand the search space, but is difficult for the optimizer itself to do it, because optimizer rules must preserve the number and type of fields. Hence, this transform that operates on the entire tree, similar to the type-flattening transform.

Currently this functionality is disabled in farrago/luciddb; the default implementation of this method does nothing.

Parameters:

rootRel - Relational expression that is at the root of the tree

Returns:

Trimmed relational expression

newFieldTrimmer

protected RelFieldTrimmer newFieldTrimmer()

Creates a RelFieldTrimmer.

Returns:

Field trimmer

convertQuery

public RelNode convertQuery(SqlNode query,
                   boolean needsValidation,
                   boolean top)

Converts an unvalidated query's parse tree into a relational expression.

Parameters:

query - Query to convert

needsValidation - Whether to validate the query before converting; false if the query has already been validated.

top - Whether the query is top-level, say if its result will become a JDBC result set; false if the query will be part of a view.

checkConvertedRowType

protected boolean checkConvertedRowType(SqlNode query,
                            RelDataType convertedRowType)

uniquifyFields

protected RelDataType uniquifyFields(RelDataType rowType)

convertSelect

public RelNode convertSelect(SqlSelect select)

Converts a SELECT statement's parse tree into a relational expression.

createBlackboard

protected SqlToRelConverter.Blackboard createBlackboard(SqlValidatorScope scope,
                                            Map<String,RexNode> nameToNodeMap)

Factory method for creating translation workspace.

convertSelectImpl

protected void convertSelectImpl(SqlToRelConverter.Blackboard bb,
                     SqlSelect select)

Implementation of convertSelect(SqlSelect); derived class may override.

convertOrder

protected void convertOrder(SqlSelect select,
                SqlToRelConverter.Blackboard bb,
                RelCollation collation,
                List<SqlNode> orderExprList,
                SqlNode offset,
                SqlNode fetch)

Converts a query's ORDER BY clause, if any.

Parameters:

select - Query

bb - Blackboard

collation - Collation list

orderExprList - Method populates this list with orderBy expressions not present in selectList

offset - Expression for number of rows to discard before returning first row

fetch - Expression for number of rows to fetch

convertToSingleValueSubq

public RelNode convertToSingleValueSubq(SqlNode query,
                               RelNode plan)

Converts the RelNode tree for a select statement to a select that produces a single value.

Parameters:

query - the query

plan - the original RelNode tree corresponding to the statement

Returns:

the converted RelNode tree

getInSubqueryThreshold

protected int getInSubqueryThreshold()

Gets the list size threshold under which convertInToOr(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard, java.util.List<org.apache.calcite.rex.RexNode>, org.apache.calcite.sql.SqlNodeList, boolean) is used. Lists of this size or greater will instead be converted to use a join against an inline table (LogicalValues) rather than a predicate. A threshold of 0 forces usage of an inline table in all cases; a threshold of Integer.MAX_VALUE forces usage of OR in all cases

Returns:

threshold, default 20

convertExpression

public RexNode convertExpression(SqlNode node)

Converts an expression from SqlNode to RexNode format.

Parameters:

node - Expression to translate

Returns:

Converted expression

convertExpression

public RexNode convertExpression(SqlNode node,
                        Map<String,RexNode> nameToNodeMap)

Converts an expression from SqlNode to RexNode format, mapping identifier references to predefined expressions.

Parameters:

node - Expression to translate

nameToNodeMap - map from String to RexNode; when an SqlIdentifier is encountered, it is used as a key and translated to the corresponding value from this map

Returns:

Converted expression

convertExtendedExpression

protected RexNode convertExtendedExpression(SqlNode node,
                                SqlToRelConverter.Blackboard bb)

Converts a non-standard expression.

This method is an extension-point that derived classes can override. If this method returns a null result, the normal expression translation process will proceed. The default implementation always returns null.

Parameters:

node - Expression

bb - Blackboard

Returns:

null to proceed with the usual expression translation process

convertFrom

protected void convertFrom(SqlToRelConverter.Blackboard bb,
               SqlNode from)

Converts a FROM clause into a relational expression.

Parameters:

bb - Scope within which to resolve identifiers

from - FROM clause of a query. Examples include:

• a single table ("SALES.EMP"),
• an aliased table ("EMP AS E"),
• a list of tables ("EMP, DEPT"),
• an ANSI Join expression ("EMP JOIN DEPT ON EMP.DEPTNO = DEPT.DEPTNO"),
• a VALUES clause ("VALUES ('Fred', 20)"),
• a query ("(SELECT * FROM EMP WHERE GENDER = 'F')"),
• or any combination of the above.

convertCollectionTable

protected void convertCollectionTable(SqlToRelConverter.Blackboard bb,
                          SqlCall call)

afterTableFunction

protected void afterTableFunction(SqlToRelConverter.Blackboard bb,
                      SqlCall call,
                      LogicalTableFunctionScan callRel)

createJoin

protected RelNode createJoin(SqlToRelConverter.Blackboard bb,
                 RelNode leftRel,
                 RelNode rightRel,
                 RexNode joinCond,
                 JoinRelType joinType)

getSystemFields

protected List<RelDataTypeField> getSystemFields()

Returns a list of fields to be prefixed to each relational expression.

Returns:

List of system fields

convertAgg

protected void convertAgg(SqlToRelConverter.Blackboard bb,
              SqlSelect select,
              List<SqlNode> orderExprList)

Converts the SELECT, GROUP BY and HAVING clauses of an aggregate query.

This method extracts SELECT, GROUP BY and HAVING clauses, and creates an SqlToRelConverter.AggConverter, then delegates to createAggImpl(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard, org.apache.calcite.sql2rel.SqlToRelConverter.AggConverter, org.apache.calcite.sql.SqlNodeList, org.apache.calcite.sql.SqlNodeList, org.apache.calcite.sql.SqlNode, java.util.List<org.apache.calcite.sql.SqlNode>). Derived class may override this method to change any of those clauses or specify a different SqlToRelConverter.AggConverter.

Parameters:

bb - Scope within which to resolve identifiers

select - Query

orderExprList - Additional expressions needed to implement ORDER BY

createAggImpl

protected final void createAggImpl(SqlToRelConverter.Blackboard bb,
                 SqlToRelConverter.AggConverter aggConverter,
                 SqlNodeList selectList,
                 SqlNodeList groupList,
                 SqlNode having,
                 List<SqlNode> orderExprList)

createAggregate

protected RelNode createAggregate(SqlToRelConverter.Blackboard bb,
                      boolean indicator,
                      ImmutableBitSet groupSet,
                      com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets,
                      List<AggregateCall> aggCalls)

Creates an Aggregate.

In case the aggregate rel changes the order in which it projects fields, the groupExprProjection parameter is provided, and the implementation of this method may modify it.

The sortedCount parameter is the number of expressions known to be monotonic. These expressions must be on the leading edge of the grouping keys. The default implementation of this method ignores this parameter.

Parameters:

bb - Blackboard

indicator - Whether to output fields indicating grouping sets

groupSet - Bit set of ordinals of grouping columns

groupSets - Grouping sets

aggCalls - Array of calls to aggregate functions

Returns:

LogicalAggregate

convertDynamicParam

public RexDynamicParam convertDynamicParam(SqlDynamicParam dynamicParam)

gatherOrderExprs

protected void gatherOrderExprs(SqlToRelConverter.Blackboard bb,
                    SqlSelect select,
                    SqlNodeList orderList,
                    List<SqlNode> extraOrderExprs,
                    List<RelFieldCollation> collationList)

Creates a list of collations required to implement the ORDER BY clause, if there is one. Populates extraOrderExprs with any sort expressions which are not in the select clause.

Parameters:

bb - Scope within which to resolve identifiers

select - Select clause. Never null, because we invent a dummy SELECT if ORDER BY is applied to a set operation (UNION etc.)

orderList - Order by clause, may be null

extraOrderExprs - Sort expressions which are not in the select clause (output)

collationList - List of collations (output)

convertOrderItem

protected RelFieldCollation convertOrderItem(SqlSelect select,
                                 SqlNode orderItem,
                                 List<SqlNode> extraExprs,
                                 RelFieldCollation.Direction direction,
                                 RelFieldCollation.NullDirection nullDirection)

enableDecorrelation

protected boolean enableDecorrelation()

decorrelateQuery

protected RelNode decorrelateQuery(RelNode rootRel)

setTrimUnusedFields

public void setTrimUnusedFields(boolean trim)

Sets whether to trim unused fields as part of the conversion process.

Parameters:

trim - Whether to trim unused fields

isTrimUnusedFields

public boolean isTrimUnusedFields()

Returns whether to trim unused fields as part of the conversion process.

Returns:

Whether to trim unused fields

convertQueryRecursive

protected RelNode convertQueryRecursive(SqlNode query,
                            boolean top,
                            RelDataType targetRowType)

Recursively converts a query to a relational expression.

Parameters:

query - Query

top - Whether this query is the top-level query of the statement

targetRowType - Target row type, or null

Returns:

Relational expression

convertSetOp

protected RelNode convertSetOp(SqlCall call)

Converts a set operation (UNION, INTERSECT, MINUS) into relational expressions.

Parameters:

call - Call to set operator

Returns:

Relational expression

convertInsert

protected RelNode convertInsert(SqlInsert call)

toRel

public RelNode toRel(RelOptTable table)

getTargetTable

protected RelOptTable getTargetTable(SqlNode call)

convertColumnList

protected RelNode convertColumnList(SqlInsert call,
                        RelNode sourceRel)

Creates a source for an INSERT statement.

If the column list is not specified, source expressions match target columns in order.

If the column list is specified, Source expressions are mapped to target columns by name via targetColumnList, and may not cover the entire target table. So, we'll make up a full row, using a combination of default values and the source expressions provided.

Parameters:

call - Insert expression

sourceRel - Source relational expression

Returns:

Converted INSERT statement

collectInsertTargets

protected void collectInsertTargets(SqlInsert call,
                        RexNode sourceRef,
                        List<String> targetColumnNames,
                        List<RexNode> columnExprs)

Given an INSERT statement, collects the list of names to be populated and the expressions to put in them.

Parameters:

call - Insert statement

sourceRef - Expression representing a row from the source relational expression

targetColumnNames - List of target column names, to be populated

columnExprs - List of expressions, to be populated

adjustInputRef

protected RexNode adjustInputRef(SqlToRelConverter.Blackboard bb,
                     RexInputRef inputRef)

Adjusts the type of a reference to an input field to account for nulls introduced by outer joins; and adjusts the offset to match the physical implementation.

Parameters:

bb - Blackboard

inputRef - Input ref

Returns:

Adjusted input ref

createJoin

protected RelNode createJoin(RelNode left,
                 RelNode right,
                 RexNode condition,
                 JoinRelType joinType,
                 Set<String> variablesStopped)

Factory method that creates a join. A subclass can override to use a different kind of join.

Parameters:

left - Left input

right - Right input

condition - Join condition

joinType - Join type

variablesStopped - Set of names of variables which are set by the LHS and used by the RHS and are not available to nodes above this LogicalJoin in the tree

Returns:

A relational expression representing a join

extraSelectItems

protected void extraSelectItems(SqlToRelConverter.Blackboard bb,
                    SqlSelect select,
                    List<RexNode> exprList,
                    List<String> nameList,
                    Collection<String> aliasList,
                    List<SqlMonotonicity> columnMonotonicityList)

Adds extra select items. The default implementation adds nothing; derived classes may add columns to exprList, nameList, aliasList and columnMonotonicityList.

Parameters:

bb - Blackboard

select - Select statement being translated

exprList - List of expressions in select clause

nameList - List of names, one per column

aliasList - Collection of aliases that have been used already

columnMonotonicityList - List of monotonicity, one per column

convertWith

public RelNode convertWith(SqlWith with)

Converts a WITH sub-query into a relational expression.

convertValues

public RelNode convertValues(SqlCall values,
                    RelDataType targetRowType)

Converts a SELECT statement's parse tree into a relational expression.