@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()); }
@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); }
@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())); } }
@Override protected final ExprEval eval(ExprEval x, ExprEval y) { if (x.type() == ExprType.STRING || y.type() == ExprType.STRING) { return ExprEval.of(null); } if (x.type() == ExprType.LONG && y.type() == ExprType.LONG) { return eval(x.asLong(), y.asLong()); } else { return eval(x.asDouble(), y.asDouble()); } }
literal = rexBuilder.makeLiteral(exprResult.asBoolean(), constExp.getType(), true); } else if (sqlTypeName == SqlTypeName.DATE) { if (!constExp.getType().isNullable() && exprResult.isNumericNull()) { throw new IAE("Illegal DATE constant: %s", constExp); DateTimes.utc(exprResult.asLong()), plannerContext.getTimeZone() if (!constExp.getType().isNullable() && exprResult.isNumericNull()) { throw new IAE("Illegal TIMESTAMP constant: %s", constExp); DateTimes.utc(exprResult.asLong()), plannerContext.getTimeZone() ), final BigDecimal bigDecimal; if (exprResult.type() == ExprType.LONG) { bigDecimal = BigDecimal.valueOf(exprResult.asLong()); } else { bigDecimal = BigDecimal.valueOf(exprResult.asDouble()); literal = rexBuilder.makeLiteral(exprResult.value(), constExp.getType(), true);
public ConstantExprEvalSelector(final ExprEval eval) { this.eval = Preconditions.checkNotNull(eval, "eval"); if (NullHandling.sqlCompatible() && eval.isNumericNull()) { longValue = 0L; floatValue = 0f; doubleValue = 0d; isNull = true; } else { longValue = eval.asLong(); doubleValue = eval.asDouble(); floatValue = (float) doubleValue; isNull = false; } }
@Nonnull @Override public ExprEval eval(final ObjectBinding bindings) { ExprEval eval = arg.eval(bindings); if (eval.isNumericNull()) { // Return null if the argument if null. return ExprEval.of(null); } return ExprEval.of(granularity.bucketStart(DateTimes.utc(eval.asLong())).getMillis()); }
@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); } }
@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 ExprEval apply(List<Expr> args, Expr.ObjectBinding bindings) { if (args.size() != 3) { throw new IAE("Function[%s] needs 3 arguments", name()); } final String arg = args.get(0).eval(bindings).asString(); if (arg == null) { return ExprEval.of(null); } // Behaves like SubstringDimExtractionFn, not SQL SUBSTRING final int index = args.get(1).eval(bindings).asInt(); final int length = args.get(2).eval(bindings).asInt(); if (index < arg.length()) { if (length >= 0) { return ExprEval.of(arg.substring(index, Math.min(index + length, arg.length()))); } else { return ExprEval.of(arg.substring(index)); } } else { // If starting index of substring is greater then the length of string, the result will be a zero length string. // e.g. 'select substring("abc", 4,5) as c;' will return an empty string return ExprEval.of(NullHandling.defaultStringValue()); } } }
@Override public ExprEval apply(final List<Expr> args, final Expr.ObjectBinding bindings) { if (args.size() < 2) { throw new IAE("Function[%s] must have at least 2 arguments", name()); } for (int i = 0; i < args.size(); i += 2) { if (i == args.size() - 1) { // ELSE else_result. return args.get(i).eval(bindings); } else if (args.get(i).eval(bindings).asBoolean()) { // Matching WHEN boolean_expr THEN result return args.get(i + 1).eval(bindings); } } return ExprEval.of(null); } }
@Override public float getFloat() { // No Assert for null handling as ExprEval already have it. return (float) getObject().asDouble(); }
@Override public ExprEval apply(List<Expr> args, Expr.ObjectBinding bindings) { if (args.size() != 1) { throw new IAE("Function[%s] needs 1 argument", name()); } final String arg = args.get(0).eval(bindings).asString(); return arg == null ? ExprEval.ofLong(NullHandling.defaultLongValue()) : ExprEval.of(arg.length()); } }
@Override public boolean isNull() { // It is possible for an expression to have a non-null String value but it can return null when parsed // as a primitive long/float/double. // ExprEval.isNumericNull checks whether the parsed primitive value is null or not. return eval().isNumericNull(); }
@Nonnull @Override public ExprEval eval(ObjectBinding bindings) { ExprEval leftVal = left.eval(bindings); return leftVal.asBoolean() ? leftVal : right.eval(bindings); } }
@Override public ExprEval apply(List<Expr> args, Expr.ObjectBinding bindings) { if (args.size() == 0) { return ExprEval.of(null); } else { // Pass first argument in to the constructor to provide StringBuilder a little extra sizing hint. String first = NullHandling.nullToEmptyIfNeeded(args.get(0).eval(bindings).asString()); if (first == null) { // Result of concatenation is null if any of the Values is null. // e.g. 'select CONCAT(null, "abc") as c;' will return null as per Standard SQL spec. return ExprEval.of(null); } final StringBuilder builder = new StringBuilder(first); for (int i = 1; i < args.size(); i++) { final String s = NullHandling.nullToEmptyIfNeeded(args.get(i).eval(bindings).asString()); if (s == null) { // Result of concatenation is null if any of the Values is null. // e.g. 'select CONCAT(null, "abc") as c;' will return null as per Standard SQL spec. return ExprEval.of(null); } else { builder.append(s); } } return ExprEval.of(builder.toString()); } } }