Inheritance diagram for org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard:

Collaboration diagram for org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard:

Public Member Functions
SqlNode	getTopNode ()

void	setPatternVarRef (boolean isVarRef)

RexNode	register (RelNode rel, JoinRelType joinType)

RexNode	register (RelNode rel, JoinRelType joinType, List< RexNode > leftKeys)

void	setRoot (RelNode root, boolean leaf)

void	setDataset (String datasetName)

void	flatten (List< RelNode > rels, int systemFieldCount, int[] start, List< Pair< RelNode, Integer >> relOffsetList)

RexNode	convertExpression (SqlNode expr)

RexFieldCollation	convertSortExpression (SqlNode expr, RelFieldCollation.Direction direction, RelFieldCollation.NullDirection nullDirection)

int	getGroupCount ()

RexBuilder	getRexBuilder ()

RexRangeRef	getSubQueryExpr (SqlCall call)

RelDataTypeFactory	getTypeFactory ()

InitializerExpressionFactory	getInitializerExpressionFactory ()

SqlValidator	getValidator ()

RexNode	convertLiteral (SqlLiteral literal)

RexNode	convertInterval (SqlIntervalQualifier intervalQualifier)

RexNode	visit (SqlLiteral literal)

RexNode	visit (SqlCall call)

RexNode	visit (SqlNodeList nodeList)

RexNode	visit (SqlIdentifier id)

RexNode	visit (SqlDataTypeSpec type)

RexNode	visit (SqlDynamicParam param)

RexNode	visit (SqlIntervalQualifier intervalQualifier)

List< SqlMonotonicity >	getColumnMonotonicities ()

Public Attributes
final SqlValidatorScope	scope

RelNode	root

Protected Member Functions
	Blackboard (SqlValidatorScope scope, Map< String, RexNode > nameToNodeMap, boolean top)

Package Functions
void	setRoot (List< RelNode > inputs)

Pair< RexNode, Map< String, Integer > >	lookupExp (SqlQualified qualified)

RexNode	lookup (int offset, LookupContext lookupContext)

RelDataTypeField	getRootField (RexInputRef inputRef)

void	registerSubQuery (SqlNode node, RelOptUtil.Logic logic)

SubQuery	getSubQuery (SqlNode expr)

ImmutableList< RelNode >	retrieveCursors ()

Package Attributes
final List< RelNode >	cursors = new ArrayList<>()

AggConverter	agg

SqlWindow	window

final boolean	top

Private Member Functions
void	setRoot (List< RelNode > inputs, RelNode root, boolean hasSystemFields)

boolean	isConvertedSubq (RexNode rex)

Private Attributes
final Map< String, RexNode >	nameToNodeMap

List< RelNode >	inputs

final Map< CorrelationId, RexFieldAccess >	mapCorrelateToRex = new HashMap<>()

boolean	isPatternVarRef = false

final Set< SubQuery >	subQueryList = new LinkedHashSet<>()

final Map< RelNode, Map < Integer, Integer > >	mapRootRelToFieldProjection

final List< SqlMonotonicity >	columnMonotonicities = new ArrayList<>()

final List< RelDataTypeField >	systemFieldList = new ArrayList<>()

final InitializerExpressionFactory	initializerExpressionFactory

Detailed Description

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

Definition at line 3880 of file SqlToRelConverter.java.

Constructor & Destructor Documentation

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

inlineprotected

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

Definition at line 3939 of file SqlToRelConverter.java.

                                                                                       {
       this.scope = scope;
       this.nameToNodeMap = nameToNodeMap;
       this.top = top;
     }

Member Function Documentation

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.convertExpression ( SqlNode expr )

inline

Definition at line 4249 of file SqlToRelConverter.java.

