@Nullable @Override public Object getObject() { // No need for null check on getObject() since baseSelector impls will never return null. //noinspection ConstantConditions return baseSelector.getObject().value(); }
@Override public Object eval(final Row row) { return expr.eval(name -> getValueFromRow(row, name)).value(); } }
@Override public Object compute(Map<String, Object> values) { // Maps.transformEntries is lazy, will only finalize values we actually read. final Map<String, Object> finalizedValues = Maps.transformEntries( values, (String k, Object v) -> { final Function<Object, Object> finalizer = finalizers.get(k); return finalizer != null ? finalizer.apply(v) : v; } ); return parsed.eval(Parser.withMap(finalizedValues)).value(); }
@Override public ExprEval apply(List<Expr> args, Expr.ObjectBinding bindings) { if (args.size() != 2) { throw new IAE("Function[%s] needs 2 arguments", name()); } final ExprEval eval = args.get(0).eval(bindings); return eval.value() == null ? args.get(1).eval(bindings) : eval; } }
@Override public ExprEval apply(List<Expr> args, Expr.ObjectBinding bindings) { if (args.size() != 1) { throw new IAE("Function[%s] needs 1 argument", name()); } final ExprEval expr = args.get(0).eval(bindings); return ExprEval.of(expr.value() != null, ExprType.LONG); } }
@Override public ExprEval apply(List<Expr> args, Expr.ObjectBinding bindings) { if (args.size() != 1) { throw new IAE("Function[%s] needs 1 argument", name()); } final ExprEval expr = args.get(0).eval(bindings); return ExprEval.of(expr.value() == null, ExprType.LONG); } }
if (chars.length == 0 || stringEval.value() == null) { return stringEval;
@Nonnull @Override public ExprEval eval(ObjectBinding bindings) { ExprEval ret = expr.eval(bindings); if (NullHandling.sqlCompatible() && (ret.value() == null)) { return ExprEval.of(null); } // conforming to other boolean-returning binary operators ExprType retType = ret.type() == ExprType.DOUBLE ? ExprType.DOUBLE : ExprType.LONG; return ExprEval.of(!ret.asBoolean(), retType); }
} else { Chronology chronology = timeZone == null ? ISOChronology.getInstanceUTC() : ISOChronology.getInstance(timeZone); final Object value = originArg.eval(bindings).value(); if (value instanceof String && NullHandling.isNullOrEquivalent((String) value)) {
private void assertExpr(final String expression, final Object expectedResult) { final Expr expr = Parser.parse(expression, LookupEnabledTestExprMacroTable.INSTANCE); Assert.assertEquals(expression, expectedResult, expr.eval(BINDINGS).value()); } }
private void validateConstantExpression(String expression, Object expected) { Assert.assertEquals( expression, expected, Parser.parse(expression, ExprMacroTable.nil()).eval(Parser.withMap(ImmutableMap.of())).value() ); } }
@Nonnull @Override public ExprEval eval(ObjectBinding bindings) { ExprEval ret = expr.eval(bindings); if (NullHandling.sqlCompatible() && (ret.value() == null)) { return ExprEval.of(null); } if (ret.type() == ExprType.LONG) { return ExprEval.of(-ret.asLong()); } if (ret.type() == ExprType.DOUBLE) { return ExprEval.of(-ret.asDouble()); } throw new IAE("unsupported type " + ret.type()); }
private void assertExpr(final String expression, final Object expectedResult) { final Expr expr = Parser.parse(expression, ExprMacroTable.nil()); Assert.assertEquals(expression, expectedResult, expr.eval(bindings).value()); }
@Override protected ExprEval eval(ExprEval x, ExprEval y) { if (NullHandling.sqlCompatible() && x.value() == null) { return ExprEval.of(null); } ExprType castTo; try { castTo = ExprType.valueOf(StringUtils.toUpperCase(y.asString())); } catch (IllegalArgumentException e) { throw new IAE("invalid type '%s'", y.asString()); } return x.castTo(castTo); } }
@Nonnull @Override public ExprEval eval(ObjectBinding bindings) { ExprEval leftVal = left.eval(bindings); ExprEval rightVal = right.eval(bindings); // Result of any Binary expressions is null if any of the argument is null. // e.g "select null * 2 as c;" or "select null + 1 as c;" will return null as per Standard SQL spec. if (NullHandling.sqlCompatible() && (leftVal.value() == null || rightVal.value() == null)) { return ExprEval.of(null); } if (leftVal.type() == ExprType.STRING && rightVal.type() == ExprType.STRING) { return evalString(leftVal.asString(), rightVal.asString()); } else if (leftVal.type() == ExprType.LONG && rightVal.type() == ExprType.LONG) { if (NullHandling.sqlCompatible() && (leftVal.isNumericNull() || rightVal.isNumericNull())) { return ExprEval.of(null); } return ExprEval.of(evalLong(leftVal.asLong(), rightVal.asLong())); } else { if (NullHandling.sqlCompatible() && (leftVal.isNumericNull() || rightVal.isNumericNull())) { return ExprEval.of(null); } return ExprEval.of(evalDouble(leftVal.asDouble(), rightVal.asDouble())); } }
private void testExpression( final RexNode rexNode, final DruidExpression expectedExpression, final Object expectedResult ) { final DruidExpression expression = Expressions.toDruidExpression(plannerContext, rowSignature, rexNode); Assert.assertEquals("Expression for: " + rexNode, expectedExpression, expression); final ExprEval result = Parser.parse(expression.getExpression(), plannerContext.getExprMacroTable()) .eval(Parser.withMap(bindings)); Assert.assertEquals("Result for: " + rexNode, expectedResult, result.value()); } }
literal = rexBuilder.makeLiteral(exprResult.value(), constExp.getType(), true);
@Override public ExprEval apply(List<Expr> args, Expr.ObjectBinding bindings) { if (args.size() != 1) { throw new IAE("Function[%s] needs 1 argument", name()); } final ExprEval expr = args.get(0).eval(bindings); return ExprEval.of(expr.value() == null, ExprType.LONG); } }
@Override public ExprEval apply(List<Expr> args, Expr.ObjectBinding bindings) { if (args.size() != 1) { throw new IAE("Function[%s] needs 1 argument", name()); } final ExprEval expr = args.get(0).eval(bindings); return ExprEval.of(expr.value() != null, ExprType.LONG); } }