Class org::apache::calcite::sql2rel::SqlToRelConverter

class SqlToRelConverter

Converts a SQL parse tree (consisting of org.apache.calcite.sql.SqlNode objects) into a relational algebra expression (consisting of org.apache.calcite.rel.RelNode objects).

The public entry points are: convertQuery, convertExpression(SqlNode).

Public Functions

org.apache.calcite.sql2rel.SqlToRelConverter.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

org.apache.calcite.sql2rel.SqlToRelConverter.SqlToRelConverter(RelOptTable.ViewExpander viewExpander, SqlValidator validator, Prepare.CatalogReader catalogReader, RelOptCluster cluster, SqlRexConvertletTable convertletTable)
org.apache.calcite.sql2rel.SqlToRelConverter.SqlToRelConverter(RelOptTable.ViewExpander viewExpander, SqlValidator validator, Prepare.CatalogReader catalogReader, RelOptCluster cluster, SqlRexConvertletTable convertletTable, Config config)
RelOptCluster org.apache.calcite.sql2rel.SqlToRelConverter.getCluster()

Returns the RelOptCluster in use.

RexBuilder org.apache.calcite.sql2rel.SqlToRelConverter.getRexBuilder()

Returns the row-expression builder.

int org.apache.calcite.sql2rel.SqlToRelConverter.getDynamicParamCount()

Returns the number of dynamic parameters encountered during translation; this must only be called after convertQuery.

Return

number of dynamic parameters

RelDataType org.apache.calcite.sql2rel.SqlToRelConverter.getDynamicParamType(int index)

Returns the type inferred for a dynamic parameter.

Return

inferred type, never null

Parameters
  • index: 0-based index of dynamic parameter

int org.apache.calcite.sql2rel.SqlToRelConverter.getDynamicParamCountInExplain(boolean increment)

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

Return

the current count before the optional increment

Parameters
  • increment: if true, increment the count

Map<SqlNode, RexNode> org.apache.calcite.sql2rel.SqlToRelConverter.getMapConvertedNonCorrSubqs()

Returns the mapping of non-correlated sub-queries that have been converted to the constants that they evaluate to.

void org.apache.calcite.sql2rel.SqlToRelConverter.addConvertedNonCorrSubqs(Map< SqlNode, RexNode > alreadyConvertedNonCorrSubqs)

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

Parameters
  • alreadyConvertedNonCorrSubqs: the other map

void org.apache.calcite.sql2rel.SqlToRelConverter.setSubQueryConverter(SubQueryConverter converter)

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

Parameters
  • converter: new SubQueryConverter

void org.apache.calcite.sql2rel.SqlToRelConverter.setDynamicParamCountInExplain(int explainParamCount)

Sets the number of dynamic parameters in the current EXPLAIN PLAN statement.

Parameters
  • explainParamCount: number of dynamic parameters in the statement

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.flattenTypes(RelNode rootRel, boolean restructure)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.decorrelate(SqlNode query, RelNode rootRel)

If sub-query is correlated and decorrelation is enabled, performs decorrelation.

Return

New root relational expression after decorrelation