References assert().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertInToOr().

                                                    {
       // If we're in aggregation mode and this is an expression in the
       // GROUP BY clause, return a reference to the field.
       if (agg != null) {
         final SqlNode expandedGroupExpr = validator.expand(expr, scope);
         final int ref = agg.lookupGroupExpr(expandedGroupExpr);
         if (ref >= 0) {
           return rexBuilder.makeInputRef(root, ref);
         }
         if (expr instanceof SqlCall) {
           final RexNode rex = agg.lookupAggregates((SqlCall) expr);
           if (rex != null) {
             return rex;
           }
         }
       }
 
       // Allow the derived class chance to override the standard
       // behavior for special kinds of expressions.
       RexNode rex = convertExtendedExpression(expr, this);
       if (rex != null) {
         return rex;
       }
 
       // Sub-queries and OVER expressions are not like ordinary
       // expressions.
       final SqlKind kind = expr.getKind();
       final SubQuery subQuery;
 
       boolean isExpand = config.getExpandPredicate().test(getTopNode(), expr);
       if (!isExpand) {
         final SqlCall call;
         final SqlNode query;
         final RelRoot root;
         switch (kind) {
           case IN:
           case NOT_IN:
           case SOME:
           case ALL:
             call = (SqlCall) expr;
             query = call.operand(1);
             if (!(query instanceof SqlNodeList)) {
               root = convertQueryRecursive(query, false, null);
               final SqlNode operand = call.operand(0);
               List<SqlNode> nodes;
               switch (operand.getKind()) {
                 case ROW:
                   nodes = ((SqlCall) operand).getOperandList();
                   break;
                 default:
                   nodes = ImmutableList.of(operand);
               }
               final ImmutableList.Builder<RexNode> builder = ImmutableList.builder();
               for (SqlNode node : nodes) {
                 builder.add(convertExpression(node));
               }
               final ImmutableList<RexNode> list = builder.build();
               switch (kind) {
                 case IN:
                   return RexSubQuery.in(root.rel, list);
                 case NOT_IN:
                   return rexBuilder.makeCall(
                           SqlStdOperatorTable.NOT, RexSubQuery.in(root.rel, list));
                 case SOME:
                   return RexSubQuery.some(
                           root.rel, list, (SqlQuantifyOperator) call.getOperator());
                 case ALL:
                   return rexBuilder.makeCall(SqlStdOperatorTable.NOT,
                           RexSubQuery.some(root.rel,
                                   list,
                                   negate((SqlQuantifyOperator) call.getOperator())));
                 default:
                   throw new AssertionError(kind);
               }
             }
             break;
 
           case EXISTS:
             call = (SqlCall) expr;
             query = Iterables.getOnlyElement(call.getOperandList());
             root = convertQueryRecursive(query, false, null);
             RelNode rel = root.rel;
             while (rel instanceof Project
                     || rel instanceof Sort && ((Sort) rel).fetch == null
                             && ((Sort) rel).offset == null) {
               rel = ((SingleRel) rel).getInput();
             }
             return RexSubQuery.exists(rel);
 
           case SCALAR_QUERY:
             call = (SqlCall) expr;
             query = Iterables.getOnlyElement(call.getOperandList());
             root = convertQueryRecursive(query, false, null);
             return RexSubQuery.scalar(root.rel);
         }
       }
 
       switch (kind) {
         case SOME:
         case ALL:
           if (isExpand) {
             throw new RuntimeException(kind + " is only supported if expand = false");
           }
           // fall through
         case CURSOR:
         case IN:
         case NOT_IN:
           subQuery = Objects.requireNonNull(getSubQuery(expr));
           rex = Objects.requireNonNull(subQuery.expr);
           return StandardConvertletTable.castToValidatedType(
                   expr, rex, validator, rexBuilder);
 
         case SELECT:
         case EXISTS:
         case SCALAR_QUERY:
           subQuery = getSubQuery(expr);
           assert subQuery != null;
           rex = subQuery.expr;
           assert rex != null : "rex != null";
 
           if (((kind == SqlKind.SCALAR_QUERY) || (kind == SqlKind.EXISTS))
                   && isConvertedSubq(rex)) {
             // scalar sub-query or EXISTS has been converted to a
             // constant
             return rex;
           }
 
           // The indicator column is the last field of the sub-query.
           RexNode fieldAccess =
                   rexBuilder.makeFieldAccess(rex, rex.getType().getFieldCount() - 1);
 
           // The indicator column will be nullable if it comes from
           // the null-generating side of the join. For EXISTS, add an
           // "IS TRUE" check so that the result is "BOOLEAN NOT NULL".
           if (fieldAccess.getType().isNullable() && kind == SqlKind.EXISTS) {
             fieldAccess =
                     rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, fieldAccess);
           }
           return fieldAccess;
 
         case OVER:
           return convertOver(this, expr);
 
         default:
           // fall through
       }
 
       // Apply standard conversions.
       rex = expr.accept(this);
       return Objects.requireNonNull(rex);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.convertInterval ( SqlIntervalQualifier intervalQualifier )

