/** Creates a call to a scalar operator. */ public RexNode call(SqlOperator operator, RexNode... operands) { final RexBuilder builder = cluster.getRexBuilder(); final List<RexNode> operandList = ImmutableList.copyOf(operands); final RelDataType type = builder.deriveReturnType(operator, operandList); if (type == null) { throw new IllegalArgumentException("cannot derive type: " + operator + "; operands: " + Lists.transform(operandList, FN_TYPE)); } return builder.makeCall(type, operator, operandList); }
private RelNode projectLeftOuterSide(RelNode srcRel, int numColumns) throws SemanticException { RowResolver iRR = relToHiveRR.get(srcRel); RowResolver oRR = new RowResolver(); RowResolver.add(oRR, iRR, numColumns); List<RexNode> calciteColLst = new ArrayList<RexNode>(); List<String> oFieldNames = new ArrayList<String>(); RelDataType iType = srcRel.getRowType(); for (int i = 0; i < iType.getFieldCount(); i++) { RelDataTypeField fType = iType.getFieldList().get(i); String fName = iType.getFieldNames().get(i); calciteColLst.add(cluster.getRexBuilder().makeInputRef(fType.getType(), i)); oFieldNames.add(fName); } HiveRelNode selRel = HiveProject.create(srcRel, calciteColLst, oFieldNames); this.relToHiveColNameCalcitePosMap.put(selRel, buildHiveToCalciteColumnMap(oRR, selRel)); this.relToHiveRR.put(selRel, oRR); return selRel; }
/** Creates a literal (constant expression). */ public RexNode literal(Object value) { final RexBuilder rexBuilder = cluster.getRexBuilder(); if (value == null) { return rexBuilder.constantNull(); } else if (value instanceof Boolean) { return rexBuilder.makeLiteral((Boolean) value); } else if (value instanceof BigDecimal) { return rexBuilder.makeExactLiteral((BigDecimal) value); } else if (value instanceof Float || value instanceof Double) { return rexBuilder.makeApproxLiteral( BigDecimal.valueOf(((Number) value).doubleValue())); } else if (value instanceof Number) { return rexBuilder.makeExactLiteral( BigDecimal.valueOf(((Number) value).longValue())); } else if (value instanceof String) { return rexBuilder.makeLiteral((String) value); } else { throw new IllegalArgumentException("cannot convert " + value + " (" + value.getClass() + ") to a constant"); } }
/** * 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); } }
@Test public void testTimeMinusYearMonthInterval() { final Period period = new Period("P1Y1M"); testExpression( rexBuilder.makeCall( typeFactory.createSqlType(SqlTypeName.TIMESTAMP), SqlStdOperatorTable.MINUS_DATE, ImmutableList.of( inputRef("t"), rexBuilder.makeIntervalLiteral( new BigDecimal(13), // YEAR-MONTH literals value is months new SqlIntervalQualifier(TimeUnit.YEAR, TimeUnit.MONTH, SqlParserPos.ZERO) ) ) ), DruidExpression.of( null, "timestamp_shift(\"t\",concat('P', 13, 'M'),-1)" ), DateTimes.of("2000-02-03T04:05:06").minus(period).getMillis() ); }
private static RelNode createMaterializedViewScan(HiveConf conf, Table viewTable) { final RexBuilder rexBuilder = new RexBuilder( new JavaTypeFactoryImpl( new HiveTypeSystemImpl())); final RelOptCluster cluster = RelOptCluster.create(planner, rexBuilder); RelDataTypeFactory dtFactory = cluster.getRexBuilder().getTypeFactory(); for (RelDataTypeField field : rowType.getFieldList()) { if (DruidTable.DEFAULT_TIMESTAMP_COLUMN.equals(field.getName())) { druidColTypes.add(dtFactory.createTypeWithNullability(field.getType(), false)); } else { druidColTypes.add(field.getType()); druidColNames.add(field.getName()); if (field.getType().getSqlTypeName() == SqlTypeName.VARCHAR) { rowType = dtFactory.createStructType(druidColTypes, druidColNames); RelOptHiveTable optTable = new RelOptHiveTable(null, cluster.getTypeFactory(), fullyQualifiedTabName, rowType, viewTable, nonPartitionColumns, partitionColumns, new ArrayList<>(), conf, new HashMap<>(), new HashMap<>(), new AtomicInteger()); optTable, viewTable.getTableName(), null, false, false); tableRel = DruidQuery.create(cluster, cluster.traitSetOf(BindableConvention.INSTANCE), optTable, druidTable, ImmutableList.<RelNode>of(scan), ImmutableMap.of()); } else {
newCasts.add(rexBuilder.makeInputRef(project.getChildExps().get(fieldNumber).getType(), fieldNumber)); final RexNode filterFromCase = rexBuilder.makeCall( booleanType, flip ? SqlStdOperatorTable.IS_FALSE : SqlStdOperatorTable.IS_TRUE, ImmutableList.of(caseCall.getOperands().get(0)) ); filter = rexBuilder.makeCall( booleanType, SqlStdOperatorTable.AND, ImmutableList.of(project.getProjects().get(aggregateCall.filterArg), filterFromCase) ); } else { && arg1.isA(SqlKind.LITERAL) && !RexLiteral.isNullLiteral(arg1) && RexLiteral.isNullLiteral(arg2)) { final RelDataType oldType = aggregate.getRowType().getFieldList().get(i).getType(); if (newCall == null) { newCasts.add(rexBuilder.makeInputRef(oldType, i)); } else { newCasts.add(rexBuilder.makeCast(oldType, rexBuilder.makeInputRef(newCall.getType(), i)));
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); final RelDataType sumReturnType = getSumReturnType( rexBuilder.getTypeFactory(), sum0InputType, oldCall.getType()); final AggregateCall sumCall = AggregateCall.create( rexBuilder.addAggCall(sumCall, nGroups, oldAggRel.indicator, newCalls, aggCallMapping, ImmutableList.of(sum0InputType)); refSum = rexBuilder.ensureType(oldCall.getType(), refSum, true); final RexNode coalesce = rexBuilder.makeCall( SqlStdOperatorTable.COALESCE, refSum, rexBuilder.makeZeroLiteral(refSum.getType())); return rexBuilder.makeCast(oldCall.getType(), coalesce);
/** Creates a call to a scalar operator. */ public RexNode call(SqlOperator operator, Iterable<? extends RexNode> operands) { return cluster.getRexBuilder().makeCall(operator, ImmutableList.copyOf(operands)); }
@Test public void testConcat() { testExpression( rexBuilder.makeCall( typeFactory.createSqlType(SqlTypeName.VARCHAR), SqlStdOperatorTable.CONCAT, ImmutableList.of( inputRef("s"), rexBuilder.makeLiteral("bar") ) ), DruidExpression.fromExpression("concat(\"s\",'bar')"), "foobar" ); }
ImmutableList.of(rexBuilder.makeCast( cluster.getTypeFactory().createTypeWithNullability(projExprs.get(0).getType(), true), projExprs.get(0))), null, false, relBuilder);
); if (rexNode.getType().isNullable()) { final DimFilter nonNullFilter = Expressions.toFilter( plannerContext, rowSignature, rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, ImmutableList.of(rexNode)) );
final BlockBuilder builder = new BlockBuilder(); final JavaTypeFactoryImpl javaTypeFactory = new JavaTypeFactoryImpl(rexBuilder.getTypeFactory().getTypeSystem()); ImmutableList.of( Pair.<Expression, PhysType>of( Expressions.field(context,
programBuilder.addMatchOrder(HepMatchOrder.TOP_DOWN); programBuilder = programBuilder.addRuleCollection( ImmutableList.<RelOptRule>of(DummyRule.INSTANCE)); RexBuilder rexBuilder = new RexBuilder(new JavaTypeFactoryImpl()); RelOptCluster cluster = RelOptCluster.create(planner, rexBuilder); RelMetadataProvider chainedProvider = ChainedRelMetadataProvider.of(list); final RelNode node = new DummyNode(cluster, cluster.traitSet()); node.getCluster().setMetadataProvider( new CachingRelMetadataProvider(chainedProvider, planner));
public static HiveTableFunctionScan createUDTFForSetOp(RelOptCluster cluster, RelNode input) throws SemanticException { RelTraitSet traitSet = TraitsUtil.getDefaultTraitSet(cluster); List<RexNode> originalInputRefs = Lists.transform(input.getRowType().getFieldList(), new Function<RelDataTypeField, RexNode>() { @Override public RexNode apply(RelDataTypeField input) { return new RexInputRef(input.getIndex(), input.getType()); } }); ImmutableList.Builder<RelDataType> argTypeBldr = ImmutableList.<RelDataType> builder(); for (int i = 0; i < originalInputRefs.size(); i++) { argTypeBldr.add(originalInputRefs.get(i).getType()); } RelDataType retType = input.getRowType(); String funcName = "replicate_rows"; FunctionInfo fi = FunctionRegistry.getFunctionInfo(funcName); SqlOperator calciteOp = SqlFunctionConverter.getCalciteOperator(funcName, fi.getGenericUDTF(), argTypeBldr.build(), retType); // Hive UDTF only has a single input List<RelNode> list = new ArrayList<>(); list.add(input); RexNode rexNode = cluster.getRexBuilder().makeCall(calciteOp, originalInputRefs); return HiveTableFunctionScan.create(cluster, traitSet, list, rexNode, null, retType, null); }
private static RexCall adjustOBSchema(RexCall obyExpr, Project obChild, List<FieldSchema> resultSchema) { int a = -1; List<RexNode> operands = new ArrayList<>(); for (int k = 0; k < obyExpr.operands.size(); k++) { RexNode rn = obyExpr.operands.get(k); for (int j = 0; j < resultSchema.size(); j++) { if( obChild.getChildExps().get(j).toString().equals(rn.toString())) { a = j; break; } } if (a != -1) { operands.add(new RexInputRef(a, rn.getType())); } else { if (rn instanceof RexCall) { operands.add(adjustOBSchema((RexCall)rn, obChild, resultSchema)); } else { operands.add(rn); } } a = -1; } return (RexCall) obChild.getCluster().getRexBuilder().makeCall( obyExpr.getType(), obyExpr.getOperator(), operands); }
private RexNode transformIntoInClauseCondition(RexBuilder rexBuilder, RexNode condition, int minNumORClauses) throws SemanticException { assert condition.getKind() == SqlKind.OR; if (operands.size() < minNumORClauses) { for (int i = 0; i < operands.size(); i++) { ConstraintGroup m = new ConstraintGroup(operands.get(i)); allNodes.add(m); return ops.get(0); } else { return rexBuilder.makeCall(SqlStdOperatorTable.OR, ops);
switch (conjCall.getOperator().getKind()) { case EQUALS: if (!(RexUtil.isConstant(conjCall.operands.get(0))) && RexUtil.isConstant(conjCall.operands.get(1))) { conditions.put(conjCall.operands.get(0).toString(), conjCall.operands.get(1)); } else if (!(RexUtil.isConstant(conjCall.operands.get(1))) && RexUtil.isConstant(conjCall.operands.get(0))) { conditions.put(conjCall.operands.get(1).toString(), conjCall.operands.get(0)); conditions.put(conjCall.operands.get(0).toString(), relBuilder.getRexBuilder().makeNullLiteral( conjCall.operands.get(0).getType().getSqlTypeName()));
RelNode input = aggr.getInput(); RelBuilder relBuilder = call.builder(); RexBuilder rexBuilder = aggr.getCluster().getRexBuilder(); int index = 0; Iterator<Integer> groupSetIter = aggr.getGroupSet().iterator(); Iterator<RelDataTypeField> typeIterator = aggr.getRowType().getFieldList().iterator(); Iterator<Integer> groupKeyIter = groupSet.iterator(); int groupKey = groupKeyIter.next(); RelDataType type = typeIterator.next().getType(); if (groupKey == aggrGroupKey) { rexNodes.add(rexBuilder.makeInputRef(type, index++)); groupKey = groupKeyIter.next(); } else { rexNodes.add(rexBuilder.makeNullLiteral(type)); RelDataType type = typeIterator.next().getType(); rexNodes.add(rexBuilder.makeInputRef(type, index++)); RelNode unionAggr = relBuilder.union(true, aggr.getGroupSets().size()).build();
try { hiveUDF = SqlFunctionConverter.getHiveUDF(call.getOperator(), call.getType(), call.operands.size()); if (hiveUDF != null && !FunctionRegistry.isConsistentWithinQuery(hiveUDF)) { RexNode n = operand.accept(this); if (n != null) { args.add(n); return args.get(0); } else { return cluster.getRexBuilder().makeCall(call.getOperator(), args);