private static ExpressionRewriter createRewrite() { return (expression, context) -> ExpressionTreeRewriter.rewriteWith(new com.facebook.presto.sql.tree.ExpressionRewriter<Void>() { @Override public Expression rewriteCurrentUser(CurrentUser node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { return DesugarCurrentUser.getCall(node); } }, expression); }
public Expression map(Expression value) { return ExpressionTreeRewriter.rewriteWith(new ExpressionRewriter<Void>() { @Override public Expression rewriteSymbolReference(SymbolReference node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { Symbol canonical = map(Symbol.from(node)); return canonical.toSymbolReference(); } }, value); }
private static ExpressionRewriter createRewrite() { return (expression, context) -> rewriteWith(new com.facebook.presto.sql.tree.ExpressionRewriter<Void>() { @Override public Expression rewriteCurrentPath(CurrentPath node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { return DesugarCurrentPath.getCall(node); } }, expression); }
private Expression canonicalize(Expression value) { return ExpressionTreeRewriter.rewriteWith(new ExpressionRewriter<Void>() { @Override public Expression rewriteSymbolReference(SymbolReference node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { Symbol canonical = canonicalize(Symbol.from(node)); return canonical.toSymbolReference(); } }, value); }
public static Expression canonicalizeExpression(Expression expression) { return ExpressionTreeRewriter.rewriteWith(new Visitor(), expression); }
public static Expression replaceExpression(Expression expression, Map<? extends Expression, ? extends Expression> mappings) { return ExpressionTreeRewriter.rewriteWith(new ExpressionNodeInliner(mappings), expression); }
public static Expression pushDownNegations(Expression expression) { return ExpressionTreeRewriter.rewriteWith(new Visitor(), expression); }
public static Expression rewrite(Expression expression) { return ExpressionTreeRewriter.rewriteWith(new Visitor(), expression); }
public static Expression addCoercions(Expression expression, Map<NodeRef<Expression>, Type> coercions, Set<NodeRef<Expression>> typeOnlyCoercions) { return ExpressionTreeRewriter.rewriteWith(new Rewriter(coercions, typeOnlyCoercions), expression); }
public static Expression rewrite(Expression expression, Map<NodeRef<Expression>, Type> expressionTypes) { return ExpressionTreeRewriter.rewriteWith(new Visitor(expressionTypes), expression); }
private Expression rewrite(Expression expression) { return ExpressionTreeRewriter.rewriteWith(new Visitor(), expression); }
public <C> Assignments rewrite(ExpressionRewriter<C> rewriter) { return rewrite(expression -> ExpressionTreeRewriter.rewriteWith(rewriter, expression)); }
public static Expression extractCommonPredicates(Expression expression) { return ExpressionTreeRewriter.rewriteWith(new Visitor(), expression, NodeContext.ROOT_NODE); }
public static Expression rewrite(Expression expression, TypeProvider symbolTypes, SymbolAllocator symbolAllocator) { return ExpressionTreeRewriter.rewriteWith(new Visitor(symbolTypes, symbolAllocator), expression, new Context()); }
public static Expression addCoercions(Expression expression, Analysis analysis) { return ExpressionTreeRewriter.rewriteWith(new Rewriter(analysis.getCoercions(), analysis.getTypeOnlyCoercions()), expression); }
private static Expression normalize(Expression expression) { return ExpressionTreeRewriter.rewriteWith(new NormalizeExpressionRewriter(), expression); }
private Expression normalize(Expression expression) { Expression identityNormalizedExpression = expressionCache.get(expression); if (identityNormalizedExpression == null) { // Make sure all sub-expressions are normalized first for (Expression subExpression : Iterables.filter(SubExpressionExtractor.extract(expression), Predicates.not(Predicates.equalTo(expression)))) { normalize(subExpression); } // Since we have not seen this expression before, rewrite it entirely in terms of the normalized sub-expressions identityNormalizedExpression = ExpressionTreeRewriter.rewriteWith(new ExpressionNodeInliner(expressionCache), expression); expressionCache.put(identityNormalizedExpression, identityNormalizedExpression); } return identityNormalizedExpression; } }
private Object evaluatePropertyValue(Expression expression, Type expectedType, Session session, Metadata metadata, List<Expression> parameters) { Expression rewritten = ExpressionTreeRewriter.rewriteWith(new ParameterRewriter(parameters), expression); Object value = evaluateConstantExpression(rewritten, expectedType, metadata, session, parameters); // convert to object value type of SQL type BlockBuilder blockBuilder = expectedType.createBlockBuilder(null, 1); writeNativeValue(expectedType, blockBuilder, value); Object objectValue = expectedType.getObjectValue(session.toConnectorSession(), blockBuilder, 0); if (objectValue == null) { throw new PrestoException(propertyError, format("Invalid null value for %s property", propertyType)); } return objectValue; } }
public static Object evaluatePropertyValue(Expression expression, Type expectedType, Session session, Metadata metadata, List<Expression> parameters) { Expression rewritten = ExpressionTreeRewriter.rewriteWith(new ParameterRewriter(parameters), expression); Object value = evaluateConstantExpression(rewritten, expectedType, metadata, session, parameters); // convert to object value type of SQL type BlockBuilder blockBuilder = expectedType.createBlockBuilder(null, 1); writeNativeValue(expectedType, blockBuilder, value); Object objectValue = expectedType.getObjectValue(session.toConnectorSession(), blockBuilder, 0); if (objectValue == null) { throw new PrestoException(INVALID_SESSION_PROPERTY, "Session property value must not be null"); } return objectValue; }
private static void assertOptimizedMatches(@Language("SQL") String actual, @Language("SQL") String expected) { // replaces FunctionCalls to FailureFunction by fail() Object actualOptimized = optimize(actual); if (actualOptimized instanceof Expression) { actualOptimized = ExpressionTreeRewriter.rewriteWith(new FailedFunctionRewriter(), (Expression) actualOptimized); } assertEquals( actualOptimized, rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(expected))); }