Examples with Expr org.apache.druid.math.expr.Expr used on opensource projects

Example 96 with Expr

use of org.apache.druid.math.expr.Expr in project druid by druid-io.

the class TrimExprMacro method apply.

@Override
public Expr apply(final List<Expr> args) {
    if (args.size() < 1 || args.size() > 2) {
        throw new IAE("Function[%s] must have 1 or 2 arguments", name());
    }
    final Function<Expr.Shuttle, Expr> visitFn = shuttle -> shuttle.visit(apply(shuttle.visitAll(args)));
    if (args.size() == 1) {
        return new TrimStaticCharsExpr(mode, args.get(0), DEFAULT_CHARS, null, visitFn);
    } else {
        final Expr charsArg = args.get(1);
        if (charsArg.isLiteral()) {
            final String charsString = charsArg.eval(InputBindings.nilBindings()).asString();
            final char[] chars = charsString == null ? EMPTY_CHARS : charsString.toCharArray();
            return new TrimStaticCharsExpr(mode, args.get(0), chars, charsArg, visitFn);
        } else {
            return new TrimDynamicCharsExpr(mode, args.get(0), args.get(1), visitFn);
        }
    }
}

Example 97 with Expr

use of org.apache.druid.math.expr.Expr in project druid by druid-io.

the class LookupExprMacro method apply.

@Override
public Expr apply(final List<Expr> args) {
    if (args.size() != 2) {
        throw new IAE("Function[%s] must have 2 arguments", name());
    }
    final Expr arg = args.get(0);
    final Expr lookupExpr = args.get(1);
    if (!lookupExpr.isLiteral() || lookupExpr.getLiteralValue() == null) {
        throw new IAE("Function[%s] second argument must be a registered lookup name", name());
    }
    final String lookupName = lookupExpr.getLiteralValue().toString();
    final RegisteredLookupExtractionFn extractionFn = new RegisteredLookupExtractionFn(lookupExtractorFactoryContainerProvider, lookupName, false, null, false, null);
    class LookupExpr extends ExprMacroTable.BaseScalarUnivariateMacroFunctionExpr {

        private LookupExpr(Expr arg) {
            super(FN_NAME, arg);
        }

        @Nonnull
        @Override
        public ExprEval eval(final ObjectBinding bindings) {
            return ExprEval.of(extractionFn.apply(NullHandling.emptyToNullIfNeeded(arg.eval(bindings).asString())));
        }

        @Override
        public Expr visit(Shuttle shuttle) {
            return shuttle.visit(apply(shuttle.visitAll(args)));
        }

        @Nullable
        @Override
        public ExpressionType getOutputType(InputBindingInspector inspector) {
            return ExpressionType.STRING;
        }

        @Override
        public String stringify() {
            return StringUtils.format("%s(%s, %s)", FN_NAME, arg.stringify(), lookupExpr.stringify());
        }

        @Override
        public byte[] getCacheKey() {
            return new CacheKeyBuilder(Exprs.LOOKUP_EXPR_CACHE_KEY).appendString(stringify()).appendCacheable(extractionFn).build();
        }
    }
    return new LookupExpr(arg);
}

Example 98 with Expr

use of org.apache.druid.math.expr.Expr in project druid by druid-io.

the class RegexpLikeExprMacro method apply.

