final String expression; if (arg.isDirectColumnAccess()) { fieldName = arg.getDirectColumn(); expression = null; } else { fieldName = null; expression = arg.getExpression();
return DruidExpression.fromColumn(columnName); } else if (rexNode instanceof RexCall) { final SqlOperator operator = ((RexCall) rexNode).getOperator(); 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()) { return DruidExpression.fromExpression(DruidExpression.numberLiteral(milliseconds)); } else if (SqlTypeFamily.INTERVAL_YEAR_MONTH == sqlTypeName.getFamily()) { 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( Calcites.calciteDateTimeLiteralToJoda(rexNode, plannerContext.getTimeZone()).getMillis() return DruidExpression.fromExpression(DruidExpression.numberLiteral(RexLiteral.booleanValue(rexNode) ? 1 : 0)); } else {
inputExpressions -> { final DruidExpression arg = inputExpressions.get(0); final Expr patternExpr = inputExpressions.get(1).parse(plannerContext.getExprMacroTable()); final Expr indexExpr = inputExpressions.size() > 2 ? inputExpressions.get(2).parse(plannerContext.getExprMacroTable()) : null; if (arg.isSimpleExtraction() && patternExpr.isLiteral() && (indexExpr == null || indexExpr.isLiteral())) { return arg.getSimpleExtraction().cascade( new RegexDimExtractionFn( (String) patternExpr.getLiteralValue(),
public static String stringLiteral(final String s) { return s == null ? nullLiteral() : "'" + escape(s) + "'"; }
public static DruidExpression applyTimeExtract( final DruidExpression timeExpression, final TimestampExtractExprMacro.Unit unit, final DateTimeZone timeZone ) { return DruidExpression.fromFunctionCall( "timestamp_extract", ImmutableList.of( timeExpression, DruidExpression.fromExpression(DruidExpression.stringLiteral(unit.name())), DruidExpression.fromExpression(DruidExpression.stringLiteral(timeZone.getID())) ) ); }
public List<VirtualColumn> getVirtualColumns(final ExprMacroTable macroTable) { if (expression.isSimpleExtraction()) { return ImmutableList.of(); } else { return ImmutableList.of(expression.toVirtualColumn(getVirtualColumnName(), outputType, macroTable)); } }
final String aggregatorName = finalizeAggregations ? Calcites.makePrefixedName(name, "a") : name; if (arg.isDirectColumnAccess() && rowSignature.getColumnType(arg.getDirectColumn()) == ValueType.COMPLEX) { aggregatorFactory = new HyperUniquesAggregatorFactory(aggregatorName, arg.getDirectColumn(), false, true); } else { final SqlTypeName sqlTypeName = rexNode.getType().getSqlTypeName(); if (arg.isSimpleExtraction()) { dimensionSpec = arg.getSimpleExtraction().toDimensionSpec(null, inputType); } else { final ExpressionVirtualColumn virtualColumn = arg.toVirtualColumn( Calcites.makePrefixedName(name, "v"), inputType,
inputMatches = input.isDirectColumnAccess() && input.getDirectColumn().equals(theFactory.getFieldName()); } else { inputMatches = ((ExpressionVirtualColumn) virtualInput).getExpression() .equals(input.getExpression()); if (input.isDirectColumnAccess()) { if (rowSignature.getColumnType(input.getDirectColumn()) == ValueType.COMPLEX) { aggregatorFactory = new ApproximateHistogramFoldingAggregatorFactory( histogramName, input.getDirectColumn(), resolution, numBuckets, aggregatorFactory = new ApproximateHistogramAggregatorFactory( histogramName, input.getDirectColumn(), resolution, numBuckets, final ExpressionVirtualColumn virtualColumn = input.toVirtualColumn( StringUtils.format("%s:v", name), ValueType.FLOAT,
private static DruidExpression toDruidExpressionForSimpleAggregator( final PlannerContext plannerContext, final RowSignature rowSignature, final RexNode rexNode ) { final DruidExpression druidExpression = Expressions.toDruidExpression(plannerContext, rowSignature, rexNode); if (druidExpression == null) { return null; } if (druidExpression.isSimpleExtraction() && (!druidExpression.isDirectColumnAccess() || rowSignature.getColumnType(druidExpression.getDirectColumn()) == ValueType.STRING)) { // Aggregators are unable to implicitly cast strings to numbers. So remove the simple extraction in this case. return druidExpression.map(simpleExtraction -> null, Function.identity()); } else { return druidExpression; } } }
} else if (call.getOperands().size() == 1) { return druidExpression.map( simpleExtraction -> null, expression -> StringUtils.format("ceil(%s)", expression) return DruidExpression.fromFunctionCall( "timestamp_ceil", Stream .of( druidExpression.getExpression(), DruidExpression.stringLiteral(granularity.getPeriod().toString()), DruidExpression.numberLiteral( granularity.getOrigin() == null ? null : granularity.getOrigin().getMillis() ), DruidExpression.stringLiteral(granularity.getTimeZone().toString())
return DruidExpression.fromExpression( DruidExpression.functionCall( "timestamp_shift", timeExpr, shiftExpr.map( simpleExtraction -> null, expression -> StringUtils.format("concat('P', %s, 'M')", expression) ), DruidExpression.fromExpression(DruidExpression.numberLiteral(direction > 0 ? 1 : -1)) return DruidExpression.fromExpression( StringUtils.format( "(%s %s %s)", timeExpr.getExpression(), direction > 0 ? "+" : "-", shiftExpr.getExpression()
@Nullable public static TimestampFloorExprMacro.TimestampFloorExpr asTimestampFloorExpr( final DruidExpression expression, final ExprMacroTable macroTable ) { final Expr expr = Parser.parse(expression.getExpression(), macroTable); if (expr instanceof TimestampFloorExprMacro.TimestampFloorExpr) { return (TimestampFloorExprMacro.TimestampFloorExpr) expr; } else { return null; } }
public DimensionSpec toDimensionSpec() { if (expression.isSimpleExtraction()) { return expression.getSimpleExtraction().toDimensionSpec(outputName, outputType); } else { return new DefaultDimensionSpec(getVirtualColumnName(), getOutputName(), outputType); } }
@Override public DruidExpression toDruidExpression( final PlannerContext plannerContext, final RowSignature rowSignature, final RexNode rexNode ) { return OperatorConversions.convertCall( plannerContext, rowSignature, rexNode, operands -> DruidExpression.fromExpression( StringUtils.format( "%s(%s)", druidOperator, Iterables.getOnlyElement(operands).getExpression() ) ) ); } }
@Override public DruidExpression toDruidExpression( final PlannerContext plannerContext, final RowSignature rowSignature, final RexNode rexNode ) { return OperatorConversions.convertCall( plannerContext, rowSignature, rexNode, druidExpressions -> DruidExpression.of( null, DruidExpression.functionCall("concat", druidExpressions) ) ); } }
private static DruidExpression castCharToDateTime( final PlannerContext plannerContext, final DruidExpression operand, final SqlTypeName toType ) { // Cast strings to datetimes by parsing them from SQL format. final DruidExpression timestampExpression = DruidExpression.fromFunctionCall( "timestamp_parse", ImmutableList.of( operand, DruidExpression.fromExpression(DruidExpression.nullLiteral()), DruidExpression.fromExpression(DruidExpression.stringLiteral(plannerContext.getTimeZone().getID())) ) ); if (toType == SqlTypeName.DATE) { return TimeFloorOperatorConversion.applyTimestampFloor( timestampExpression, new PeriodGranularity(Period.days(1), null, plannerContext.getTimeZone()), plannerContext.getExprMacroTable() ); } else if (toType == SqlTypeName.TIMESTAMP) { return timestampExpression; } else { throw new ISE("Unsupported DateTime type[%s]", toType); } }
if (expression.isDirectColumnAccess()) { directColumns.add(expression.getDirectColumn()); rowOrder.add(expression.getDirectColumn()); } else { final String virtualColumnName = virtualColumnPrefix + virtualColumnNameCounter++; virtualColumns.add( expression.toVirtualColumn( virtualColumnName, Calcites.getValueTypeForSqlTypeName(project.getChildExps().get(i).getType().getSqlTypeName()),
final DruidExpression arg = inputExpressions.get(0); final Expr digitsExpr = inputExpressions.size() > 1 ? inputExpressions.get(1).parse(plannerContext.getExprMacroTable()) : null; final int digits = ((Number) digitsExpr.getLiteralValue()).intValue(); final double factor = Math.pow(10, digits); factorString = DruidExpression.numberLiteral(factor); } else { factorString = StringUtils.format("pow(10,%s)", inputExpressions.get(1)); return DruidExpression.fromExpression( StringUtils.format( "(cast(cast(%s * %s,'long'),'double') / %s)", arg.getExpression(), factorString, factorString
final DruidExpression arg = inputExpressions.get(1); final Expr truncTypeExpr = Parser.parse( inputExpressions.get(0).getExpression(), plannerContext.getExprMacroTable() ); return DruidExpression.fromFunctionCall( "timestamp_floor", ImmutableList.of( arg, DruidExpression.fromExpression(DruidExpression.stringLiteral(truncPeriod.toString())), DruidExpression.fromExpression(DruidExpression.stringLiteral(null)), DruidExpression.fromExpression(DruidExpression.stringLiteral(plannerContext.getTimeZone().getID()))
@Override public DruidExpression toDruidExpression( final PlannerContext plannerContext, final RowSignature rowSignature, final RexNode rexNode ) { return OperatorConversions.convertCall( plannerContext, rowSignature, rexNode, operands -> { if (operands.size() < 2) { throw new ISE("WTF?! Got binary operator[%s] with %s args?", operator.getName(), operands.size()); } return DruidExpression.fromExpression( StringUtils.format( "(%s)", joiner.join( operands.stream() .map(DruidExpression::getExpression) .collect(Collectors.toList()) ) ) ); } ); } }