public static Expression and(Expression... expressions) { return and(Arrays.asList(expressions)); }
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); }
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()); }; }
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);
@Override public FunctionCall deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return (FunctionCall) rewriteIdentifiersToSymbolReferences(sqlParser.createExpression(jsonParser.readValueAs(String.class))); } }
@Override public int hashCode() { return Objects.hash(sources, ImmutableSet.copyOf(extractConjuncts(filter)), outputSymbols); }
public static List<Expression> extractConjuncts(Expression expression) { return extractPredicates(LogicalBinaryExpression.Operator.AND, expression); }
@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); } }
public static Expression combineConjuncts(Expression... expressions) { return combineConjuncts(Arrays.asList(expressions)); }
@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); }
@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; }
private static void assertNormalize(Expression expression, Expression normalized) { assertEquals(normalize(expression), normalized); }
public static Expression or(Expression... expressions) { return or(Arrays.asList(expressions)); }
public static Expression combineDisjuncts(Collection<Expression> expressions) { return combineDisjunctsWithDefault(expressions, FALSE_LITERAL); }
public static Expression combineDisjuncts(Expression... expressions) { return combineDisjuncts(Arrays.asList(expressions)); }
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()); }; }
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);