@Override
public Expr apply(final List<Expr> args) {
    if (args.size() != 2) {
        throw new IAE("Function[%s] must have 2 arguments", name());
    }
    final Expr arg = args.get(0);
    final Expr patternExpr = args.get(1);
    if (!ExprUtils.isStringLiteral(patternExpr)) {
        throw new IAE("Function[%s] pattern must be a string literal", name());
    }
    // Precompile the pattern.
    final Pattern pattern = Pattern.compile(StringUtils.nullToEmptyNonDruidDataString((String) patternExpr.getLiteralValue()));
    class RegexpLikeExpr extends ExprMacroTable.BaseScalarUnivariateMacroFunctionExpr {

        private RegexpLikeExpr(Expr arg) {
            super(FN_NAME, arg);
        }

        @Nonnull
        @Override
        public ExprEval eval(final ObjectBinding bindings) {
            final String s = NullHandling.nullToEmptyIfNeeded(arg.eval(bindings).asString());
            if (s == null) {
                // True nulls do not match anything. Note: this branch only executes in SQL-compatible null handling mode.
                return ExprEval.ofLongBoolean(false);
            } else {
                final Matcher matcher = pattern.matcher(s);
                return ExprEval.ofLongBoolean(matcher.find());
            }
        }

        @Override
        public Expr visit(Shuttle shuttle) {
            return shuttle.visit(apply(shuttle.visitAll(args)));
        }

        @Nullable
        @Override
        public ExpressionType getOutputType(InputBindingInspector inspector) {
            return ExpressionType.LONG;
        }

        @Override
        public String stringify() {
            return StringUtils.format("%s(%s, %s)", FN_NAME, arg.stringify(), patternExpr.stringify());
        }
    }
    return new RegexpLikeExpr(arg);
}

Example 99 with Expr

use of org.apache.druid.math.expr.Expr in project druid by druid-io.

the class ContainsExprMacro method apply.

@Override
public Expr apply(final List<Expr> args) {
    if (args.size() != 2) {
        throw new IAE("Function[%s] must have 2 arguments", name());
    }
    final Expr arg = args.get(0);
    final Expr searchStr = args.get(1);
    return new ContainsExpr(FN_NAME, arg, searchStr, true, shuttle -> shuttle.visit(apply(shuttle.visitAll(args))));
}

Example 100 with Expr

use of org.apache.druid.math.expr.Expr in project druid by druid-io.

the class RegexpExtractExprMacro method apply.

@Override
public Expr apply(final List<Expr> args) {
    if (args.size() < 2 || args.size() > 3) {
        throw new IAE("Function[%s] must have 2 to 3 arguments", name());
    }
    final Expr arg = args.get(0);
    final Expr patternExpr = args.get(1);
    final Expr indexExpr = args.size() > 2 ? args.get(2) : null;
    if (!ExprUtils.isStringLiteral(patternExpr)) {
        throw new IAE("Function[%s] pattern must be a string literal", name());
    }
    if (indexExpr != null && (!indexExpr.isLiteral() || !(indexExpr.getLiteralValue() instanceof Number))) {
        throw new IAE("Function[%s] index must be a numeric literal", name());
    }
    // Precompile the pattern.
    final Pattern pattern = Pattern.compile(StringUtils.nullToEmptyNonDruidDataString((String) patternExpr.getLiteralValue()));
    final int index = indexExpr == null ? 0 : ((Number) indexExpr.getLiteralValue()).intValue();
    class RegexpExtractExpr extends ExprMacroTable.BaseScalarUnivariateMacroFunctionExpr {

        private RegexpExtractExpr(Expr arg) {
            super(FN_NAME, arg);
        }

        @Nonnull
        @Override
        public ExprEval eval(final ObjectBinding bindings) {
            final String s = NullHandling.nullToEmptyIfNeeded(arg.eval(bindings).asString());
            if (s == null) {
                // True nulls do not match anything. Note: this branch only executes in SQL-compatible null handling mode.
                return ExprEval.of(null);
            } else {
                final Matcher matcher = pattern.matcher(NullHandling.nullToEmptyIfNeeded(s));
                final String retVal = matcher.find() ? matcher.group(index) : null;
                return ExprEval.of(retVal);
            }
        }

        @Override
        public Expr visit(Shuttle shuttle) {
            return shuttle.visit(apply(shuttle.visitAll(args)));
        }

        @Nullable
        @Override
        public ExpressionType getOutputType(InputBindingInspector inspector) {
            return ExpressionType.STRING;
        }

        @Override
        public String stringify() {
            if (indexExpr != null) {
                return StringUtils.format("%s(%s, %s, %s)", FN_NAME, arg.stringify(), patternExpr.stringify(), indexExpr.stringify());
            }
            return StringUtils.format("%s(%s, %s)", FN_NAME, arg.stringify(), patternExpr.stringify());
        }
    }
    return new RegexpExtractExpr(arg);
}