Package org.apache.calcite.sql2rel

Class SqlToRelConverter

java.lang.Object
org.apache.calcite.sql2rel.SqlToRelConverter
@Enclosing 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).

  • Field Details

  • Constructor Details

  • Method Details

    • 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 the mapping of non-correlated sub-queries 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 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

    • 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

    • setDynamicParamCountInExplain

      public void setDynamicParamCountInExplain(int explainParamCount)
      Sets the number of dynamic parameters in the current EXPLAIN PLAN statement.
      Parameters:
      explainParamCount - number of dynamic parameters in the statement

    • flattenTypes

      public RelNode flattenTypes(RelNode rootRel, boolean restructure)

    • decorrelate

      public RelNode decorrelate(SqlNode query, RelNode rootRel)
      If sub-query 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(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.

      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
      Returns:
      Trimmed relational expression

    • newFieldTrimmer

      protected RelFieldTrimmer newFieldTrimmer()
      Creates a RelFieldTrimmer.
      Returns:
      Field trimmer

    • convertQuery

      public RelRoot 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.

    • isOrdered

      public static boolean isOrdered(SqlNode query)

    • convertSelect

      public RelNode convertSelect(SqlSelect select, boolean top)
      Converts a SELECT statement's parse tree into a relational expression.

    • createBlackboard

      protected SqlToRelConverter.Blackboard createBlackboard(SqlValidatorScope scope, @Nullable Map<String,RexNode> nameToNodeMap, boolean top)
      Factory method for creating translation workspace.

    • convertSelectImpl

      protected void convertSelectImpl(SqlToRelConverter.Blackboard bb, SqlSelect select)
      Implementation of convertSelect(SqlSelect, boolean); derived class may override.

    • convertOrder

      protected void convertOrder(SqlSelect select, SqlToRelConverter.Blackboard bb, RelCollation collation, List<SqlNode> orderExprList, @Nullable SqlNode offset, @Nullable 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

    • 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

      @Deprecated protected int getInSubqueryThreshold()
      Deprecated.
      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, org.apache.calcite.sql.fun.SqlInOperator) 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 DEFAULT_IN_SUB_QUERY_THRESHOLD

    • 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 @Nullable 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, @Nullable SqlNode from)

    • convertFrom

      protected void convertFrom(SqlToRelConverter.Blackboard bb, @Nullable SqlNode from, @Nullable 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:
      • 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.
      fieldNames - Field aliases, usually come from AS clause, or null

    • convertMatchRecognize

      protected void convertMatchRecognize(SqlToRelConverter.Blackboard bb, SqlMatchRecognize matchRecognize)

    • convertPivot

      protected void convertPivot(SqlToRelConverter.Blackboard bb, SqlPivot pivot)

    • convertUnpivot

      protected void convertUnpivot(SqlToRelConverter.Blackboard bb, SqlUnpivot unpivot)

    • 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 AggConverter, then delegates to createAggImpl(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard, org.apache.calcite.sql2rel.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 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, org.apache.calcite.sql2rel.AggConverter aggConverter, SqlNodeList selectList, @Nullable SqlNodeList groupList, @Nullable SqlNode having, List<SqlNode> orderExprList)

    • createAggregate

      protected RelNode createAggregate(SqlToRelConverter.Blackboard bb, 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
      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, @Nullable 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

      @Deprecated protected boolean enableDecorrelation()
      Deprecated.

    • decorrelateQuery

      protected RelNode decorrelateQuery(RelNode rootRel)

    • isTrimUnusedFields

      @Deprecated public boolean isTrimUnusedFields()
      Deprecated.
      Returns whether to trim unused fields as part of the conversion process.
      Returns:
      Whether to trim unused fields

    • convertQueryRecursive

      protected RelRoot convertQueryRecursive(SqlNode query, boolean top, @Nullable 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, List<RelHint> hints)

    • getTargetTable

      protected RelOptTable getTargetTable(SqlNode call)

    • convertColumnList

      protected RelNode convertColumnList(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.

      Parameters:
      call - Insert expression
      source - 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

    • 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 RelRoot convertWith(SqlWith with, boolean top)
      Converts a WITH sub-query into a relational expression.

    • convertValues

      public RelNode convertValues(SqlCall values, @Nullable RelDataType targetRowType)
      Converts a SELECT statement's parse tree into a relational expression.

    • config

      public static SqlToRelConverter.Config config()
      Returns a default SqlToRelConverter.Config.