/** * Converts an expression from {@link SqlNode} to {@link RexNode} format, * mapping identifier references to predefined expressions. * * @param node Expression to translate * @param nameToNodeMap map from String to {@link RexNode}; when an * {@link SqlIdentifier} is encountered, it is used as a * key and translated to the corresponding value from * this map * @return Converted expression */ public RexNode convertExpression( SqlNode node, Map<String, RexNode> nameToNodeMap) { final Map<String, RelDataType> nameToTypeMap = new HashMap<String, RelDataType>(); for (Map.Entry<String, RexNode> entry : nameToNodeMap.entrySet()) { nameToTypeMap.put(entry.getKey(), entry.getValue().getType()); } Blackboard bb = createBlackboard( new ParameterScope((SqlValidatorImpl) validator, nameToTypeMap), nameToNodeMap); return bb.convertExpression(node); }
public void addGroupExpr(SqlNode expr) { RexNode convExpr = bb.convertExpression(expr); final RexNode rex = lookupGroupExpr(expr); if (rex != null) { return; // don't add duplicates, in e.g. "GROUP BY x, y, x" } groupExprs.add(expr); String name = nameMap.get(expr.toString()); addExpr(convExpr, name); final RelDataType type = convExpr.getType(); inputRefs.add(rexBuilder.makeInputRef(type, inputRefs.size())); }
for (SqlNode expr : selectList) { ++i; exprs.add(bb.convertExpression(expr)); fieldNames.add(deriveAlias(expr, aliases, i)); ++i; SqlNode expr2 = validator.expandOrderExpr(select, expr); exprs.add(bb.convertExpression(expr2)); fieldNames.add(deriveAlias(expr, aliases, i));
public void addGroupExpr(SqlNode expr) { RexNode convExpr = bb.convertExpression(expr); final RexNode rex = lookupGroupExpr(expr); if (rex != null) { return; // don't add duplicates, in e.g. "GROUP BY x, y, x" } groupExprs.add(expr); String name = nameMap.get(expr.toString()); addExpr(convExpr, name); final RelDataType type = convExpr.getType(); inputRefs.add(rexBuilder.makeInputRef(type, inputRefs.size())); }
public RexNode apply(Integer i) { return rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, leftKeys[i], bb.convertExpression( call.getOperands()[i])); } }),
SqlNode newHaving = pushDownNotForIn(having); replaceSubqueries(bb, newHaving, RelOptUtil.Logic.UNKNOWN_AS_FALSE); havingExpr = bb.convertExpression(newHaving); if (havingExpr.isAlwaysTrue()) { havingExpr = null; int sysFieldCount = selectList.size() - names.size(); for (SqlNode expr : selectList) { selectExprs.add(bb.convertExpression(expr)); selectNames.add( k < sysFieldCount selectExprs.add(bb.convertExpression(expr)); selectNames.add(validator.deriveAlias(expr, k++));
RelOptUtil.createProject( (null != bb.root) ? bb.root : new OneRowRel(cluster), Collections.singletonList(bb.convertExpression(node)), Collections.singletonList(validator.deriveAlias(node, 0)), true);
leftKeys = Lists.newArrayList(); for (SqlNode sqlExpr : ((SqlBasicCall) leftKeyNode).getOperandList()) { leftKeys.add(bb.convertExpression(sqlExpr)); leftKeys = ImmutableList.of(bb.convertExpression(leftKeyNode));
for (int j = 0; j < projectList.size(); j++) { SqlNode operand = projectList.get(j); selectList.add(bb.convertExpression(operand));
exps.add( Pair.of( tmpBb.convertExpression(operand.e), validator.deriveAlias(operand.e, operand.i)));
convertedExpr = bb.convertExpression(operand); assert convertedExpr != null; if (argTypes != null) {
RexNode rexCall = bb.convertExpression(call); final List<RelNode> inputs = bb.retrieveCursors(); Set<RelColumnMapping> columnMappings =
return bb.convertExpression(call);
ImmutableList.builder(); for (SqlNode partition : partitionList) { partitionKeys.add(bb.convertExpression(partition)); RexNode lowerBound = bb.convertExpression(window.getLowerBound()); RexNode upperBound = bb.convertExpression(window.getUpperBound()); SqlNodeList orderList = window.getOrderList(); if ((orderList.size() == 0) && !window.isRows()) {
SqlStdOperatorTable.EQUALS, leftKeys.get(0), bb.convertExpression(rightVals)); } else { assert rightVals instanceof SqlCall;
private RexNode convertJoinCondition( Blackboard bb, SqlNode condition, JoinConditionType conditionType, RelNode leftRel, RelNode rightRel) { if (condition == null) { return rexBuilder.makeLiteral(true); } bb.setRoot(ImmutableList.of(leftRel, rightRel)); replaceSubqueries(bb, condition, RelOptUtil.Logic.UNKNOWN_AS_FALSE); switch (conditionType) { case ON: bb.setRoot(ImmutableList.of(leftRel, rightRel)); return bb.convertExpression(condition); case USING: SqlNodeList list = (SqlNodeList) condition; List<String> nameList = new ArrayList<String>(); for (SqlNode columnName : list) { final SqlIdentifier id = (SqlIdentifier) columnName; String name = id.getSimple(); nameList.add(name); } return convertUsing(leftRel, rightRel, nameList); default: throw Util.unexpected(conditionType); } }
/** * Converts a WHERE clause. * * @param bb Blackboard * @param where WHERE clause, may be null */ private void convertWhere( final Blackboard bb, final SqlNode where) { if (where == null) { return; } SqlNode newWhere = pushDownNotForIn(where); replaceSubqueries(bb, newWhere, RelOptUtil.Logic.UNKNOWN_AS_FALSE); final RexNode convertedWhere = bb.convertExpression(newWhere); // only allocate filter if the condition is not TRUE if (!convertedWhere.isAlwaysTrue()) { bb.setRoot( RelOptUtil.createFilter(bb.root, convertedWhere), false); } }
/** * Converts an item in an ORDER BY clause, extracting DESC, NULLS LAST * and NULLS FIRST flags first. */ public RexNode convertSortExpression(SqlNode expr, Set<SqlKind> flags) { switch (expr.getKind()) { case DESCENDING: case NULLS_LAST: case NULLS_FIRST: flags.add(expr.getKind()); final SqlNode operand = ((SqlCall) expr).operand(0); return convertSortExpression(operand, flags); default: return convertExpression(expr); } }
/** * Converts an expression from {@link SqlNode} to {@link RexNode} format. * * @param node Expression to translate * @return Converted expression */ public RexNode convertExpression( SqlNode node) { Map<String, RelDataType> nameToTypeMap = Collections.emptyMap(); Blackboard bb = createBlackboard( new ParameterScope((SqlValidatorImpl) validator, nameToTypeMap), null); return bb.convertExpression(node); }
public RexNode apply(Pair<RexNode, SqlNode> pair) { return rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, pair.left, bb.convertExpression(pair.right)); } }),