Parameters
  • query: Query

  • rootRel: Root relational expression

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.trimUnusedFields(boolean ordered, 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.

Return

Trimmed relational expression

Parameters
  • ordered: Whether the relational expression must produce results in a particular order (typically because it has an ORDER BY at top level)

  • rootRel: Relational expression that is at the root of the tree

RelRoot org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery(SqlNode query, final boolean needsValidation, final 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.

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertSelect(SqlSelect select, boolean top)

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

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertToSingleValueSubq(SqlNode query, RelNode plan)

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

Return

the converted RelNode tree

Parameters
  • query: the query

  • plan: the original RelNode tree corresponding to the statement

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertExpression(SqlNode node)

Converts an expression from SqlNode to RexNode format.

Return

Converted expression

Parameters
  • node: Expression to translate

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertExpression(SqlNode node, Map< String, RexNode > nameToNodeMap)

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

Return

Converted expression

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

RexDynamicParam org.apache.calcite.sql2rel.SqlToRelConverter.convertDynamicParam(final SqlDynamicParam dynamicParam)
boolean org.apache.calcite.sql2rel.SqlToRelConverter.isTrimUnusedFields()

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

Return

Whether to trim unused fields

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.toRel(final RelOptTable table, final List< RelHint > hints)
RelRoot org.apache.calcite.sql2rel.SqlToRelConverter.convertWith(SqlWith with, boolean top)

Converts a WITH sub-query into a relational expression.

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertValues(SqlCall values, RelDataType targetRowType)

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

Public Members

final SqlToRelConverter.Config org.apache.calcite.sql2rel.SqlToRelConverter.config
final RelOptTable.ViewExpander org.apache.calcite.sql2rel.SqlToRelConverter.viewExpander

Public Static Functions

static boolean org.apache.calcite.sql2rel.SqlToRelConverter.isOrdered(SqlNode query)

Public Static Attributes

final int org.apache.calcite.sql2rel.SqlToRelConverter.DEFAULT_IN_SUB_QUERY_THRESHOLD = 20

Size of the smallest IN list that will be converted to a semijoin to a static table.

final int org.apache.calcite.sql2rel.SqlToRelConverter.DEFAULT_IN_SUBQUERY_THRESHOLD = DEFAULT_IN_SUB_QUERY_THRESHOLD

Protected Functions

RelFieldTrimmer org.apache.calcite.sql2rel.SqlToRelConverter.newFieldTrimmer()

Creates a RelFieldTrimmer.

Return

Field trimmer

Blackboard org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard(SqlValidatorScope scope, Map< String, RexNode > nameToNodeMap, boolean top)

Factory method for creating translation workspace.

void org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl(final Blackboard bb, SqlSelect select)

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

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

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

Ignores the ORDER BY clause if the query is not top-level and FETCH or OFFSET are not present.

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

int org.apache.calcite.sql2rel.SqlToRelConverter.getInSubqueryThreshold()

Gets the list size threshold under which convertInToOr is used. Lists of this size or greater will instead be converted to use a join against an inline table (org.apache.calcite.rel.logical.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

Return

threshold, default DEFAULT_IN_SUB_QUERY_THRESHOLD

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertExtendedExpression(SqlNode node, 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.

Return

null to proceed with the usual expression translation process

Parameters

void org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(Blackboard bb, SqlNode from)
void org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(Blackboard bb, SqlNode from, List< String > fieldNames)

Converts a FROM clause into a relational expression.

Parameters
  • bb: Scope within which to resolve identifiers

  • from: FROM clause of a query. Examples include:

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

  • fieldNames: Field aliases, usually come from AS clause

void org.apache.calcite.sql2rel.SqlToRelConverter.convertMatchRecognize(Blackboard bb, SqlCall call)
void org.apache.calcite.sql2rel.SqlToRelConverter.convertCollectionTable(Blackboard bb, SqlCall call)
void org.apache.calcite.sql2rel.SqlToRelConverter.afterTableFunction(SqlToRelConverter.Blackboard bb, SqlCall call, LogicalTableFunctionScan callRel)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.createJoin(Blackboard bb, RelNode leftRel, RelNode rightRel, RexNode joinCond, JoinRelType joinType)
List<RelDataTypeField> org.apache.calcite.sql2rel.SqlToRelConverter.getSystemFields()

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

Return

List of system fields

void org.apache.calcite.sql2rel.SqlToRelConverter.convertAgg(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 AggConverter, then delegates to createAggImpl. Derived class may override this method to change any of those clauses or specify a different AggConverter.

Parameters
  • bb: Scope within which to resolve identifiers

  • select: Query

  • orderExprList: Additional expressions needed to implement ORDER BY

final void org.apache.calcite.sql2rel.SqlToRelConverter.createAggImpl(Blackboard bb, final AggConverter aggConverter, SqlNodeList selectList, SqlNodeList groupList, SqlNode having, List< SqlNode > orderExprList)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.createAggregate(Blackboard bb, ImmutableBitSet groupSet, 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.

Return

LogicalAggregate

Parameters
  • bb: Blackboard

  • groupSet: Bit set of ordinals of grouping columns

  • groupSets: Grouping sets

  • aggCalls: Array of calls to aggregate functions

void org.apache.calcite.sql2rel.SqlToRelConverter.gatherOrderExprs(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)

RelFieldCollation org.apache.calcite.sql2rel.SqlToRelConverter.convertOrderItem(SqlSelect select, SqlNode orderItem, List< SqlNode > extraExprs, RelFieldCollation.Direction direction, RelFieldCollation.NullDirection nullDirection)
boolean org.apache.calcite.sql2rel.SqlToRelConverter.enableDecorrelation()
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.decorrelateQuery(RelNode rootRel)
RelRoot org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive(SqlNode query, boolean top, RelDataType targetRowType)

Recursively converts a query to a relational expression.

Return

Relational expression

Parameters
  • query: Query

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

  • targetRowType: Target row type, or null

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertSetOp(SqlCall call)

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

Return

Relational expression

Parameters
  • call: Call to set operator

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertInsert(SqlInsert call)
RelOptTable org.apache.calcite.sql2rel.SqlToRelConverter.getTargetTable(SqlNode call)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertColumnList(final SqlInsert call, RelNode source)

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.

Return

Converted INSERT statement

Parameters
  • call: Insert expression

  • source: Source relational expression

void org.apache.calcite.sql2rel.SqlToRelConverter.collectInsertTargets(SqlInsert call, final RexNode sourceRef, final 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

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.adjustInputRef(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.

Return

Adjusted input ref

Parameters

void org.apache.calcite.sql2rel.SqlToRelConverter.extraSelectItems(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

Protected Attributes

final SqlValidator org.apache.calcite.sql2rel.SqlToRelConverter.validator
final RexBuilder org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder
final Prepare.CatalogReader org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader
final RelOptCluster org.apache.calcite.sql2rel.SqlToRelConverter.cluster
final Map<RelNode, Integer> org.apache.calcite.sql2rel.SqlToRelConverter.leaves = new HashMap<>()
final RelDataTypeFactory org.apache.calcite.sql2rel.SqlToRelConverter.typeFactory

Protected Static Attributes

final Logger org.apache.calcite.sql2rel.SqlToRelConverter.SQL2REL_LOGGER = CalciteTrace.getSqlToRelTracer()

Private Functions

void org.apache.calcite.sql2rel.SqlToRelConverter.checkConvertedType(SqlNode query, RelNode result)
RelCollation org.apache.calcite.sql2rel.SqlToRelConverter.requiredCollation(RelNode r)
void org.apache.calcite.sql2rel.SqlToRelConverter.distinctify(Blackboard bb, boolean checkForDupExprs)

Having translated ‘SELECT … FROM … [GROUP BY …] [HAVING …]’, adds a relational expression to make the results unique.

If the SELECT clause contains duplicate expressions, adds org.apache.calcite.rel.logical.LogicalProjects so that we are grouping on the minimal set of keys. The performance gain isn’t huge, but it is difficult to detect these duplicate expressions later.

Parameters
  • bb: Blackboard

  • checkForDupExprs: Check for duplicate expressions

void org.apache.calcite.sql2rel.SqlToRelConverter.convertWhere(final Blackboard bb, final SqlNode where)

Converts a WHERE clause.

Parameters

void org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries(final Blackboard bb, final SqlNode expr, RelOptUtil.Logic logic)
void org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery(Blackboard bb, SubQuery subQuery)
RexNode org.apache.calcite.sql2rel.SqlToRelConverter.translateIn(RelOptUtil.Logic logic, RelNode root, final RexNode rex)
boolean org.apache.calcite.sql2rel.SqlToRelConverter.convertNonCorrelatedSubQuery(SubQuery subQuery, Blackboard bb, RelNode converted, boolean isExists)

Determines if a sub-query is non-correlated and if so, converts it to a constant.

Return

Whether the sub-query can be converted to a constant

Parameters
  • subQuery: the call that references the sub-query

  • bb: blackboard used to convert the sub-query

  • converted: RelNode tree corresponding to the sub-query

  • isExists: true if the sub-query is part of an EXISTS expression

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertInToOr(final Blackboard bb, final List< RexNode > leftKeys, SqlNodeList valuesList, SqlInOperator op)

Converts “x IN (1, 2, …)” to “x=1 OR x=2 OR …”.

Return

converted expression

Parameters
  • leftKeys: LHS

  • valuesList: RHS

  • op: The operator (IN, NOT IN, > SOME, …)

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.ensureSqlType(RelDataType type, RexNode node)

Ensures that an expression has a given SqlTypeName, applying a cast if necessary. If the expression already has the right type family, returns the expression unchanged.

RelOptUtil.Exists org.apache.calcite.sql2rel.SqlToRelConverter.convertExists(SqlNode seek, RelOptUtil.SubQueryType subQueryType, RelOptUtil.Logic logic, boolean notIn, RelDataType targetDataType)

Converts an EXISTS or IN predicate into a join. For EXISTS, the sub-query produces an indicator variable, and the result is a relational expression which outer joins that indicator to the original query. After performing the outer join, the condition will be TRUE if the EXISTS condition holds, NULL otherwise.

Return

join expression

Parameters
  • seek: A query, for example ‘select * from emp’ or ‘values (1,2,3)’ or ‘(‘Foo’, 34)’.

  • subQueryType: Whether sub-query is IN, EXISTS or scalar

  • logic: Whether the answer needs to be in full 3-valued logic (TRUE, FALSE, UNKNOWN) will be required, or whether we can accept an approximation (say representing UNKNOWN as FALSE)

  • notIn: Whether the operation is NOT IN

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryOrInList(Blackboard bb, SqlNode seek, RelDataType targetRowType)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertRowValues(Blackboard bb, SqlNode rowList, Collection< SqlNode > rows, boolean allowLiteralsOnly, RelDataType targetRowType)
RexLiteral org.apache.calcite.sql2rel.SqlToRelConverter.convertLiteralInValuesList(SqlNode sqlNode, Blackboard bb, RelDataType rowType, int iField)
boolean org.apache.calcite.sql2rel.SqlToRelConverter.isRowConstructor(SqlNode node)
void org.apache.calcite.sql2rel.SqlToRelConverter.findSubQueries(Blackboard bb, SqlNode node, RelOptUtil.Logic logic, boolean registerOnlyScalarSubQueries)

Builds a list of all IN or EXISTS operators inside SQL parse tree. Does not traverse inside queries.

Parameters
  • bb: blackboard

  • node: the SQL parse tree

  • logic: Whether the answer needs to be in full 3-valued logic (TRUE, FALSE, UNKNOWN) will be required, or whether we can accept an approximation (say representing UNKNOWN as FALSE)

  • registerOnlyScalarSubQueries: if set to true and the parse tree corresponds to a variation of a select node, only register it if it’s a scalar sub-query

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertOver(Blackboard bb, SqlNode node)
void org.apache.calcite.sql2rel.SqlToRelConverter.convertUnnest(Blackboard bb, SqlCall call, List< String > fieldNames)
void org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier(Blackboard bb, SqlIdentifier id, SqlNodeList extendedColumns, SqlNodeList tableHints)
void org.apache.calcite.sql2rel.SqlToRelConverter.convertTemporalTable(Blackboard bb, SqlCall call)
Set<RelColumnMapping> org.apache.calcite.sql2rel.SqlToRelConverter.getColumnMappings(SqlOperator op)
CorrelationUse org.apache.calcite.sql2rel.SqlToRelConverter.getCorrelationUse(Blackboard bb, final RelNode r0)
boolean org.apache.calcite.sql2rel.SqlToRelConverter.isSubQueryNonCorrelated(RelNode subq, Blackboard bb)

Determines whether a sub-query is non-correlated. Note that a non-correlated sub-query can contain correlated references, provided those references do not reference select statements that are parents of the sub-query.

Return

true if the sub-query is non-correlated

Parameters
  • subq: the sub-query

  • bb: blackboard used while converting the sub-query, i.e., the blackboard of the parent query of this sub-query

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertJoinCondition(Blackboard bb, SqlValidatorNamespace leftNamespace, SqlValidatorNamespace rightNamespace, SqlNode condition, JoinConditionType conditionType, RelNode leftRel, RelNode rightRel)
RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertUsing(SqlValidatorNamespace leftNamespace, SqlValidatorNamespace rightNamespace, List< String > nameList)

Returns an expression for matching columns of a USING clause or inferred from NATURAL JOIN. “a JOIN b USING (x, y)” becomes “a.x = b.x AND a.y = b.y”. Returns null if the column list is empty.

Return

Expression to match columns from name list, or true if name list is empty

Parameters
  • leftNamespace: Namespace of left input to join

  • rightNamespace: Namespace of right input to join

  • nameList: List of column names to join on

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.rewriteAggregateWithGroupId(Blackboard bb, AggregatingSelectScope.Resolved r, AggConverter converter)

The

GROUP_ID() 
function is used to distinguish duplicate groups. However, as Aggregate normalizes group sets to canonical form (i.e., flatten, sorting, redundancy removal), this information is lost in RelNode. Therefore, it is impossible to implement the function in runtime.

To fill this gap, an aggregation query that contains

GROUP_ID() 
function will generally be rewritten into UNION when converting to RelNode.

Also see the discussion in JIRA [CALCITE-1824] GROUP_ID returns wrong result.

boolean org.apache.calcite.sql2rel.SqlToRelConverter.all(SqlCall call)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.createModify(RelOptTable targetTable, RelNode source)

Creates a relational expression to modify a table or modifiable view.

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.createSource(RelOptTable targetTable, RelNode source, ModifiableView modifiableView, RelDataType delegateRowType)

Wraps a relational expression in the projects and filters implied by a ModifiableView.

The input relational expression is suitable for inserting into the view, and the returned relational expression is suitable for inserting into its delegate table.

In principle, the delegate table of a view might be another modifiable view, and if so, the process can be repeated.

RelOptTable.ToRelContext org.apache.calcite.sql2rel.SqlToRelConverter.createToRelContext(List< RelHint > hints)
Blackboard org.apache.calcite.sql2rel.SqlToRelConverter.createInsertBlackboard(RelOptTable targetTable, RexNode sourceRef, List< String > targetColumnNames)

Creates a blackboard for translating the expressions of generated columns in an INSERT statement.

InitializerExpressionFactory org.apache.calcite.sql2rel.SqlToRelConverter.getInitializerFactory(SqlValidatorTable validatorTable)
RexNode org.apache.calcite.sql2rel.SqlToRelConverter.castNullLiteralIfNeeded(RexNode node, RelDataType type)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertDelete(SqlDelete call)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertUpdate(SqlUpdate call)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertMerge(SqlMerge call)
RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier(Blackboard bb, SqlIdentifier identifier)

Converts an identifier into an expression in a given scope. For example, the “empno” in “select empno from emp join dept” becomes “emp.empno”.

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertRowConstructor(Blackboard bb, SqlCall rowConstructor)

Converts a row constructor into a relational expression.

Return

Relational expression which returns a single row.

Parameters
  • bb: Blackboard

  • rowConstructor: Row constructor expression

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertCursor(Blackboard bb, SubQuery subQuery)
RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertMultisets(final List< SqlNode > operands, Blackboard bb)
void org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectList(Blackboard bb, SqlSelect select, List< SqlNode > orderList)
String org.apache.calcite.sql2rel.SqlToRelConverter.deriveAlias(final SqlNode node, Collection< String > aliases, final int ordinal)
void org.apache.calcite.sql2rel.SqlToRelConverter.convertValuesImpl(Blackboard bb, SqlCall values, RelDataType targetRowType)

Converts a values clause (as in “INSERT INTO T(x,y) VALUES (1,2)”) into a relational expression.

Parameters
  • bb: Blackboard

  • values: Call to SQL VALUES operator

  • targetRowType: Target row type

SqlQuantifyOperator org.apache.calcite.sql2rel.SqlToRelConverter.negate(SqlQuantifyOperator operator)

Private Members

SubQueryConverter org.apache.calcite.sql2rel.SqlToRelConverter.subQueryConverter
final List<SqlDynamicParam> org.apache.calcite.sql2rel.SqlToRelConverter.dynamicParamSqlNodes = new ArrayList<>()
final SqlOperatorTable org.apache.calcite.sql2rel.SqlToRelConverter.opTab
final SqlNodeToRexConverter org.apache.calcite.sql2rel.SqlToRelConverter.exprConverter
final HintStrategyTable org.apache.calcite.sql2rel.SqlToRelConverter.hintStrategies
int org.apache.calcite.sql2rel.SqlToRelConverter.explainParamCount
final RelBuilder org.apache.calcite.sql2rel.SqlToRelConverter.relBuilder
final Map<CorrelationId, DeferredLookup> org.apache.calcite.sql2rel.SqlToRelConverter.mapCorrelToDeferred = new HashMap<>()

Fields used in name resolution for correlated sub-queries.

final Deque<String> org.apache.calcite.sql2rel.SqlToRelConverter.datasetStack = new ArrayDeque<>()

Stack of names of datasets requested by the TABLE(SAMPLE(<datasetName>, <query>)) construct.

final Map<SqlNode, RexNode> org.apache.calcite.sql2rel.SqlToRelConverter.mapConvertedNonCorrSubqs = new HashMap<>()

Mapping of non-correlated sub-queries that have been converted to their equivalent constants. Used to avoid re-evaluating the sub-query if it’s already been evaluated.

Private Static Functions

static boolean org.apache.calcite.sql2rel.SqlToRelConverter.isStream(SqlNode query)
static boolean org.apache.calcite.sql2rel.SqlToRelConverter.containsInOperator(SqlNode node)

Returns whether a given node contains a SqlInOperator.

Parameters
  • node: a RexNode tree

static SqlNode org.apache.calcite.sql2rel.SqlToRelConverter.pushDownNotForIn(SqlValidatorScope scope, SqlNode sqlNode)

Push down all the NOT logical operators into any IN/NOT IN operators.

Return

the transformed SqlNode representation with NOT pushed down.

Parameters
  • scope: Scope where

    sqlNode 
    
    occurs

  • sqlNode: the root node from which to look for NOT operators

static SqlNode org.apache.calcite.sql2rel.SqlToRelConverter.reg(SqlValidatorScope scope, SqlNode e)

Registers with the validator a SqlNode that has been created during the Sql-to-Rel process.

static boolean org.apache.calcite.sql2rel.SqlToRelConverter.containsNullLiteral(SqlNodeList valueList)
static JoinRelType org.apache.calcite.sql2rel.SqlToRelConverter.convertJoinType(JoinType joinType)
static boolean org.apache.calcite.sql2rel.SqlToRelConverter.desc(RelFieldCollation.Direction direction)
static <T> T org.apache.calcite.sql2rel.SqlToRelConverter.unwrap(Object o, Class< T > clazz)
class Blackboard : public SqlRexContext, public org::apache::calcite::sql::util::SqlVisitor<RexNode>, public InitializerContext

Workspace for translating an individual SELECT statement (or sub-SELECT).

Public Functions

SqlNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getTopNode()
void org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.setPatternVarRef(boolean isVarRef)
RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.register(RelNode rel, JoinRelType joinType)
RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.register(RelNode rel, JoinRelType joinType, List< RexNode > leftKeys)

Registers a relational expression.

Return

Expression with which to refer to the row (or partial row) coming from this relational expression’s side of the join

Parameters
  • rel: Relational expression

  • joinType: Join type

  • leftKeys: LHS of IN clause, or null for expressions other than IN

void org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.setRoot(RelNode root, boolean leaf)

Sets a new root relational expression, as the translation process backs its way further up the tree.

Parameters
  • root: New root relational expression

  • leaf: Whether the relational expression is a leaf, that is, derived from an atomic relational expression such as a table name in the from clause, or the projection on top of a select-sub-query. In particular, relational expressions derived from JOIN operators are not leaves, but set expressions are.

void org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.setDataset(String datasetName)

Notifies this Blackboard that the root just set using setRoot(RelNode, boolean) was derived using dataset substitution.

The default implementation is not interested in such notifications, and does nothing.

Parameters
  • datasetName: Dataset name

Public Members

final SqlValidatorScope org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.scope

Collection of RelNode objects which correspond to a SELECT statement.

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.root

Protected Functions

org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.Blackboard(SqlValidatorScope scope, Map< String, RexNode > nameToNodeMap, boolean top)

Creates a Blackboard.

Parameters
  • scope: Name-resolution scope for expressions validated within this query. Can be null if this Blackboard is for a leaf node, say

  • nameToNodeMap: Map which translates the expression to map a given parameter into, if translating expressions; null otherwise

  • top: Whether this is the root of the query

Private Functions

void org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.setRoot(List< RelNode > inputs, RelNode root, boolean hasSystemFields)

Private Members

final Map<String, RexNode> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.nameToNodeMap
List<RelNode> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.inputs
final Map<CorrelationId, RexFieldAccess> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.mapCorrelateToRex = new HashMap<>()
boolean org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.isPatternVarRef = false
final List<SubQuery> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.subQueryList = new ArrayList<>()

List of IN and EXISTS nodes inside this SELECT statement (but not inside sub-queries).

final Map<RelNode, Map<Integer, Integer> > org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.mapRootRelToFieldProjection= new HashMap<>()

Project the groupby expressions out of the root of this sub-select. Sub-queries can reference group by expressions projected from the “right” to the sub-query.

final List<SqlMonotonicity> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.columnMonotonicities = new ArrayList<>()
final List<RelDataTypeField> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.systemFieldList = new ArrayList<>()
final InitializerExpressionFactory org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.initializerExpressionFactory= new NullInitializerExpressionFactory()
class DeferredLookup

Deferred lookup.

Public Functions

RexFieldAccess org.apache.calcite.sql2rel.SqlToRelConverter.DeferredLookup.getFieldAccess(CorrelationId name)
String org.apache.calcite.sql2rel.SqlToRelConverter.DeferredLookup.getOriginalRelName()
class NoOpSubQueryConverter : public SubQueryConverter

A default implementation of SubQueryConverter that does no conversion.

Public Functions

boolean org.apache.calcite.sql2rel.SqlToRelConverter.NoOpSubQueryConverter.canConvertSubQuery()
RexNode org.apache.calcite.sql2rel.SqlToRelConverter.NoOpSubQueryConverter.convertSubQuery(SqlCall subQuery, SqlToRelConverter parentConverter, boolean isExists, boolean isExplain)
class RexAccessShuttle : public RexShuttle

Shuttle that replace outer RexInputRef with RexFieldAccess, and adjust

offset 
to each inner RexInputRef in the lateral join condition.

Public Functions

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.RexAccessShuttle.visitInputRef(RexInputRef input)

Private Members

final RexBuilder org.apache.calcite.sql2rel.SqlToRelConverter.RexAccessShuttle.builder
final RexCorrelVariable org.apache.calcite.sql2rel.SqlToRelConverter.RexAccessShuttle.rexCorrel
final BitSet org.apache.calcite.sql2rel.SqlToRelConverter.RexAccessShuttle.varCols = new BitSet()