/** * Creates an expression with which to reference the expression whose * offset in its from-list is {@code offset}. */ RexNode lookup( int offset, LookupContext lookupContext) { Pair<RelNode, Integer> pair = lookupContext.findRel(offset); return rexBuilder.makeRangeReference( pair.left.getRowType(), pair.right, false); }
/** * Adds an expression, deducing an appropriate name if possible. * * @param expr Expression * @param name Suggested name */ private void addExpr(RexNode expr, String name) { convertedInputExprs.add(expr); if ((name == null) && (expr instanceof RexInputRef)) { final int i = ((RexInputRef) expr).getIndex(); name = bb.root.getRowType().getFieldList().get(i).getName(); } if (convertedInputExprNames.contains(name)) { // In case like 'SELECT ... GROUP BY x, y, x', don't add // name 'x' twice. name = null; } convertedInputExprNames.add(name); }
private RelNode convertCursor(Blackboard bb, SubQuery subQuery) { final SqlCall cursorCall = (SqlCall) subQuery.node; assert cursorCall.operandCount() == 1; SqlNode query = cursorCall.operand(0); RelNode converted = convertQuery(query, false, false); int iCursor = bb.cursors.size(); bb.cursors.add(converted); subQuery.expr = new RexInputRef( iCursor, converted.getRowType()); return converted; }
RelDataTypeField getRootField(RexInputRef inputRef) { 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(); }
public void flatten( List<RelNode> rels, int systemFieldCount, int[] start, List<Pair<RelNode, Integer>> relOffsetList) { for (RelNode rel : rels) { if (leaves.contains(rel)) { relOffsetList.add( Pair.of(rel, start[0])); start[0] += rel.getRowType().getFieldCount(); } else { if (rel instanceof JoinRel || rel instanceof AggregateRel) { start[0] += systemFieldCount; } flatten( rel.getInputs(), systemFieldCount, start, relOffsetList); } } }
setRoot(rel, false); return rexBuilder.makeRangeReference( root.getRowType(), 0, false); final int origLeftInputCount = root.getRowType().getFieldCount(); if (leftKeys != null) { List<RexNode> newLeftInputExpr = Lists.newArrayList(); final int rightOffset = root.getRowType().getFieldCount() - newLeftInput.getRowType().getFieldCount(); final List<Integer> rightKeys = int leftFieldCount = root.getRowType().getFieldCount(); final RelNode join = createJoin( && joinType == JoinRelType.LEFT) { final int leftKeyCount = leftKeys.size(); int rightFieldLength = rel.getRowType().getFieldCount(); assert leftKeyCount == rightFieldLength - 1; } else { return rexBuilder.makeRangeReference( rel.getRowType(), leftFieldCount, joinType.generatesNullsOnRight());
SqlInsert call, RelNode sourceRel) { RelDataType sourceRowType = sourceRel.getRowType(); final RexNode sourceRef = rexBuilder.makeRangeReference(sourceRowType, 0, false);
final List<RelDataTypeField> fields = rel.getRowType().getFieldList(); final List<Pair<RexNode, String>> newProjects = Lists.newArrayList(); for (int i = 0; i < fields.size(); i++) { createAggregate( bb, BitSets.range(rel.getRowType().getFieldCount()), ImmutableList.<AggregateCall>of());
final List<RexNode> list = Lists.newArrayList(); for (String name : nameList) { final RelDataType leftRowType = leftRel.getRowType(); RelDataTypeField leftField = catalogReader.field(leftRowType, name); RexNode left = leftField.getType(), leftField.getIndex()); final RelDataType rightRowType = rightRel.getRowType(); RelDataTypeField rightField = catalogReader.field(rightRowType, name);
final int leftCount = leftRel.getRowType().getFieldCount(); final int rightCount = rightRel.getRowType().getFieldCount(); if (!containsGet(joinCond)) { joinCond = pushDownJoinConditions( leftRel.getRowType().getFieldList(); leftRel = RelOptUtil.createProject( leftRel, rightRel.getRowType().getFieldList(); final int newLeftCount = leftCount + extraLeftExprs.size(); rightRel = RelOptUtil.createProject(
final RelDataType rowType = bb.root.getRowType(); final int fieldCount = rowType.getFieldCount() - orderExprList.size();
int nSourceFields = joinRel.getLeft().getRowType().getFieldCount(); List<RexNode> projects = new ArrayList<RexNode>(); for (int level1Idx = 0; level1Idx < nLevel1Exprs; level1Idx++) {
protected RelDataType deriveRowType() { return child.getRowType(); } }
private void checkConvertedType(SqlNode query, RelNode result) { if (!query.isA(SqlKind.DML)) { // Verify that conversion from SQL to relational algebra did // not perturb any type information. (We can't do this if the // SQL statement is something like an INSERT which has no // validator type information associated with its result, // hence the namespace check above.) RelDataType convertedRowType = result.getRowType(); if (!checkConvertedRowType(query, convertedRowType)) { RelDataType validatedRowType = validator.getValidatedNodeType(query); validatedRowType = uniquifyFields(validatedRowType); throw Util.newInternal( "Conversion to relational algebra failed to preserve " + "datatypes:\n" + "validated type:\n" + validatedRowType.getFullTypeString() + "\nconverted type:\n" + convertedRowType.getFullTypeString() + "\nrel:\n" + RelOptUtil.toString(result)); } } }
final ProjectRelBase left = (ProjectRelBase) join.getLeft(); final RelNode leftLeft = ((JoinRelBase) left.getInput(0)).getLeft(); final int leftLeftCount = leftLeft.getRowType().getFieldCount(); final RelDataType nullableBooleanType = typeFactory.createTypeWithNullability( final RexNode ckRef = rexBuilder.makeInputRef(root, leftLeftCount + 1); final RexNode iRef = rexBuilder.makeInputRef(root, root.getRowType().getFieldCount() - 1);
private static boolean equalType( String desc0, RelNode rel0, String desc1, RelNode rel1) { return RelOptUtil.equal( desc0, rel0.getRowType(), desc1, rel1.getRowType(), true); }
public static Fields createTypedFieldsFor( RelNode relNode, boolean numeric ) { RelDataType rowType = relNode.getRowType(); RelOptCluster cluster = relNode.getCluster(); return createTypedFields( cluster, rowType, numeric ); }
protected RelDataType deriveRowType() { return getChild().getRowType(); } }
public RelDataTypeField get(int index) { return getChild().getRowType().getFieldList().get( Util.toList(groupSet).get(index)); } },
/** * Returns a mapping, or null if this projection is not a mapping. */ public Mappings.TargetMapping getMapping() { return getMapping(getChild().getRowType().getFieldCount(), exps); }