@Override public <R,C> R accept(Visitor<R,C> v, C context) { if (predicate != null) { return predicate.accept(v, context); } else { return null; } }
@Override public BooleanBuilder not() { if (predicate != null) { predicate = predicate.not(); } return this; }
@Nullable private Predicate transform(Predicate expr, Filters filters) { return (Predicate) expr.accept(this, filters); }
/** * Create the insertion of this and the negation of the given predicate * * @param right * @return */ public BooleanBuilder andNot(Predicate right) { return and(right.not()); }
query.whereExpressions.add( predicate.accept( new Visitor<PredicateExpression, BooleanExpression>()
/** * Create the union of this and the negation of the given predicate * * @param right * @return */ public BooleanBuilder orNot(Predicate right) { return or(right.not()); }
@Override protected Predicate normalize(Predicate predicate, boolean where) { predicate = (Predicate)ExpressionUtils.extract(predicate); if (predicate != null) { Context context = new Context(); Predicate transformed = (Predicate) predicate.accept(CollectionAnyVisitor.DEFAULT, context); for (int i = 0; i < context.paths.size(); i++) { Path<?> path = context.paths.get(i); addCondition(context, i, path, where); } return transformed; } else { return null; } }
/** * Wrap a Querydsl predicate into a Guava predicate * * @param predicate * @return */ public static <T> com.google.common.base.Predicate<T> wrap(Predicate predicate) { Path<?> path = (Path<?>)predicate.accept(PathExtractor.DEFAULT, null); if (path != null) { final Evaluator<Boolean> ev = createEvaluator(path.getRoot(), predicate); return new com.google.common.base.Predicate<T>() { @Override public boolean apply(T input) { return ev.evaluate(input); } }; } else { throw new IllegalArgumentException("No path in " + predicate); } }
@Override protected Predicate normalize(Predicate predicate, boolean where) { predicate = (Predicate)ExpressionUtils.extract(predicate); if (predicate != null) { Context context = new Context(); Predicate transformed = (Predicate) predicate.accept(CollectionAnyVisitor.DEFAULT, context); for (int i = 0; i < context.paths.size(); i++) { leftJoin( (Path)context.paths.get(i).getMetadata().getParent(), (Path)context.replacements.get(i)); on(ANY); } return transformed; } else { return predicate; } } }
private Set<RelationalPath<?>> visitJoins(Iterable<JoinExpression> joins, Set<RelationalPath<?>> known) { for (JoinExpression j : joins) { known = j.getTarget().accept(this, known); if (j.getCondition() != null) { known = j.getCondition().accept(this, known); } } return known; }
Predicate<Bindings> predicate = (Predicate) expr.getFilters().accept(this, previous); iterable = Iterables.filter(iterable, predicate);
builder.or(ExpressionUtils.eq(args.get(0), new ConstantImpl(arg))); builder.getValue().accept(this, null); return;
result = ExpressionUtils.notInAny(path, partitioned); result.accept(this, null);
public static Set<RelationalPath<?>> extract(QueryMetadata md) { Set<RelationalPath<?>> known = ImmutableSet.of(); known = DEFAULT.visitJoins(md.getJoins(), known); for (Expression<?> p : md.getProjection()) { known = p.accept(DEFAULT, known); } for (OrderSpecifier<?> o : md.getOrderBy()) { known = o.getTarget().accept(DEFAULT, known); } for (Expression<?> g : md.getGroupBy()) { known = g.accept(DEFAULT, known); } if (md.getHaving() != null) { known = md.getHaving().accept(DEFAULT, known); } if (md.getWhere() != null) { known = md.getWhere().accept(DEFAULT, known); } return known; }
private Set<Expression<?>> visitJoins(Iterable<JoinExpression> joins, Set<Expression<?>> known) { for (JoinExpression j : joins) { final Expression<?> expr = j.getTarget(); if (expr instanceof Path && ((Path)expr).getMetadata().isRoot()) { known = add(known, expr); } else { known = expr.accept(this, known); } if (j.getCondition() != null) { known = j.getCondition().accept(this, known); } } return known; }
Iterable<Bindings> iterable = (Iterable<Bindings>) ((Pair) where.accept(this, whereBindings)).getFirst();
@Override public Set<Expression<?>> visit(SubQueryExpression<?> expr, Set<Expression<?>> known) { Set<Expression<?>> old = known; final QueryMetadata md = expr.getMetadata(); known = visitJoins(md.getJoins(), known); for (Expression<?> p : md.getProjection()) { known = p.accept(this, known); } for (OrderSpecifier<?> o : md.getOrderBy()) { known = o.getTarget().accept(this, known); } for (Expression<?> g : md.getGroupBy()) { known = g.accept(this, known); } if (md.getHaving() != null) { known = md.getHaving().accept(this, known); } if (md.getWhere() != null) { known = md.getWhere().accept(this, known); } return old; }
@Override public Set<RelationalPath<?>> visit(SubQueryExpression<?> expr, Set<RelationalPath<?>> known) { Set<RelationalPath<?>> old = known; final QueryMetadata md = expr.getMetadata(); known = visitJoins(md.getJoins(), known); for (Expression<?> p : md.getProjection()) { known = p.accept(this, known); } for (OrderSpecifier<?> o : md.getOrderBy()) { known = o.getTarget().accept(this, known); } for (Expression<?> g : md.getGroupBy()) { known = g.accept(this, known); } if (md.getHaving() != null) { known = md.getHaving().accept(this, known); } if (md.getWhere() != null) { md.getWhere().accept(this, known); } return old; }
builder.or(ExpressionUtils.eqConst((Expression) expr.getArg(0), o)); return builder.getValue().accept(this, bindings);