public static Function<Expression, Expression> expressionOrNullSymbols(final Predicate<Symbol>... nullSymbolScopes) { return expression -> { ImmutableList.Builder<Expression> resultDisjunct = ImmutableList.builder(); resultDisjunct.add(expression); for (Predicate<Symbol> nullSymbolScope : nullSymbolScopes) { List<Symbol> symbols = SymbolsExtractor.extractUnique(expression).stream() .filter(nullSymbolScope) .collect(toImmutableList()); if (Iterables.isEmpty(symbols)) { continue; } ImmutableList.Builder<Expression> nullConjuncts = ImmutableList.builder(); for (Symbol symbol : symbols) { nullConjuncts.add(new IsNullPredicate(symbol.toSymbolReference())); } resultDisjunct.add(and(nullConjuncts.build())); } return or(resultDisjunct.build()); }; }
public static Expression and(Collection<Expression> expressions) { return binaryExpression(LogicalBinaryExpression.Operator.AND, expressions); }
public static Expression filterConjuncts(Expression expression, Predicate<Expression> predicate) { List<Expression> conjuncts = extractConjuncts(expression).stream() .filter(predicate) .collect(toList()); return combineConjuncts(conjuncts); }
public static Expression combinePredicates(LogicalBinaryExpression.Operator operator, Collection<Expression> expressions) { if (operator == LogicalBinaryExpression.Operator.AND) { return combineConjuncts(expressions); } return combineDisjuncts(expressions); }
public static Expression combineDisjunctsWithDefault(Collection<Expression> expressions, Expression emptyDefault) { requireNonNull(expressions, "expressions is null"); List<Expression> disjuncts = expressions.stream() .flatMap(e -> ExpressionUtils.extractDisjuncts(e).stream()) .filter(e -> !e.equals(FALSE_LITERAL)) .collect(toList()); disjuncts = removeDuplicates(disjuncts); if (disjuncts.contains(TRUE_LITERAL)) { return TRUE_LITERAL; } return disjuncts.isEmpty() ? emptyDefault : or(disjuncts); }
List<ComparisonExpression.Operator> joinConditionComparisonOperators = new ArrayList<>(); for (Expression conjunct : ExpressionUtils.extractConjuncts(criteria)) { conjunct = ExpressionUtils.normalize(conjunct); Expression joinedFilterCondition = ExpressionUtils.and(complexJoinExpressions); Expression rewrittenFilterCondition = translationMap.rewrite(joinedFilterCondition); root = new JoinNode(idAllocator.getNextId(), postInnerJoinCriteria = ExpressionUtils.and(postInnerJoinConditions); root = new FilterNode(idAllocator.getNextId(), root, postInnerJoinCriteria);
public static Expression and(Expression... expressions) { return and(Arrays.asList(expressions)); }
analysis.setJoinCriteria(node, ExpressionUtils.and(expressions)); final Set<InPredicate> rightJoinInPredicates = new HashSet<>(); for (Expression conjunct : ExpressionUtils.extractConjuncts((Expression) optimizedExpression)) { conjunct = ExpressionUtils.normalize(conjunct); if (conjunct instanceof ComparisonExpression) { Expression conjunctFirst = ((ComparisonExpression) conjunct).getLeft(); ExpressionAnalysis postJoinPredicatesConjunctsAnalysis = analyzeExpression(ExpressionUtils.combineConjuncts(postJoinConjuncts), output, context); analysis.recordSubqueries(node, postJoinPredicatesConjunctsAnalysis); analysis.addJoinInPredicates(node, new Analysis.JoinInPredicates(leftJoinInPredicates, rightJoinInPredicates));
public static Expression combineConjuncts(Collection<Expression> expressions) { requireNonNull(expressions, "expressions is null"); List<Expression> conjuncts = expressions.stream() .flatMap(e -> ExpressionUtils.extractConjuncts(e).stream()) .filter(e -> !e.equals(TRUE_LITERAL)) .collect(toList()); conjuncts = removeDuplicates(conjuncts); if (conjuncts.contains(FALSE_LITERAL)) { return FALSE_LITERAL; } return and(conjuncts); }
public static Expression combineConjuncts(Expression... expressions) { return combineConjuncts(Arrays.asList(expressions)); }
public static List<Expression> extractConjuncts(Expression expression) { return extractPredicates(LogicalBinaryExpression.Operator.AND, expression); }
@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 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 public int hashCode() { return Objects.hash(sources, ImmutableSet.copyOf(extractConjuncts(filter)), outputSymbols); }
@Test public void testAnd() { Expression a = name("a"); Expression b = name("b"); Expression c = name("c"); Expression d = name("d"); Expression e = name("e"); assertEquals( ExpressionUtils.and(a, b, c, d, e), and(and(and(a, b), and(c, d)), e)); assertEquals( ExpressionUtils.combineConjuncts(a, b, a, c, d, c, e), and(and(and(a, b), and(c, d)), e)); }
public static Expression or(Expression... expressions) { return or(Arrays.asList(expressions)); }
private static void assertNormalize(Expression expression, Expression normalized) { assertEquals(normalize(expression), normalized); }
@Override public Expression visitFilter(FilterNode node, Void context) { Expression underlyingPredicate = node.getSource().accept(this, context); Expression predicate = node.getPredicate(); // Remove non-deterministic conjuncts predicate = filterDeterministicConjuncts(predicate); return combineConjuncts(predicate, underlyingPredicate); }
public static Expression combineDisjunctsWithDefault(Iterable<Expression> expressions, Expression emptyDefault) { requireNonNull(expressions, "expressions is null"); // Flatten all the expressions into their component disjuncts expressions = Iterables.concat(transform(expressions, ExpressionUtils::extractDisjuncts)); // Strip out all false literal disjuncts expressions = filter(expressions, not(Predicates.<Expression>equalTo(FALSE_LITERAL))); expressions = removeDuplicates(expressions); if (contains(expressions, TRUE_LITERAL)) { return TRUE_LITERAL; } return Iterables.isEmpty(expressions) ? emptyDefault : or(expressions); }
public static Expression combineDisjuncts(Collection<Expression> expressions) { return combineDisjunctsWithDefault(expressions, FALSE_LITERAL); }