private CaseTupleExpression getCaseTupleExpression(RexCall call) { List<Pair<TupleFilter, TupleExpression>> whenList = Lists .newArrayListWithExpectedSize(call.operands.size() / 2); TupleExpression elseExpr = null; for (int i = 0; i < call.operands.size() - 1; i += 2) { if (call.operands.get(i) instanceof RexCall) { RexCall whenCall = (RexCall) call.operands.get(i); CompareTupleFilter.CompareResultType compareResultType = RexUtil.getCompareResultType(whenCall); if (compareResultType == CompareTupleFilter.CompareResultType.AlwaysTrue) { elseExpr = call.operands.get(i + 1).accept(this); break; } else if (compareResultType == CompareTupleFilter.CompareResultType.AlwaysFalse) { continue; TupleFilter whenFilter = whenCall.accept(filterVistor); whenFilter = new FilterOptimizeTransformer().transform(whenFilter); TupleExpression thenExpr = call.operands.get(i + 1).accept(this); whenList.add(new Pair<>(whenFilter, thenExpr)); if (elseExpr == null && call.operands.size() % 2 == 1) { RexNode elseNode = call.operands.get(call.operands.size() - 1); if (!(elseNode instanceof RexLiteral && ((RexLiteral) elseNode).getValue() == null)) { elseExpr = elseNode.accept(this); tuple.setDigest(call.toString()); return tuple;
private TupleFilter dealWithTrivialExpr(RexCall call) { ImmutableList<RexNode> operators = call.operands; if (operators.size() != 2) { return null; if (temp.getType().getFamily() != SqlTypeFamily.NUMERIC || !(temp.getValue() instanceof BigDecimal)) { return null;// only numeric constants now left = (BigDecimal) temp.getValue(); } else { right = (BigDecimal) temp.getValue();
RexLiteral pattern = null, escape = null; String patternStr = null, escapeStr = null; if (condition.getOperands().size() == 2) { if (pattern.getTypeName() == SqlTypeName.DECIMAL || pattern.getTypeName() == SqlTypeName.INTEGER) { patternStr = pattern.getValue().toString(); } else if (pattern.getTypeName() == SqlTypeName.CHAR) { patternStr = pattern.getValue2().toString(); if (op.getKind() == SqlKind.LITERAL) { if (pattern.getTypeName() == SqlTypeName.DECIMAL || pattern.getTypeName() == SqlTypeName.INTEGER) { patternStr = pattern.getValue().toString(); } else if (pattern.getTypeName() == SqlTypeName.CHAR) { patternStr = pattern.getValue2().toString(); if (escape.getTypeName() == SqlTypeName.DECIMAL || escape.getTypeName() == SqlTypeName.INTEGER) { escapeStr = escape.getValue().toString(); } else if (escape.getTypeName() == SqlTypeName.CHAR) { escapeStr = escape.getValue2().toString(); return builder.makeCall(SqlStdOperatorTable.EQUALS, arg, pattern);
BigDecimal maxVal = new BigDecimal(max.floatValue()); BigDecimal minVal = new BigDecimal(min.floatValue()); RexLiteral maxLiteral = rexBuilder.makeExactLiteral(maxVal, literal.getType()); RexLiteral minLiteral = rexBuilder.makeExactLiteral(minVal, literal.getType()); if (minLiteral.getValue().compareTo(literal.getValue()) > 0 || maxLiteral.getValue().compareTo(literal.getValue()) < 0) { return rexBuilder.makeLiteral(false); if (minLiteral.getValue().compareTo(literal.getValue()) > 0) { return rexBuilder.makeLiteral(true); } else if (maxLiteral.getValue().compareTo(literal.getValue()) <= 0) { return rexBuilder.makeLiteral(false); if (minLiteral.getValue().compareTo(literal.getValue()) >= 0) { return rexBuilder.makeLiteral(true); } else if (maxLiteral.getValue().compareTo(literal.getValue()) < 0) { return rexBuilder.makeLiteral(false); if (minLiteral.getValue().compareTo(literal.getValue()) >= 0) { return rexBuilder.makeLiteral(false); } else if (maxLiteral.getValue().compareTo(literal.getValue()) < 0) { return rexBuilder.makeLiteral(true); if (minLiteral.getValue().compareTo(literal.getValue()) > 0) { return rexBuilder.makeLiteral(false); } else if (maxLiteral.getValue().compareTo(literal.getValue()) <= 0) { return rexBuilder.makeLiteral(true);
@Override public DruidExpression toDruidExpression( final PlannerContext plannerContext, final RowSignature rowSignature, final RexNode rexNode ) { final RexCall call = (RexCall) rexNode; final RexNode timeArg = call.getOperands().get(0); final DruidExpression timeExpression = Expressions.toDruidExpression(plannerContext, rowSignature, timeArg); if (timeExpression == null) { return null; } final TimestampExtractExprMacro.Unit unit = TimestampExtractExprMacro.Unit.valueOf( StringUtils.toUpperCase(RexLiteral.stringValue(call.getOperands().get(1))) ); final DateTimeZone timeZone = call.getOperands().size() > 2 && !RexLiteral.isNullLiteral(call.getOperands().get(2)) ? DateTimes.inferTzFromString(RexLiteral.stringValue(call.getOperands().get(2))) : plannerContext.getTimeZone(); return applyTimeExtract(timeExpression, unit, timeZone); } }
final RexNode timeArg = call.getOperands().get(0); final DruidExpression timeExpression = Expressions.toDruidExpression(plannerContext, rowSignature, timeArg); if (timeExpression == null) { final String pattern = call.getOperands().size() > 1 && !RexLiteral.isNullLiteral(call.getOperands().get(1)) ? RexLiteral.stringValue(call.getOperands().get(1)) : "yyyy-MM-dd'T'HH:mm:ss.SSSZZ"; final DateTimeZone timeZone = call.getOperands().size() > 2 && !RexLiteral.isNullLiteral(call.getOperands().get(2)) ? DateTimes.inferTzFromString(RexLiteral.stringValue(call.getOperands().get(2))) : plannerContext.getTimeZone(); ImmutableList.of( timeExpression.getExpression(), DruidExpression.stringLiteral(pattern), DruidExpression.stringLiteral(timeZone.getID()) ).stream().map(DruidExpression::fromExpression).collect(Collectors.toList()) );
private RexNode simplifyCast(RexCall e) { final RexNode operand = e.getOperands().get(0); switch (operand.getKind()) { case LITERAL: final RexLiteral literal = (RexLiteral) operand; final Comparable value = literal.getValueAs(Comparable.class); final SqlTypeName typeName = literal.getTypeName(); if (rexBuilder.canRemoveCastFromLiteral(e.getType(), value, typeName)) { return rexBuilder.makeCast(e.getType(), operand); switch (literal.getTypeName()) { case TIME: switch (e.getType().getSqlTypeName()) { case TIMESTAMP: return e; executor.reduce(rexBuilder, ImmutableList.of(e), reducedValues); return Objects.requireNonNull( Iterables.getOnlyElement(reducedValues)); default: if (operand.getType().equals(e.getType())) { return simplify(operand, UNKNOWN);
public List<Double> averageColumnSizes(Values rel, RelMetadataQuery mq) { final List<RelDataTypeField> fields = rel.getRowType().getFieldList(); final ImmutableList.Builder<Double> list = ImmutableList.builder(); for (int i = 0; i < fields.size(); i++) { RelDataTypeField field = fields.get(i); double d; if (rel.getTuples().isEmpty()) { d = averageTypeValueSize(field.getType()); } else { d = 0; for (ImmutableList<RexLiteral> literals : rel.getTuples()) { d += typeValueSize(field.getType(), literals.get(i).getValueAs(Comparable.class)); } d /= rel.getTuples().size(); } list.add(d); } return list.build(); }
newCasts.add(rexBuilder.makeInputRef(project.getChildExps().get(fieldNumber).getType(), fieldNumber)); final boolean flip = RexLiteral.isNullLiteral(caseCall.getOperands().get(1)) && !RexLiteral.isNullLiteral(caseCall.getOperands().get(2)); final RexNode arg1 = caseCall.getOperands().get(flip ? 2 : 1); if (aggregateCall.getAggregation().getKind() == SqlKind.COUNT && RexLiteral.isNullLiteral(arg2)) { newProjects.add(arg1); newProjects.add(filter); && arg1.isA(SqlKind.LITERAL) && !RexLiteral.isNullLiteral(arg1) && RexLiteral.isNullLiteral(arg2)) { ); } else if (aggregateCall.getAggregation().getKind() == SqlKind.SUM && Calcites.isIntLiteral(arg1) && RexLiteral.intValue(arg1) == 1 && Calcites.isIntLiteral(arg2) && RexLiteral.intValue(arg2) == 0) { aggregateCall.getName() ); } else if (RexLiteral.isNullLiteral(arg2) /* Case A1 */ || (aggregateCall.getAggregation().getKind() == SqlKind.SUM && Calcites.isIntLiteral(arg2) && RexLiteral.intValue(arg2) == 0) /* Case A2 */) { newProjects.add(arg1); newProjects.add(filter);
final Sort sort = call.rel(1); final int count = sort.getInput().getRowType().getFieldCount(); if (count == 1) { Map<RexNode, RexNode> constants = new HashMap<>(); for (int i = 0; i < count ; i++) { RexNode expr = rexBuilder.makeInputRef(sort.getInput(), i); if (conditionsExtracted.containsKey(expr)) { constants.put(expr, conditionsExtracted.get(expr)); topChildExprs = ImmutableList.copyOf(RexUtil.apply(mapping, topChildExprs)); final ImmutableList<RexNode> sortFields = relBuilder.fields(RelCollations.of(fieldCollations)); relBuilder.sortLimit(sort.offset == null ? -1 : RexLiteral.intValue(sort.offset), sort.fetch == null ? -1 : RexLiteral.intValue(sort.fetch), sortFields);
@Test public void testConstant() throws Exception { check((rexBuilder, executor) -> { final List<RexNode> reducedValues = new ArrayList<>(); final RexLiteral ten = rexBuilder.makeExactLiteral(BigDecimal.TEN); executor.reduce(rexBuilder, ImmutableList.of(ten), reducedValues); assertThat(reducedValues.size(), equalTo(1)); assertThat(reducedValues.get(0), instanceOf(RexLiteral.class)); assertThat(((RexLiteral) reducedValues.get(0)).getValue2(), equalTo((Object) 10L)); }); }
@Override public RelDataType get(int index) { return index < childFieldCount ? childRowType.getFieldList().get(index).getType() : constants.get(index - childFieldCount).getType(); }
Operator<?> inputOp = inputOpAf.inputs.get(0); Operator<?> resultOp = inputOpAf.inputs.get(0); int limit = RexLiteral.intValue(sortRel.fetch); int offset = sortRel.offset == null ? 0 : RexLiteral.intValue(sortRel.offset); LimitDesc limitDesc = new LimitDesc(offset,limit); ArrayList<ColumnInfo> cinfoLst = createColInfos(resultOp);
return null; RelDataTypeField field = rowType.getFieldList().get(iField); RelDataType type = field.getType(); if (type.isStruct()) { assert literalExpr.isA(SqlKind.CAST); RexNode child = ((RexCall) literalExpr).getOperands().get(0); assert RexLiteral.isNullLiteral(child); Comparable value = literal.getValue(); NumberUtil.rescaleBigDecimal( (BigDecimal) value, type.getScale()); return rexBuilder.makeExactLiteral( roundedValue, type); return rexBuilder.makeCharLiteral( new NlsString( Spaces.padRight(unpadded.getValue(), type.getPrecision()),
@Override public ExprNodeDesc visitLiteral(RexLiteral literal) { RelDataType lType = literal.getType(); if (RexLiteral.value(literal) == null) { switch (literal.getType().getSqlTypeName()) { case BOOLEAN: return new ExprNodeConstantDesc(TypeInfoFactory.booleanTypeInfo, null); switch (literal.getType().getSqlTypeName()) { case BOOLEAN: return new ExprNodeConstantDesc(TypeInfoFactory.booleanTypeInfo, Boolean.valueOf(RexLiteral .booleanValue(literal))); case TINYINT: return new ExprNodeConstantDesc(TypeInfoFactory.byteTypeInfo, Byte.valueOf(((Number) literal .getValue3()).byteValue())); case SMALLINT: return new ExprNodeConstantDesc(TypeInfoFactory.shortTypeInfo, Short.valueOf(((Number) literal.getValue3()).shortValue())); case INTEGER: return new ExprNodeConstantDesc(TypeInfoFactory.intTypeInfo, Integer.valueOf(((Number) literal.getValue3()).intValue())); case BIGINT: return new ExprNodeConstantDesc(TypeInfoFactory.longTypeInfo, Long.valueOf(((Number) literal .getValue3()).longValue())); case FLOAT: case REAL: return new ExprNodeConstantDesc(TypeInfoFactory.floatTypeInfo, Float.valueOf(((Number) literal.getValue3()).floatValue())); case DOUBLE:
final SqlKind kind = rexNode.getKind(); final SqlTypeName sqlTypeName = rexNode.getType().getSqlTypeName(); final SqlOperator operator = ((RexCall) rexNode).getOperator(); if (RexLiteral.isNullLiteral(rexNode)) { return DruidExpression.fromExpression(DruidExpression.nullLiteral()); } else if (SqlTypeName.NUMERIC_TYPES.contains(sqlTypeName)) { return DruidExpression.fromExpression(DruidExpression.numberLiteral((Number) RexLiteral.value(rexNode))); } else if (SqlTypeFamily.INTERVAL_DAY_TIME == sqlTypeName.getFamily()) { final long milliseconds = ((Number) RexLiteral.value(rexNode)).longValue(); return DruidExpression.fromExpression(DruidExpression.numberLiteral(milliseconds)); } else if (SqlTypeFamily.INTERVAL_YEAR_MONTH == sqlTypeName.getFamily()) { final long months = ((Number) RexLiteral.value(rexNode)).longValue(); return DruidExpression.fromExpression(DruidExpression.numberLiteral(months)); } else if (SqlTypeName.STRING_TYPES.contains(sqlTypeName)) { return DruidExpression.fromExpression(DruidExpression.stringLiteral(RexLiteral.stringValue(rexNode))); } else if (SqlTypeName.TIMESTAMP == sqlTypeName || SqlTypeName.DATE == sqlTypeName) { if (RexLiteral.isNullLiteral(rexNode)) { return DruidExpression.fromExpression(DruidExpression.nullLiteral()); } else { return DruidExpression.fromExpression(DruidExpression.numberLiteral(RexLiteral.booleanValue(rexNode) ? 1 : 0)); } else {
public Double averageRexSize(RexNode node, List<Double> inputColumnSizes) { switch (node.getKind()) { case INPUT_REF: return inputColumnSizes.get(((RexInputRef) node).getIndex()); case LITERAL: return typeValueSize(node.getType(), ((RexLiteral) node).getValueAs(Comparable.class)); default: if (node instanceof RexCall) { RexCall call = (RexCall) node; for (RexNode operand : call.getOperands()) { // It's a reasonable assumption that a function's result will have // similar size to its argument of a similar type. For example, // UPPER(c) has the same average size as c. if (operand.getType().getSqlTypeName() == node.getType().getSqlTypeName()) { return averageRexSize(operand, inputColumnSizes); } } } return averageTypeValueSize(node.getType()); } } }
Mapping m = Mappings.create(MappingType.PARTIAL_FUNCTION, child.getRowType().getFieldCount(), project.getRowType().getFieldCount()); int sIdx = ((RexInputRef) o.e).getIndex(); m.set(sIdx, o.i); inpIndxToOutIndxMap.put(sIdx, o.i); ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r); if (columnsMapped.contains(rCols)) { r = r.accept(new RexPermuteInputsShuttle(m, child)); projectPullUpPredicates.add(r); if (RexLiteral.isNullLiteral(expr.e)) { projectPullUpPredicates.add(rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, rexBuilder.makeInputRef(project, expr.i))); } else if (expr.e instanceof RexLiteral) { final RexLiteral literal = (RexLiteral) expr.e; projectPullUpPredicates.add(rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef(project, expr.i), literal)); } else if (expr.e instanceof RexCall && HiveCalciteUtil.isDeterministicFuncOnLiterals(expr.e)) {
/** Infers the alias of an expression. * * <p>If the expression was created by {@link #alias}, replaces the expression * in the project list. */ private String inferAlias(List<RexNode> exprList, RexNode expr) { switch (expr.getKind()) { case INPUT_REF: final RexInputRef ref = (RexInputRef) expr; return peek(0).getRowType().getFieldNames().get(ref.getIndex()); case CAST: return inferAlias(exprList, ((RexCall) expr).getOperands().get(0)); case AS: final RexCall call = (RexCall) expr; for (;;) { final int i = exprList.indexOf(expr); if (i < 0) { break; } exprList.set(i, call.getOperands().get(0)); } return ((NlsString) ((RexLiteral) call.getOperands().get(1)).getValue()) .getValue(); default: return null; } }