public static List<Expression> extractPredicates(LogicalBinaryExpression expression) { return extractPredicates(expression.getOperator(), expression); }
private static List<List<Expression>> getSubPredicates(LogicalBinaryExpression expression) { return extractPredicates(expression.getOperator(), expression).stream() .map(predicate -> predicate instanceof LogicalBinaryExpression ? extractPredicates((LogicalBinaryExpression) predicate) : ImmutableList.of(predicate)) .collect(toImmutableList()); }
public static List<Expression> extractPredicates(LogicalBinaryExpression.Operator operator, Expression expression) { if (expression instanceof LogicalBinaryExpression && ((LogicalBinaryExpression) expression).getOperator() == operator) { LogicalBinaryExpression logicalBinaryExpression = (LogicalBinaryExpression) expression; return ImmutableList.<Expression>builder() .addAll(extractPredicates(operator, logicalBinaryExpression.getLeft())) .addAll(extractPredicates(operator, logicalBinaryExpression.getRight())) .build(); } return ImmutableList.of(expression); }
@Override protected Void visitLogicalBinaryExpression(LogicalBinaryExpression node, Integer indentLevel) { print(indentLevel, node.getOperator().toString()); super.visitLogicalBinaryExpression(node, indentLevel + 1); return null; }
private static Expression extractCommonPredicates(LogicalBinaryExpression node) { List<List<Expression>> subPredicates = getSubPredicates(node); Set<Expression> commonPredicates = ImmutableSet.copyOf(subPredicates.stream() .map(Visitor::filterDeterministicPredicates) .reduce(Sets::intersection) .orElse(emptySet())); List<List<Expression>> uncorrelatedSubPredicates = subPredicates.stream() .map(predicateList -> removeAll(predicateList, commonPredicates)) .collect(toImmutableList()); LogicalBinaryExpression.Operator flippedOperator = node.getOperator().flip(); List<Expression> uncorrelatedPredicates = uncorrelatedSubPredicates.stream() .map(predicate -> combinePredicates(flippedOperator, predicate)) .collect(toImmutableList()); Expression combinedUncorrelatedPredicates = combinePredicates(node.getOperator(), uncorrelatedPredicates); return combinePredicates(flippedOperator, ImmutableList.<Expression>builder() .addAll(commonPredicates) .add(combinedUncorrelatedPredicates) .build()); }
@Override public Expression rewriteLogicalBinaryExpression(LogicalBinaryExpression node, NodeContext context, ExpressionTreeRewriter<NodeContext> treeRewriter) { Expression expression = combinePredicates( node.getOperator(), extractPredicates(node.getOperator(), node).stream() .map(subExpression -> treeRewriter.rewrite(subExpression, NodeContext.NOT_ROOT_NODE)) .collect(toImmutableList())); if (!(expression instanceof LogicalBinaryExpression)) { return expression; } Expression simplified = extractCommonPredicates((LogicalBinaryExpression) expression); // Prefer AND LogicalBinaryExpression at the root if possible if (context.isRootNode() && simplified instanceof LogicalBinaryExpression && ((LogicalBinaryExpression) simplified).getOperator() == OR) { return distributeIfPossible((LogicalBinaryExpression) simplified); } return simplified; }
@Override protected PlanNodeStatsEstimate visitLogicalBinaryExpression(LogicalBinaryExpression node, Void context) { switch (node.getOperator()) { case AND: return estimateLogicalAnd(node.getLeft(), node.getRight()); case OR: return estimateLogicalOr(node.getLeft(), node.getRight()); default: throw new IllegalArgumentException("Unexpected binary operator: " + node.getOperator()); } }
expression.getOperator().flip(), crossProduct.stream() .map(expressions -> combinePredicates(expression.getOperator(), expressions)) .collect(toImmutableList()));
@Override public Expression rewriteLogicalBinaryExpression(LogicalBinaryExpression node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { List<Expression> predicates = extractPredicates(node.getOperator(), node).stream() .map(p -> treeRewriter.rewrite(p, context)) .sorted(Comparator.comparing(Expression::toString)) .collect(toList()); return binaryExpression(node.getOperator(), predicates); } }
@Override protected String visitLogicalBinaryExpression(LogicalBinaryExpression node, Void context) { return formatBinaryExpression(node.getOperator().toString(), node.getLeft(), node.getRight()); }
Object right; switch (node.getOperator()) { case AND: { if (Boolean.FALSE.equals(left)) { return new LogicalBinaryExpression(node.getOperator(), toExpression(left, type(node.getLeft())), toExpression(right, type(node.getRight())));
@Override protected RowExpression visitLogicalBinaryExpression(LogicalBinaryExpression node, Void context) { return call( logicalExpressionSignature(node.getOperator()), BOOLEAN, process(node.getLeft(), context), process(node.getRight(), context)); }
@Override protected Boolean visitLogicalBinaryExpression(LogicalBinaryExpression actual, Node expectedExpression) { if (expectedExpression instanceof LogicalBinaryExpression) { LogicalBinaryExpression expected = (LogicalBinaryExpression) expectedExpression; if (actual.getOperator() == expected.getOperator()) { return process(actual.getLeft(), expected.getLeft()) && process(actual.getRight(), expected.getRight()); } } return false; }
TupleDomain<Symbol> rightTupleDomain = rightResult.getTupleDomain(); LogicalBinaryExpression.Operator operator = complement ? node.getOperator().flip() : node.getOperator(); switch (operator) { case AND: throw new AssertionError("Unknown operator: " + node.getOperator());
@Override public Expression rewriteNotExpression(NotExpression node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { if (node.getValue() instanceof LogicalBinaryExpression) { LogicalBinaryExpression child = (LogicalBinaryExpression) node.getValue(); List<Expression> predicates = extractPredicates(child); List<Expression> negatedPredicates = predicates.stream().map(predicate -> treeRewriter.rewrite((Expression) new NotExpression(predicate), context)).collect(toImmutableList()); return combinePredicates(child.getOperator().flip(), negatedPredicates); } else if (node.getValue() instanceof ComparisonExpression && ((ComparisonExpression) node.getValue()).getOperator() != IS_DISTINCT_FROM) { ComparisonExpression child = (ComparisonExpression) node.getValue(); return new ComparisonExpression(child.getOperator().negate(), treeRewriter.rewrite(child.getLeft(), context), treeRewriter.rewrite(child.getRight(), context)); } else if (node.getValue() instanceof NotExpression) { NotExpression child = (NotExpression) node.getValue(); return treeRewriter.rewrite(child.getValue(), context); } return new NotExpression(treeRewriter.rewrite(node.getValue(), context)); } }
@Override protected Void visitLogicalBinaryExpression(LogicalBinaryExpression node, Integer indentLevel) { print(indentLevel, node.getOperator().toString()); super.visitLogicalBinaryExpression(node, indentLevel + 1); return null; }
@Override protected String visitLogicalBinaryExpression(LogicalBinaryExpression node, Void context) { return formatBinaryExpression(node.getOperator().toString(), node.getLeft(), node.getRight()); }