/** As {@link #field(int, int, int)}, but if {@code alias} is true, the method * may apply an alias to make sure that the field has the same name as in the * input frame. If no alias is applied the expression is definitely a * {@link RexInputRef}. */ private RexNode field(int inputCount, int inputOrdinal, int fieldOrdinal, boolean alias) { final Frame frame = peek_(inputCount, inputOrdinal); final RelNode input = frame.rel; final RelDataType rowType = input.getRowType(); if (fieldOrdinal < 0 || fieldOrdinal > rowType.getFieldCount()) { throw new IllegalArgumentException("field ordinal [" + fieldOrdinal + "] out of range; input fields are: " + rowType.getFieldNames()); } final RelDataTypeField field = rowType.getFieldList().get(fieldOrdinal); final int offset = inputOffset(inputCount, inputOrdinal); final RexInputRef ref = cluster.getRexBuilder() .makeInputRef(field.getType(), offset + fieldOrdinal); final RelDataTypeField aliasField = frame.fields().get(fieldOrdinal); if (!alias || field.getName().equals(aliasField.getName())) { return ref; } else { return alias(ref, aliasField.getName()); } }
/** * Create a cast for partition column. Partition column is output as "VARCHAR" in native parquet reader. Cast it * appropriate type according the partition type in HiveScan. */ private RexNode createPartitionColumnCast(final DrillScanRel hiveScanRel, final DrillScanRel nativeScanRel, final String outputColName, final String dirColName, final RexBuilder rb) { final RelDataType outputType = hiveScanRel.getRowType().getField(outputColName, false, false).getType(); final RelDataTypeField inputField = nativeScanRel.getRowType().getField(dirColName, false, false); final RexInputRef inputRef = rb.makeInputRef(rb.getTypeFactory().createSqlType(SqlTypeName.VARCHAR), inputField.getIndex()); if (outputType.getSqlTypeName() == SqlTypeName.CHAR) { return rb.makeCall(RTRIM, inputRef); } return rb.makeCast(outputType, inputRef); } }
@Override public RexNode visitInputRef(RexInputRef ref) { RelDataTypeField f = oldFields.get(ref.getIndex()); for (int index = 0; index < newFields.size(); index++) { RelDataTypeField newf = newFields.get(index); if (f.getKey().equals(newf.getKey()) && f.getValue() == newf.getValue()) { return new RexInputRef(index, f.getValue()); } } throw MatchFailed.INSTANCE; } };
@Override public RexNode apply(RelDataTypeField input) { return new RexInputRef(input.getIndex(), input.getType()); } });
@Override public RexNode apply(RelDataTypeField field) { return rel.getCluster().getRexBuilder().makeInputRef(field.getType(), field.getIndex()); } });
private List<RexNode> projects(RelDataType inputRowType) { final List<RexNode> exprList = new ArrayList<>(); for (RelDataTypeField field : inputRowType.getFieldList()) { final RexBuilder rexBuilder = cluster.getRexBuilder(); exprList.add(rexBuilder.makeInputRef(field.getType(), field.getIndex())); } return exprList; }
RelNode leftRel = inputRels[0]; RelNode rightRel = inputRels[1]; RexBuilder rexBuilder = leftRel.getCluster().getRexBuilder(); RexNode outJoinCond = null; int origLeftInputSize = leftRel.getRowType().getFieldCount(); int origRightInputSize = rightRel.getRowType().getFieldCount(); final RelDataTypeField field = leftRel.getRowType().getFieldList().get(i); newLeftFields.add(rexBuilder.makeInputRef(field.getType(), i)); newLeftFieldNames.add(field.getName()); final RelDataTypeField field = rightRel.getRowType().getFieldList().get(i); newRightFields.add(rexBuilder.makeInputRef(field.getType(), i)); newRightFieldNames.add(field.getName()); origColEqConds.add(Pair.of(((RexInputRef) leftKey).getIndex(), ((RexInputRef) rightKey).getIndex())); origColEqCondsPosBuilder.set(i); } else { leftKeys.add(p.left); rightKeys.add(p.right); RexNode cond = rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef(leftKey.getType(), systemColCount + p.left),
final Sort sort = call.rel(1); final int count = sort.getInput().getRowType().getFieldCount(); if (count == 1) { final RexBuilder rexBuilder = sort.getCluster().getRexBuilder(); final RelMetadataQuery mq = call.getMetadataQuery(); final RelOptPredicateList predicates = mq.getPulledUpPredicates(sort.getInput()); List<RelDataTypeField> fields = sort.getInput().getRowType().getFieldList(); List<Pair<RexNode, String>> newChildExprs = new ArrayList<>(); List<RexNode> topChildExprs = new ArrayList<>(); List<String> topChildExprsFields = new ArrayList<>(); for (int i = 0; i < count ; i++) { RexNode expr = rexBuilder.makeInputRef(sort.getInput(), i); RelDataTypeField field = fields.get(i); if (constants.containsKey(expr)) { topChildExprs.add(constants.get(expr)); topChildExprsFields.add(field.getName()); } else { newChildExprs.add(Pair.<RexNode,String>of(expr, field.getName())); topChildExprs.add(expr); topChildExprsFields.add(field.getName()); RelOptUtil.permutation(Pair.left(newChildExprs), sort.getInput().getRowType()).inverse(); List<RelFieldCollation> fieldCollations = new ArrayList<>(); for (RelFieldCollation fc : sort.getCollation().getFieldCollations()) {
private RexNode decorrFieldAccess(RexFieldAccess fieldAccess) { int newInputOutputOffset = 0; for (RelNode input : currentRel.getInputs()) { final Frame frame = map.get(input); if (frame != null) { // try to find in this input rel the position of cor var final CorRef corRef = cm.mapFieldAccessToCorRef.get(fieldAccess); if (corRef != null) { Integer newInputPos = frame.corDefOutputs.get(corRef.def()); if (newInputPos != null) { // This input rel does produce the cor var referenced. // Assume fieldAccess has the correct type info. return new RexInputRef(newInputPos + newInputOutputOffset, frame.r.getRowType().getFieldList().get(newInputPos) .getType()); } } // this input rel does not produce the cor var needed newInputOutputOffset += frame.r.getRowType().getFieldCount(); } else { // this input rel is not rewritten newInputOutputOffset += input.getRowType().getFieldCount(); } } return fieldAccess; } }
final List<RelDataTypeField> relOutput = rel.getRowType().getFieldList(); projects.add( newPos, Pair.of( decorrelateExpr(oldProjects.get(newPos)), relOutput.get(newPos).getName())); mapOldToNewOutputs.put(newPos, newPos); for (Map.Entry<CorDef, Integer> entry : frame.corDefOutputs.entrySet()) { projects.add( RexInputRef.of2(entry.getValue(), frame.r.getRowType().getFieldList())); corDefOutputs.put(entry.getKey(), newPos); newPos++; RelNode newProject = HiveProject.create(frame.r, Pair.left(projects), Pair.right(projects));
final Union union = call.rel(0); final int count = union.getRowType().getFieldCount(); if (count == 1) { ImmutableBitSet.Builder refsIndexBuilder = ImmutableBitSet.builder(); for (int i = 0; i < count ; i++) { RexNode expr = rexBuilder.makeInputRef(union, i); RelDataTypeField field = fields.get(i); if (constants.containsKey(expr)) { topChildExprs.add(constants.get(expr)); topChildExprsFields.add(field.getName()); } else { topChildExprs.add(expr); topChildExprsFields.add(field.getName()); refs.add(expr); refsIndexBuilder.set(i); RelOptUtil.permutation(refs, union.getInput(0).getRowType()).inverse(); topChildExprs = ImmutableList.copyOf(RexUtil.apply(mapping, topChildExprs)); int pos = refsIndex.nth(j); newChildExprs.add( Pair.<RexNode, String>of(rexBuilder.makeInputRef(input, pos), input.getRowType().getFieldList().get(pos).getName())); relBuilder.project(Pair.left(newChildExprs), Pair.right(newChildExprs));
private RelNode genLateralViewPlans(ASTNode lateralView, Map<String, RelNode> aliasToRel) throws SemanticException { final RexBuilder rexBuilder = this.cluster.getRexBuilder(); final RelDataTypeFactory dtFactory = this.cluster.getTypeFactory(); final String inlineFunctionName = GenericUDTFInline.class.getAnnotation(Description.class).name(); List<RexNode> inputRefs = Lists.transform(inputRel.getRowType().getFieldList(), input -> new RexInputRef(input.getIndex(), input.getType())); List<String> outputFieldNames = new ArrayList<>(inputRel.getRowType().getFieldNames()); RexCall convertedOriginalValuesExpr = (RexCall) new RexNodeConverter(this.cluster, inputRel.getRowType(), inputPosMap, 0, false).convert(valuesExpr); RelDataType valuesRowType = ((ArraySqlType) convertedOriginalValuesExpr.getType()).getComponentType(); List<RexNode> exprs = new ArrayList<>(inputRefs); exprs.addAll(structCall.getOperands()); newStructExprs.add(rexBuilder.makeCall(structCall.op, exprs)); rexBuilder.makeCall(convertedOriginalValuesExpr.op, newStructExprs); RelDataType retType = SqlValidatorUtil.deriveJoinRowType(inputRel.getRowType(), ImmutableList.of(inputRel), rexBuilder.makeCall(calciteOp, convertedFinalValuesExpr), null, retType, null); columnAliases.size() != valuesRowType.getFieldCount()) {
final int fieldCount = getRowType().getFieldCount(); if (fieldsUsed.equals(ImmutableBitSet.range(fieldCount)) && extraFields.isEmpty()) { return this; final List<RelDataTypeField> fields = getRowType().getFieldList(); List<RelDataType> fieldTypes = new LinkedList<RelDataType>(); List<String> fieldNames = new LinkedList<String>(); List<RexNode> exprList = new ArrayList<RexNode>(); RexBuilder rexBuilder = getCluster().getRexBuilder(); for (int i : fieldsUsed) { RelDataTypeField field = fields.get(i); fieldTypes.add(field.getType()); fieldNames.add(field.getName()); exprList.add(rexBuilder.makeInputRef(this, i)); HiveTableScan newHT = copy(getCluster().getTypeFactory().createStructType(fieldTypes, fieldNames));
private static RelNode project(DruidQuery dq, ImmutableBitSet fieldsUsed, Set<RelDataTypeField> extraFields, RelBuilder relBuilder) { final int fieldCount = dq.getRowType().getFieldCount(); if (fieldsUsed.equals(ImmutableBitSet.range(fieldCount)) && extraFields.isEmpty()) { final RexBuilder rexBuilder = dq.getCluster().getRexBuilder(); final List<RelDataTypeField> fields = dq.getRowType().getFieldList(); exprList.add(rexBuilder.makeInputRef(dq, i)); nameList.add(field.getName()); rexBuilder.ensureType( extraField.getType(), rexBuilder.constantNull(), true)); nameList.add(extraField.getName());
private RexInputRef getNewForOldInputRef(RexInputRef oldInputRef) { assert currentRel != null; int oldOrdinal = oldInputRef.getIndex(); int oldOrdinalNo = oldOrdinal; int newOrdinal = 0; for (RelNode oldInput0 : currentRel.getInputs()) { RelDataType oldInputType = oldInput0.getRowType(); int n = oldInputType.getFieldCount(); if (oldOrdinal < n) { oldInput = oldInput0; newOrdinal += newInput.getRowType().getFieldCount(); oldOrdinal -= n; final Frame newFrame = map.get(currentRel.getInput(0)); if(newFrame.r instanceof HiveSemiJoin) { int oldFieldSize = currentRel.getInput(0).getRowType().getFieldCount(); int newOrd = newFrame.r.getRowType().getFieldCount() + oldOrdinalNo - oldFieldSize; return new RexInputRef(newOrd, oldInputRef.getType()); return new RexInputRef(newOrdinal, frame.r.getRowType().getFieldList().get(newLocalOrdinal).getType());
/** * Projects all {@code input} output fields plus the additional expressions. * * @param input Input relational expression * @param additionalExprs Additional expressions and names * @return the new Project */ private RelNode createProjectWithAdditionalExprs( RelNode input, List<Pair<RexNode, String>> additionalExprs) { final List<RelDataTypeField> fieldList = input.getRowType().getFieldList(); List<Pair<RexNode, String>> projects = Lists.newArrayList(); for (Ord<RelDataTypeField> field : Ord.zip(fieldList)) { projects.add( Pair.of( (RexNode) rexBuilder.makeInputRef( field.e.getType(), field.i), field.e.getName())); } projects.addAll(additionalExprs); return RelOptUtil.createProject(input, Pair.left(projects), Pair.right(projects), false, relBuilder); }
final List<RelDataTypeField> fields = rel.getRowType().getFieldList(); final RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); outputNameList .add(((fieldNames == null) || (fieldNames.size() <= i) || (fieldNames.get(i) == null)) ? sourceField .getName() : fieldNames.get(i)); outputProjList.add(rexBuilder.makeInputRef(rel, source));
Project project, int nullIndicatorPos) { final RelDataTypeFactory typeFactory = join.getCluster().getTypeFactory(); final RelNode left = join.getLeft(); final JoinRelType joinType = join.getJoinType(); new RexInputRef( nullIndicatorPos, typeFactory.createTypeWithNullability( join.getRowType().getFieldList().get(nullIndicatorPos) .getType(), true)); left.getRowType().getFieldList(); newProjExprs.add(RexInputRef.of2(i, leftInputFields)); nullIndicator); newProjExprs.add(Pair.of(newProjExpr, pair.right)); return RelOptUtil.createProject(join, Pair.left(newProjExprs), Pair.right(newProjExprs), false, relBuilder);
public static ImmutableList<RexNode> getInputRef(List<Integer> inputRefs, RelNode inputRel) { ImmutableList.Builder<RexNode> bldr = ImmutableList.<RexNode> builder(); for (int i : inputRefs) { bldr.add(new RexInputRef(i, inputRel.getRowType().getFieldList().get(i).getType())); } return bldr.build(); }
final RelBuilder relBuilder = call.builder(); final Aggregate aggRel = (Aggregate) call.rel(0); final RexBuilder rexBuilder = aggRel.getCluster().getRexBuilder(); final List<Integer> nullableArgs = new ArrayList<>(args.size()); for (int arg : args) { if (aggRel.getInput().getRowType().getFieldList().get(arg).getType().isNullable()) { nullableArgs.add(arg); for (int i = 0; i < offset; ++i) { projList.add( rexBuilder.makeInputRef( aggRel.getRowType().getFieldList().get(i).getType(), i)); for (int i = offset; i < aggRel.getRowType().getFieldCount(); ++i) { projList.add( rexBuilder.makeInputRef( aggRel.getRowType().getFieldList().get(i).getType(), indexes.get(i-offset)));