private RexNode makeOr(final List<RexNode> conditions) { if (conditions.size() == 1) { return Iterables.getOnlyElement(conditions); } else { return getCluster().getRexBuilder().makeCall(SqlStdOperatorTable.OR, conditions); } } }
private List<RexNode> rewriteInClauseChildren(SqlOperator op, List<RexNode> childRexNodeLst) throws SemanticException { assert op.getKind() == SqlKind.IN; RexNode firstPred = childRexNodeLst.get(0); List<RexNode> newChildRexNodeLst = new ArrayList<RexNode>(); for (int i = 1; i < childRexNodeLst.size(); i++) { newChildRexNodeLst.add( cluster.getRexBuilder().makeCall( SqlStdOperatorTable.EQUALS, firstPred, childRexNodeLst.get(i))); } return newChildRexNodeLst; }
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; }
/*********************** Convert Hive Types To Calcite Types ***********************/ public static RelDataType getType(RelOptCluster cluster, List<ColumnInfo> cInfoLst) throws CalciteSemanticException { RexBuilder rexBuilder = cluster.getRexBuilder(); RelDataTypeFactory dtFactory = rexBuilder.getTypeFactory(); List<RelDataType> fieldTypes = new LinkedList<RelDataType>(); List<String> fieldNames = new LinkedList<String>(); for (ColumnInfo ci : cInfoLst) { fieldTypes.add(convert(ci.getType(), dtFactory)); fieldNames.add(ci.getInternalName()); } return dtFactory.createStructType(fieldTypes, fieldNames); }
public static Pair<RelOptTable, List<Integer>> getColumnOriginSet(RelNode rel, ImmutableBitSet colSet) { RelMetadataQuery mq = rel.getCluster().getMetadataQuery(); RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); Map<RelTableRef, List<Integer>> tabToOriginColumns = new HashMap<>(); for(int col:colSet) { cols = new ArrayList<>(); cols.add(inputRef.getIndex()); tabToOriginColumns.put(inputRef.getTableRef(), cols); RelTableRef tblRef = mapEntries.getKey(); List<Integer> mapColList = mapEntries.getValue(); if(mapColList.size() == colSet.cardinality()) { RelOptTable tbl = tblRef.getTable(); return Pair.of(tbl, mapColList);
private RexNode handleExplicitCast(ExprNodeGenericFuncDesc func, List<RexNode> childRexNodeLst) throws CalciteSemanticException { RexNode castExpr = null; if (childRexNodeLst != null && childRexNodeLst.size() == 1) { GenericUDF udf = func.getGenericUDF(); if ((udf instanceof GenericUDFToChar) || (udf instanceof GenericUDFToVarchar) || (udf instanceof GenericUDFToString) || (udf instanceof GenericUDFToDecimal) || (udf instanceof GenericUDFToDate) || (udf instanceof GenericUDFTimestamp) || (udf instanceof GenericUDFToTimestampLocalTZ) || (udf instanceof GenericUDFToBinary) || castExprUsingUDFBridge(udf)) { castExpr = cluster.getRexBuilder().makeAbstractCast( TypeConverter.convert(func.getTypeInfo(), cluster.getTypeFactory()), childRexNodeLst.get(0)); } } return castExpr; }
newLocalOutputs.add(newCorVarOffset); offset += distinct.getRowType().getFieldCount(); } else { r = relBuilder.push(r).push(distinct) .join(JoinRelType.INNER, cluster.getRexBuilder().makeLiteral(true)).build();
protected RexNode convert(ExprNodeColumnDesc col) throws SemanticException { //if this is co-rrelated we need to make RexCorrelVariable(with id and type) // id and type should be retrieved from outerRR InputCtx ic = getInputCtx(col); if(ic == null) { // we have correlated column, build data type from outer rr RelDataType rowType = TypeConverter.getType(cluster, this.outerRR, null); if (this.outerNameToPosMap.get(col.getColumn()) == null) { throw new SemanticException(ErrorMsg.INVALID_COLUMN_NAME.getMsg(col.getColumn())); } int pos = this.outerNameToPosMap.get(col.getColumn()); CorrelationId colCorr = new CorrelationId(this.correlatedId); RexNode corExpr = cluster.getRexBuilder().makeCorrel(rowType, colCorr); return cluster.getRexBuilder().makeFieldAccess(corExpr, pos); } int pos = ic.hiveNameToPosMap.get(col.getColumn()); return cluster.getRexBuilder().makeInputRef( ic.calciteInpDataType.getFieldList().get(pos).getType(), pos + ic.offsetInCalciteSchema); }
inputs.get(0).getCluster().getRexBuilder(), nonEquiList, false);
@Override public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) { if (getInput() instanceof OLAPFilterRel) { // merge project & filter OLAPFilterRel filter = (OLAPFilterRel) getInput(); RelNode inputOfFilter = inputs.get(0).getInput(0); RexProgram program = RexProgram.create(inputOfFilter.getRowType(), this.rewriteProjects, filter.getCondition(), this.rowType, getCluster().getRexBuilder()); return new EnumerableCalc(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), // inputOfFilter, program); } else { // keep project for table scan EnumerableRel input = sole(inputs); RexProgram program = RexProgram.create(input.getRowType(), this.rewriteProjects, null, this.rowType, getCluster().getRexBuilder()); return new EnumerableCalc(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), // input, program); } }
@Override public DruidQuery toDruidQueryForExplaining() { return partialQuery.build( DUMMY_DATA_SOURCE, RowSignature.from( sourceRel.getRowType().getFieldNames(), sourceRel.getRowType() ), getPlannerContext(), getCluster().getRexBuilder(), false ); }
public UnifyResult apply(UnifyRuleCall call) { final MutableRel query = call.query; final List<RelDataTypeField> oldFieldList = query.getRowType().getFieldList(); final List<RelDataTypeField> newFieldList = call.target.getRowType().getFieldList(); List<RexNode> newProjects; try { newProjects = transformRex( (List<RexNode>) call.getCluster().getRexBuilder().identityProjects( query.getRowType()), oldFieldList, newFieldList); } catch (MatchFailed e) { return null; } final MutableProject newProject = MutableProject.of( query.getRowType(), call.target, newProjects); final MutableRel newProject2 = MutableRels.strip(newProject); return call.result(newProject2); }
private List<RexNode> rewriteCoalesceChildren( ExprNodeGenericFuncDesc func, List<RexNode> childRexNodeLst) { final List<RexNode> convertedChildList = Lists.newArrayList(); assert childRexNodeLst.size() > 0; final RexBuilder rexBuilder = cluster.getRexBuilder(); int i=0; for (; i < childRexNodeLst.size()-1; ++i ) { // WHEN child not null THEN child final RexNode child = childRexNodeLst.get(i); RexNode childCond = rexBuilder.makeCall( SqlStdOperatorTable.IS_NOT_NULL, child); convertedChildList.add(childCond); convertedChildList.add(child); } // Add the last child as the ELSE element convertedChildList.add(childRexNodeLst.get(i)); return convertedChildList; }
/*********************** Convert Hive Types To Calcite Types ***********************/ public static RelDataType getType(RelOptCluster cluster, List<ColumnInfo> cInfoLst) throws CalciteSemanticException { RexBuilder rexBuilder = cluster.getRexBuilder(); RelDataTypeFactory dtFactory = rexBuilder.getTypeFactory(); List<RelDataType> fieldTypes = new LinkedList<RelDataType>(); List<String> fieldNames = new LinkedList<String>(); for (ColumnInfo ci : cInfoLst) { fieldTypes.add(convert(ci.getType(), dtFactory)); fieldNames.add(ci.getInternalName()); } return dtFactory.createStructType(fieldTypes, fieldNames); }
private RexNode handleExplicitCast(ExprNodeGenericFuncDesc func, List<RexNode> childRexNodeLst) throws CalciteSemanticException { RexNode castExpr = null; if (childRexNodeLst != null && childRexNodeLst.size() == 1) { GenericUDF udf = func.getGenericUDF(); if ((udf instanceof GenericUDFToChar) || (udf instanceof GenericUDFToVarchar) || (udf instanceof GenericUDFToDecimal) || (udf instanceof GenericUDFToDate) // Calcite can not specify the scale for timestamp. As a result, all // the millisecond part will be lost || (udf instanceof GenericUDFTimestamp) || (udf instanceof GenericUDFToBinary) || castExprUsingUDFBridge(udf)) { castExpr = cluster.getRexBuilder().makeAbstractCast( TypeConverter.convert(func.getTypeInfo(), cluster.getTypeFactory()), childRexNodeLst.get(0)); } } return castExpr; }
final RelOptPredicateList inputInfo = mq.getPulledUpPredicates(input); final List<RexNode> aggPullUpPredicates = new ArrayList<>(); final RexBuilder rexBuilder = agg.getCluster().getRexBuilder(); input.getRowType().getFieldCount(), agg.getRowType().getFieldCount()); if (!rCols.isEmpty() && groupKeys.contains(rCols)) { r = r.accept(new RexPermuteInputsShuttle(m, input)); aggPullUpPredicates.add(r);
private RexNode makeAnd(final List<RexNode> conditions) { if (conditions.size() == 1) { return Iterables.getOnlyElement(conditions); } else { return getCluster().getRexBuilder().makeCall(SqlStdOperatorTable.AND, conditions); } }
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; }
protected RexNode convert(ExprNodeColumnDesc col) throws SemanticException { //if this is co-rrelated we need to make RexCorrelVariable(with id and type) // id and type should be retrieved from outerRR InputCtx ic = getInputCtx(col); if(ic == null) { // we have correlated column, build data type from outer rr RelDataType rowType = TypeConverter.getType(cluster, this.outerRR, null); if (this.outerNameToPosMap.get(col.getColumn()) == null) { throw new SemanticException(ErrorMsg.INVALID_COLUMN_NAME.getMsg(col.getColumn())); } int pos = this.outerNameToPosMap.get(col.getColumn()); CorrelationId colCorr = new CorrelationId(this.correlatedId); RexNode corExpr = cluster.getRexBuilder().makeCorrel(rowType, colCorr); return cluster.getRexBuilder().makeFieldAccess(corExpr, pos); } int pos = ic.hiveNameToPosMap.get(col.getColumn()); return cluster.getRexBuilder().makeInputRef( ic.calciteInpDataType.getFieldList().get(pos).getType(), pos + ic.offsetInCalciteSchema); }
List<RexNode> inputExprs) { final int nGroups = oldAggRel.getGroupCount(); final RexBuilder rexBuilder = oldAggRel.getCluster().getRexBuilder(); final RelDataTypeFactory typeFactory = oldAggRel.getCluster().getTypeFactory(); final int iAvgInput = oldCall.getArgList().get(0); final RelDataType sum0InputType = typeFactory.createTypeWithNullability( getFieldType(oldAggRel.getInput(), iAvgInput), true);