inline

Definition at line 4512 of file SqlToRelConverter.java.

                                                                            {
       return exprConverter.convertInterval(this, intervalQualifier);
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.convertLiteral ( SqlLiteral literal )

inline

Definition at line 4508 of file SqlToRelConverter.java.

                                                       {
       return exprConverter.convertLiteral(this, literal);
     }

RexFieldCollation org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.convertSortExpression	(	SqlNode	expr,
		RelFieldCollation.Direction	direction,
		RelFieldCollation.NullDirection	nullDirection
	)

inline

Converts an item in an ORDER BY clause inside a window (OVER) clause, extracting DESC, NULLS LAST and NULLS FIRST flags first.

Definition at line 4405 of file SqlToRelConverter.java.

References FIRST, and LAST.

                                                            {
       switch (expr.getKind()) {
         case DESCENDING:
           return convertSortExpression(((SqlCall) expr).operand(0),
                   RelFieldCollation.Direction.DESCENDING,
                   nullDirection);
         case NULLS_LAST:
           return convertSortExpression(((SqlCall) expr).operand(0),
                   direction,
                   RelFieldCollation.NullDirection.LAST);
         case NULLS_FIRST:
           return convertSortExpression(((SqlCall) expr).operand(0),
                   direction,
                   RelFieldCollation.NullDirection.FIRST);
         default:
           final Set<SqlKind> flags = EnumSet.noneOf(SqlKind.class);
           switch (direction) {
             case DESCENDING:
               flags.add(SqlKind.DESCENDING);
           }
           switch (nullDirection) {
             case UNSPECIFIED:
               final RelFieldCollation.NullDirection nullDefaultDirection =
                       validator.getDefaultNullCollation().last(desc(direction))
                       ? RelFieldCollation.NullDirection.LAST
                       : RelFieldCollation.NullDirection.FIRST;
               if (nullDefaultDirection != direction.defaultNullDirection()) {
                 SqlKind nullDirectionSqlKind =
                         validator.getDefaultNullCollation().last(desc(direction))
                         ? SqlKind.NULLS_LAST
                         : SqlKind.NULLS_FIRST;
                 flags.add(nullDirectionSqlKind);
               }
               break;
             case FIRST:
               flags.add(SqlKind.NULLS_FIRST);
               break;
             case LAST:
               flags.add(SqlKind.NULLS_LAST);
               break;
           }
           return new RexFieldCollation(convertExpression(expr), flags);
       }
     }

void org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.flatten	(	List< RelNode >	rels,
		int	systemFieldCount,
		int[]	start,
		List< Pair< RelNode, Integer >>	relOffsetList
	)

inline

Definition at line 4205 of file SqlToRelConverter.java.

                                                         {
       for (RelNode rel : rels) {
         if (leaves.contains(rel) || rel instanceof LogicalMatch) {
           relOffsetList.add(Pair.of(rel, start[0]));
           start[0] += rel.getRowType().getFieldCount();
         } else {
           if (rel instanceof LogicalJoin || rel instanceof LogicalAggregate) {
             start[0] += systemFieldCount;
           }
           flatten(rel.getInputs(), systemFieldCount, start, relOffsetList);
         }
       }
     }

List<SqlMonotonicity> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getColumnMonotonicities ( )

inline

Definition at line 4553 of file SqlToRelConverter.java.

                                                            {
       return columnMonotonicities;
     }

int org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getGroupCount ( )

inline

Definition at line 4476 of file SqlToRelConverter.java.

                                {
       if (agg != null) {
         return agg.groupExprs.size();
       }
       if (window != null) {
         return window.isAlwaysNonEmpty() ? 1 : 0;
       }
       return -1;
     }

InitializerExpressionFactory org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getInitializerExpressionFactory ( )

inline

Definition at line 4500 of file SqlToRelConverter.java.

                                                                           {
       return initializerExpressionFactory;
     }

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

inline

Definition at line 4486 of file SqlToRelConverter.java.

                                       {
       return rexBuilder;
     }

RelDataTypeField org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getRootField ( RexInputRef inputRef )

inlinepackage

Definition at line 4185 of file SqlToRelConverter.java.

                                                         {
       if (inputs == null) {
         return null;
       }
       int fieldOffset = inputRef.getIndex();
       for (RelNode input : inputs) {
         RelDataType rowType = input.getRowType();
         if (rowType == null) {
           // TODO: remove this once leastRestrictive
           // is correctly implemented
           return null;
         }
         if (fieldOffset < rowType.getFieldCount()) {
           return rowType.getFieldList().get(fieldOffset);
         }
         fieldOffset -= rowType.getFieldCount();
       }
       throw new AssertionError();
     }

SubQuery org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getSubQuery ( SqlNode expr )

inlinepackage

Definition at line 4231 of file SqlToRelConverter.java.

                                        {
       for (SubQuery subQuery : subQueryList) {
         if (expr.equalsDeep(subQuery.node, Litmus.IGNORE)) {
           return subQuery;
         }
       }
 
       return null;
     }

RexRangeRef org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getSubQueryExpr ( SqlCall call )

inline

Definition at line 4490 of file SqlToRelConverter.java.

References assert().

                                                      {
       final SubQuery subQuery = getSubQuery(call);
       assert subQuery != null;
       return (RexRangeRef) subQuery.expr;
     }

Here is the call graph for this function:

SqlNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getTopNode ( )

inline

Definition at line 3946 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.createJoin(), and org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                 {
       try {
         if (null == scope) {
           return null;
         }
         return scope.getNode();
       } catch (Exception e) {
         return null;
       }
     }

Here is the caller graph for this function:

RelDataTypeFactory org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getTypeFactory ( )

inline

Definition at line 4496 of file SqlToRelConverter.java.

                                                {
       return typeFactory;
     }

SqlValidator org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.getValidator ( )

inline

Definition at line 4504 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.AggConverter.AggConverter().

                                        {
       return validator;
     }

Here is the caller graph for this function:

boolean org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.isConvertedSubq ( RexNode rex )

inlineprivate

Determines whether a RexNode corresponds to a sub-query that's been converted to a constant.

Parameters

rex	the expression to be examined

Returns: true if the expression is a dynamic parameter, a literal, or a literal that is being cast

Definition at line 4460 of file SqlToRelConverter.java.

                                                  {
       if ((rex instanceof RexLiteral) || (rex instanceof RexDynamicParam)) {
         return true;
       }
       if (rex instanceof RexCall) {
         RexCall call = (RexCall) rex;
         if (call.getOperator() == SqlStdOperatorTable.CAST) {
           RexNode operand = call.getOperands().get(0);
           if (operand instanceof RexLiteral) {
             return true;
           }
         }
       }
       return false;
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.lookup	(	int	offset,
		LookupContext	lookupContext
	)

inlinepackage

Creates an expression with which to reference the expression whose offset in its from-list is

offset

.

Definition at line 4180 of file SqlToRelConverter.java.

                                                             {
       Pair<RelNode, Integer> pair = lookupContext.findRel(offset);
       return rexBuilder.makeRangeReference(pair.left.getRowType(), pair.right, false);
     }

Pair<RexNode, Map<String, Integer> > org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.lookupExp ( SqlQualified qualified )

inlinepackage

Returns an expression with which to reference a from-list item.

Parameters

qualified the alias of the from item

Returns: a RexFieldAccess or RexRangeRef, or null if not found

Definition at line 4102 of file SqlToRelConverter.java.

References field(), Integer, and Experimental.String.

                                                                           {
       if (nameToNodeMap != null && qualified.prefixLength == 1) {
         RexNode node = nameToNodeMap.get(qualified.identifier.names.get(0));
         if (node == null) {
           throw new AssertionError("Unknown identifier '" + qualified.identifier
                   + "' encountered while expanding expression");
         }
         return Pair.of(node, null);
       }
       final SqlNameMatcher nameMatcher =
               scope.getValidator().getCatalogReader().nameMatcher();
       final SqlValidatorScope.ResolvedImpl resolved =
               new SqlValidatorScope.ResolvedImpl();
       scope.resolve(qualified.prefix(), nameMatcher, false, resolved);
       if (!(resolved.count() == 1)) {
         return null;
       }
       final SqlValidatorScope.Resolve resolve = resolved.only();
       final RelDataType rowType = resolve.rowType();
 
       // Found in current query's from list. Find which from item.
       // We assume that the order of the from clause items has been
       // preserved.
       final SqlValidatorScope ancestorScope = resolve.scope;
       boolean isParent = ancestorScope != scope;
       if ((inputs != null) && !isParent) {
         final LookupContext rels =
                 new LookupContext(this, inputs, systemFieldList.size());
         final RexNode node = lookup(resolve.path.steps().get(0).i, rels);
         if (node == null) {
           return null;
         } else {
           final Map<String, Integer> fieldOffsets = new HashMap<>();
           for (RelDataTypeField f : resolve.rowType().getFieldList()) {
             if (!fieldOffsets.containsKey(f.getName())) {
               fieldOffsets.put(f.getName(), f.getIndex());
             }
           }
           final Map<String, Integer> map = ImmutableMap.copyOf(fieldOffsets);
           return Pair.of(node, map);
         }
       } else {
         // We're referencing a relational expression which has not been
         // converted yet. This occurs when from items are correlated,
         // e.g. "select from emp as emp join emp.getDepts() as dept".
         // Create a temporary expression.
         DeferredLookup lookup =
                 new DeferredLookup(this, qualified.identifier.names.get(0));
         final CorrelationId correlId = cluster.createCorrel();
         mapCorrelToDeferred.put(correlId, lookup);
         if (resolve.path.steps().get(0).i < 0) {
           return Pair.of(rexBuilder.makeCorrel(rowType, correlId), null);
         } else {
           final RelDataTypeFactory.Builder builder = typeFactory.builder();
           final ListScope ancestorScope1 = (ListScope) resolve.scope;
           final ImmutableMap.Builder<String, Integer> fields = ImmutableMap.builder();
           int i = 0;
           int offset = 0;
           for (SqlValidatorNamespace c : ancestorScope1.getChildren()) {
             builder.addAll(c.getRowType().getFieldList());
             if (i == resolve.path.steps().get(0).i) {
               for (RelDataTypeField field : c.getRowType().getFieldList()) {
                 fields.put(field.getName(), field.getIndex() + offset);
               }
             }
             ++i;
             offset += c.getRowType().getFieldCount();
           }
           final RexNode c = rexBuilder.makeCorrel(builder.uniquify().build(), correlId);
           return Pair.of(c, fields.build());
         }
       }
     }

Here is the call graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.register	(	RelNode	rel,
		JoinRelType	joinType
	)

inline

Definition at line 3961 of file SqlToRelConverter.java.

                                                                {
       return register(rel, joinType, null);
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.register	(	RelNode	rel,
		JoinRelType	joinType,
		List< RexNode >	leftKeys
	)

inline

Registers a relational expression.

Parameters

rel	Relational expression
joinType	Join type
leftKeys	LHS of IN clause, or null for expressions other than IN

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

Definition at line 3974 of file SqlToRelConverter.java.

References assert(), join(), and Experimental.String.

                                                                                        {
       assert joinType != null;
       if (root == null) {
         assert leftKeys == null;
         setRoot(rel, false);
         return rexBuilder.makeRangeReference(root.getRowType(), 0, false);
       }
 
       final RexNode joinCond;
       final int origLeftInputCount = root.getRowType().getFieldCount();
       if (leftKeys != null) {
         List<RexNode> newLeftInputExprs = new ArrayList<>();
         for (int i = 0; i < origLeftInputCount; i++) {
           newLeftInputExprs.add(rexBuilder.makeInputRef(root, i));
         }
 
         final List<Integer> leftJoinKeys = new ArrayList<>();
         for (RexNode leftKey : leftKeys) {
           int index = newLeftInputExprs.indexOf(leftKey);
           if (index < 0 || joinType == JoinRelType.LEFT) {
             index = newLeftInputExprs.size();
             newLeftInputExprs.add(leftKey);
           }
           leftJoinKeys.add(index);
         }
 
         RelNode newLeftInput = relBuilder.push(root).project(newLeftInputExprs).build();
 
         // maintain the group by mapping in the new LogicalProject
         if (mapRootRelToFieldProjection.containsKey(root)) {
           mapRootRelToFieldProjection.put(
                   newLeftInput, mapRootRelToFieldProjection.get(root));
         }
 
         setRoot(newLeftInput, false);
 
         // right fields appear after the LHS fields.
         final int rightOffset = root.getRowType().getFieldCount()
                 - newLeftInput.getRowType().getFieldCount();
         final List<Integer> rightKeys =
                 Util.range(rightOffset, rightOffset + leftKeys.size());
 
         joinCond = RelOptUtil.createEquiJoinCondition(
                 newLeftInput, leftJoinKeys, rel, rightKeys, rexBuilder);
       } else {
         joinCond = rexBuilder.makeLiteral(true);
       }
 
       int leftFieldCount = root.getRowType().getFieldCount();
       final RelNode join = createJoin(this, root, rel, joinCond, joinType);
 
       setRoot(join, false);
 
       if (leftKeys != null && joinType == JoinRelType.LEFT) {
         final int leftKeyCount = leftKeys.size();
         int rightFieldLength = rel.getRowType().getFieldCount();
         assert leftKeyCount == rightFieldLength - 1;
 
         final int rexRangeRefLength = leftKeyCount + rightFieldLength;
         RelDataType returnType = typeFactory.createStructType(
                 new AbstractList<Map.Entry<String, RelDataType>>() {
                   public Map.Entry<String, RelDataType> get(int index) {
                     return join.getRowType().getFieldList().get(
                             origLeftInputCount + index);
                   }
 
                   public int size() {
                     return rexRangeRefLength;
                   }
                 });
 
         return rexBuilder.makeRangeReference(returnType, origLeftInputCount, false);
       } else {
         return rexBuilder.makeRangeReference(
                 rel.getRowType(), leftFieldCount, joinType.generatesNullsOnRight());
       }
     }

Here is the call graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.registerSubQuery	(	SqlNode	node,
		RelOptUtil.Logic	logic
	)

inlinepackage

Definition at line 4222 of file SqlToRelConverter.java.

                                                                 {
       for (SubQuery subQuery : subQueryList) {
         if (node.equalsDeep(subQuery.node, Litmus.IGNORE)) {
           return;
         }
       }
       subQueryList.add(new SubQuery(node, logic));
     }

ImmutableList<RelNode> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.retrieveCursors ( )

inlinepackage

Definition at line 4241 of file SqlToRelConverter.java.

                                              {
       try {
         return ImmutableList.copyOf(cursors);
       } finally {
         cursors.clear();
       }
     }

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

inline

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

Definition at line 4090 of file SqlToRelConverter.java.

4090 {}

void org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.setPatternVarRef ( boolean isVarRef )

inline

Definition at line 3957 of file SqlToRelConverter.java.

                                                    {
       this.isPatternVarRef = isVarRef;
     }

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

inline

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.

Definition at line 4063 of file SqlToRelConverter.java.

                                                     {
       setRoot(Collections.singletonList(root), root, root instanceof LogicalJoin);
       if (leaf) {
         leaves.add(root);
       }
       this.columnMonotonicities.clear();
     }

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

inlineprivate

Definition at line 4071 of file SqlToRelConverter.java.

                                                                                       {
       this.inputs = inputs;
       this.root = root;
       this.systemFieldList.clear();
       if (hasSystemFields) {
         this.systemFieldList.addAll(getSystemFields());
       }
     }

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

inlinepackage

Definition at line 4092 of file SqlToRelConverter.java.

                                        {
       setRoot(inputs, null, false);
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.visit ( SqlLiteral literal )

inline

Definition at line 4516 of file SqlToRelConverter.java.

                                              {
       return exprConverter.convertLiteral(this, literal);
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.visit ( SqlCall call )

inline

Definition at line 4520 of file SqlToRelConverter.java.

                                        {
       if (agg != null) {
         final SqlOperator op = call.getOperator();
         if (window == null
                 && (op.isAggregator() || op.getKind() == SqlKind.FILTER
                         || op.getKind() == SqlKind.WITHIN_GROUP)) {
           return agg.lookupAggregates(call);
         }
       }
       return exprConverter.convertCall(
               this, new SqlCallBinding(validator, scope, call).permutedCall());
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.visit ( SqlNodeList nodeList )

inline

Definition at line 4533 of file SqlToRelConverter.java.

                                                {
       throw new UnsupportedOperationException();
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.visit ( SqlIdentifier id )

inline

Definition at line 4537 of file SqlToRelConverter.java.

                                            {
       return convertIdentifier(this, id);
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.visit ( SqlDataTypeSpec type )

inline

Definition at line 4541 of file SqlToRelConverter.java.

                                                {
       throw new UnsupportedOperationException();
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.visit ( SqlDynamicParam param )

inline

Definition at line 4545 of file SqlToRelConverter.java.

                                                 {
       return convertDynamicParam(param);
     }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.visit ( SqlIntervalQualifier intervalQualifier )

inline

Definition at line 4549 of file SqlToRelConverter.java.

                                                                  {
       return convertInterval(intervalQualifier);
     }

Member Data Documentation

AggConverter org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.agg

package

Workspace for building aggregates.

Definition at line 3904 of file SqlToRelConverter.java.

final List<SqlMonotonicity> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.columnMonotonicities = new ArrayList<>()

private

Definition at line 3920 of file SqlToRelConverter.java.

final List<RelNode> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.cursors = new ArrayList<>()

package

Definition at line 3893 of file SqlToRelConverter.java.

final InitializerExpressionFactory org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.initializerExpressionFactory

private

Initial value:

=

new NullInitializerExpressionFactory()

Definition at line 3925 of file SqlToRelConverter.java.

List<RelNode> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.inputs

private

Definition at line 3888 of file SqlToRelConverter.java.

boolean org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.isPatternVarRef = false

private

Definition at line 3891 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier().

final Map<CorrelationId, RexFieldAccess> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.mapCorrelateToRex = new HashMap<>()

private

Definition at line 3889 of file SqlToRelConverter.java.

final Map<RelNode, Map<Integer, Integer> > org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.mapRootRelToFieldProjection

private

Initial value:

=

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.

Definition at line 3917 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.getCorrelationUse().

final Map<String, RexNode> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.nameToNodeMap

private

Definition at line 3886 of file SqlToRelConverter.java.

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

Definition at line 3887 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(), org.apache.calcite.sql2rel.SqlToRelConverter.getCorrelationUse(), org.apache.calcite.sql2rel.SqlToRelConverter.snapshotTemporalTable(), and org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

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

Collection of RelNode objects which correspond to a SELECT statement.

Definition at line 3885 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertCollectionTable(), org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier(), org.apache.calcite.sql2rel.SqlToRelConverter.convertMultisets(), org.apache.calcite.sql2rel.SqlToRelConverter.convertValuesImpl(), org.apache.calcite.sql2rel.SqlToRelConverter.convertWhere(), and org.apache.calcite.sql2rel.SqlToRelConverter.createAggImpl().

final Set<SubQuery> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.subQueryList = new LinkedHashSet<>()

private

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

Definition at line 3899 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries().

final List<RelDataTypeField> org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.systemFieldList = new ArrayList<>()

private

Definition at line 3922 of file SqlToRelConverter.java.

final boolean org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.top

package

Definition at line 3923 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertOrder(), and org.apache.calcite.sql2rel.SqlToRelConverter.gatherOrderExprs().

SqlWindow org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.window

package

When converting window aggregate, we need to know if the window is guaranteed to be non-empty.

Definition at line 3910 of file SqlToRelConverter.java.

The documentation for this class was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/java/calcite/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java

Public Member Functions

Public Attributes

Protected Member Functions

Package Functions

Package Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation