public List<RelDataType> getParameterTypes(RelDataTypeFactory typeFactory) { return ImmutableList.of( typeFactory.createTypeWithNullability( typeFactory.createSqlType(SqlTypeName.ANY), true)); }
private PlannerResult planExplanation( final RelNode rel, final SqlExplain explain, final Set<String> datasourceNames ) { final String explanation = RelOptUtil.dumpPlan("", rel, explain.getFormat(), explain.getDetailLevel()); final Supplier<Sequence<Object[]>> resultsSupplier = Suppliers.ofInstance( Sequences.simple(ImmutableList.of(new Object[]{explanation}))); final RelDataTypeFactory typeFactory = rel.getCluster().getTypeFactory(); return new PlannerResult( resultsSupplier, typeFactory.createStructType( ImmutableList.of(Calcites.createSqlType(typeFactory, SqlTypeName.VARCHAR)), ImmutableList.of("PLAN") ), datasourceNames ); } }
@Override public RelDataType deriveRowType() { final List<RelDataTypeField> fieldList = table.getRowType().getFieldList(); final RelDataTypeFactory.FieldInfoBuilder builder = getCluster().getTypeFactory().builder(); for (int field : fields) { builder.add(fieldList.get(field)); } return getCluster().getTypeFactory().createStructType(builder); }
public RelDataType getReturnType(RelDataTypeFactory typeFactory) { return typeFactory.createTypeWithNullability( typeFactory.createSqlType(SqlTypeName.ANY), true); }
private RexNode makeCast(SqlTypeName typeName, final RexNode child) { RelDataType sqlType = cluster.getTypeFactory().createSqlType(typeName); RelDataType nullableType = cluster.getTypeFactory().createTypeWithNullability(sqlType, true); return cluster.getRexBuilder().makeCast(nullableType, child); }
@Override public List<RelProtoDataType> getParams() { return ImmutableList.of( typeFactory -> typeFactory.createArrayType( typeFactory.createSqlType(SqlTypeName.INTEGER), -1), typeFactory -> typeFactory.createSqlType(SqlTypeName.INTEGER)); } }
int nFields = left.getRowType().getFieldCount(); ImmutableBitSet allCols = ImmutableBitSet.range(nFields); ImmutableList.of( Pair.<RexNode, String>of(rexBuilder.makeLiteral(true), "nullIndicator"))); int nullIndicatorPos = join.getRowType().getFieldCount() - 1; cluster.getTypeFactory().createTypeWithNullability( join.getRowType().getFieldList() .get(nullIndicatorPos).getType(), true)); joinOutputProjects.add( rexBuilder.makeInputRef( leftInputFieldType.getFieldList().get(i).getType(), i)); newAggOutputProjectList.add( rexBuilder.makeCast( cluster.getTypeFactory().createTypeWithNullability( newAggOutputProjects.getType(), true), newAggOutputProjects));
ImmutableList.of(rexBuilder.makeCast( cluster.getTypeFactory().createTypeWithNullability(projExprs.get(0).getType(), true), projExprs.get(0))), null, false, relBuilder);
@Test public void testTimeMinusDayTimeInterval() { final Period period = new Period("P1DT1H1M"); testExpression( rexBuilder.makeCall( typeFactory.createSqlType(SqlTypeName.TIMESTAMP), SqlStdOperatorTable.MINUS_DATE, ImmutableList.of( inputRef("t"), rexBuilder.makeIntervalLiteral( new BigDecimal(period.toStandardDuration().getMillis()), // DAY-TIME literals value is millis new SqlIntervalQualifier(TimeUnit.DAY, TimeUnit.MINUTE, SqlParserPos.ZERO) ) ) ), DruidExpression.of( null, "(\"t\" - 90060000)" ), 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 {
int rowIDPos = tableScan.getTable().getRowType().getField( VirtualColumn.ROWID.getName(), false, false).getIndex(); RexNode rowIDFieldAccess = rexBuilder.makeFieldAccess( rexBuilder.makeInputRef(tableScan.getTable().getRowType().getFieldList().get(rowIDPos).getType(), rowIDPos), 0); relBuilder.push(tableScan); List<RexNode> conds = new ArrayList<>(); RelDataType bigIntType = relBuilder.getTypeFactory().createSqlType(SqlTypeName.BIGINT); final RexNode literalHighWatermark = rexBuilder.makeLiteral( tableMaterializationTxnList.getHighWatermark(), bigIntType, false); conds.add( rexBuilder.makeCall( SqlStdOperatorTable.LESS_THAN_OR_EQUAL, ImmutableList.of(rowIDFieldAccess, literalHighWatermark))); for (long invalidTxn : tableMaterializationTxnList.getInvalidWriteIds()) { final RexNode literalInvalidTxn = rexBuilder.makeLiteral( rexBuilder.makeCall( SqlStdOperatorTable.NOT_EQUALS, ImmutableList.of(rowIDFieldAccess, literalInvalidTxn)));
final RexBuilder rexBuilder = cluster.getRexBuilder(); final RelDataTypeFactory typeFactory = cluster.getTypeFactory(); final RelDataType argOrdinalType = getFieldType(oldAggRel.getInput(), argOrdinal); final RelDataType oldCallType = typeFactory.createTypeWithNullability(oldCall.getType(), true); oldCall.isDistinct(), ReturnTypes.explicit(sumSquaredReturnType), InferTypes.explicit(Collections.singletonList(argSquared.getType())), newCalls, aggCallMapping, ImmutableList.of(sumArgSquaredAggCall.getType())); newCalls, aggCallMapping, ImmutableList.of(sumArgAggCall.getType())); SqlStdOperatorTable.MULTIPLY, sumArgCast, sumArgCast); RelDataType countRetType = typeFactory.createTypeWithNullability(typeFactory.createSqlType(SqlTypeName.BIGINT), true); final AggregateCall countArgAggCall = AggregateCall.create( newCalls, aggCallMapping, ImmutableList.of(argOrdinalType));
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);
@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" ); }
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 avgInputType = typeFactory.createTypeWithNullability( getFieldType(oldAggRel.getInput(), iAvgInput), true); final RelDataType sumReturnType = getSumReturnType( rexBuilder.getTypeFactory(), avgInputType, oldCall.getType()); final AggregateCall sumCall = AggregateCall.create( null, null); RelDataType countRetType = typeFactory.createTypeWithNullability( typeFactory.createSqlType(SqlTypeName.BIGINT), true); final AggregateCall countCall = AggregateCall.create(
final BlockBuilder builder = new BlockBuilder(); final JavaTypeFactoryImpl javaTypeFactory = new JavaTypeFactoryImpl(rexBuilder.getTypeFactory().getTypeSystem()); ImmutableList.of( Pair.<Expression, PhysType>of( Expressions.field(context,
final Permute left = new Permute(join.getLeft(), offset); final int fieldCount = getValidatedNodeType(join.getLeft()).getFieldList().size(); final Permute right = new Permute(join.getRight(), offset + fieldCount); final List<ImmutableIntList> sources = new ArrayList<>(); final Set<ImmutableIntList> sourceSet = new HashSet<>(); final RelDataTypeFactory.Builder b = typeFactory.builder(); if (names != null) { for (String name : names) { final RelDataTypeField f = left.field(name); final ImmutableIntList source = left.sources.get(f.getIndex()); sourceSet.add(source); final RelDataTypeField f2 = right.field(name); final ImmutableIntList source2 = right.sources.get(f2.getIndex()); sourceSet.add(source2); sources.add(source.appendAll(source2)); final boolean nullable = (f.getType().isNullable() || join.getJoinType().generatesNullsOnLeft()) && (f2.getType().isNullable() || join.getJoinType().generatesNullsOnRight()); b.add(f).nullable(nullable); this.sources = ImmutableList.copyOf(sources); this.trivial = left.trivial && right.trivial
final List<SqlNode> oldSelectItems = ImmutableList.copyOf(selectItems); selectItems.clear(); final List<Map.Entry<String, RelDataType>> oldFields = ImmutableList.copyOf(fields); fields.clear(); for (ImmutableIntList source : sources) { final RelDataType type1 = field1.getValue(); final boolean nullable = type.isNullable() && type1.isNullable(); final RelDataType type2 = SqlTypeUtil.leastRestrictiveForComparison(typeFactory, type, maybeCast(selectItem1, type1, type2)), new SqlIdentifier(name, SqlParserPos.ZERO)); type = typeFactory.createTypeWithNullability(type2, nullable);
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));
ASTNode cond = where.getCondition().accept(new RexVisitor(schema)); hiveAST.where = ASTBuilder.where(cond); for (int pos : hiveAgg.getAggregateColumnsOrder()) { RexInputRef iRef = new RexInputRef(groupBy.getGroupSet().nth(pos), groupBy.getCluster().getTypeFactory().createSqlType(SqlTypeName.ANY)); b.add(iRef.accept(new RexVisitor(schema))); if (!hiveAgg.getAggregateColumnsOrder().contains(pos)) { RexInputRef iRef = new RexInputRef(groupBy.getGroupSet().nth(pos), groupBy.getCluster().getTypeFactory().createSqlType(SqlTypeName.ANY)); b.add(iRef.accept(new RexVisitor(schema))); HiveParser.TOK_GROUPING_SETS_EXPRESSION, "TOK_GROUPING_SETS_EXPRESSION"); for (int i : groupSet) { RexInputRef iRef = new RexInputRef(i, groupBy.getCluster().getTypeFactory() .createSqlType(SqlTypeName.ANY)); expression.add(iRef.accept(new RexVisitor(schema))); ASTNode cond = having.getCondition().accept(new RexVisitor(schema)); hiveAST.having = ASTBuilder.having(cond); int i = 0; r = select.getCluster().getRexBuilder().makeAbstractCast(r.getType(), r); r = select.getCluster().getRexBuilder().makeAbstractCast(r.getType(), r);