@Override protected Clause visitNotExpression(NotExpression node, Void context) { LogicalClause notClause = new LogicalClause(); notClause.setOperation(NOT); notClause.setClauses(asList(process(node.getValue()))); return notClause; }
private Clause rewriteClause(Clause clause) { Clause toReturn = clause; if (clause instanceof LogicalClause) { LogicalClause logical = ((LogicalClause) clause); logical.setClauses(rewriteClauses(logical.getClauses())); } else if (clause instanceof StringFilterClause) { toReturn = new ObjectFilterClause((StringFilterClause) clause); } return toReturn; } }
private static boolean performLogical(BulletRecord record, LogicalClause clause) { List<Clause> clauses = clause.getClauses(); if (isEmpty(clauses)) { return true; } Stream<Boolean> results = clauses.stream().map(c -> perform(record, c)); return LOGICAL_OPERATORS.get(clause.getOperation()).test(record, results); }
private void mapFieldToFilters(Clause clause, Map<String, List<FilterClause>> mapping) { if (clause instanceof FilterClause) { mapFieldToFilter((FilterClause) clause, mapping); return; } List<Clause> clauses = ((LogicalClause) clause).getClauses(); // Cannot have null non-AND logicals as it is checked for. clauses.forEach(c -> this.mapFieldToFilters(c, mapping)); }
private static boolean hasNonANDLogicals(Clause clause) { if (clause instanceof FilterClause) { return false; } return clause.getOperation() != Clause.Operation.AND || hasNonANDLogicals(((LogicalClause) clause).getClauses()); }
@Override protected Clause visitLogicalBinaryExpression(LogicalBinaryExpression node, Void context) { LogicalClause binaryClause = new LogicalClause(); binaryClause.setOperation(node.getOperation()); binaryClause.setClauses(asList(process(node.getLeft()), process(node.getRight()))); return binaryClause; }
@Override protected Clause visitBetweenPredicate(BetweenPredicate node, Void context) { Expression value = node.getValue(); failIfReferenceWithFunction(value); LogicalClause binaryClause = new LogicalClause(); binaryClause.setOperation(AND); Clause lowerClause = createFilterClause(GREATER_EQUALS, value.toFormatlessString(), node.getMin()); Clause upperClause = createFilterClause(LESS_EQUALS, value.toFormatlessString(), node.getMax()); binaryClause.setClauses(asList(lowerClause, upperClause)); return binaryClause; }
@Override protected Clause visitComparisonExpression(ComparisonExpression node, Void context) { Expression left = node.getLeft(); Operation op = node.getOperation(); boolean isNotExpression = false; if (left instanceof ReferenceWithFunction) { if (op != EQUALS && op != NOT_EQUALS) { throw unsupportedReferenceWithFunction(((ReferenceWithFunction) left).getOperation()); } if (op == NOT_EQUALS) { isNotExpression = true; } op = ((ReferenceWithFunction) left).getOperation(); left = ((ReferenceWithFunction) left).getValue(); } Clause clause = createFilterClause(op, left.toFormatlessString(), node.getRight()); if (!isNotExpression) { return clause; } LogicalClause notClause = new LogicalClause(); notClause.setOperation(NOT); notClause.setClauses(asList(clause)); return notClause; }