/** * Create a BooleanBuilder with the given initial value * * @param initial */ public BooleanBuilder(Predicate initial) { predicate = (Predicate)ExpressionUtils.extract(initial); }
@Override public Object convert(final List<?> args) { final Object arg = args.get(index); if (arg instanceof Expression) { return ExpressionUtils.extract((Expression<?>) arg); } else { return arg; } }
/** * Create the intersection of the given arguments * * @param left * @param right * @return */ public static Predicate and(Predicate left, Predicate right) { left = (Predicate) extract(left); right = (Predicate) extract(right); if (left == null) { return right; } else if (right == null) { return left; } else { return PredicateOperation.create(Ops.AND, left, right); } }
/** * Create a left or right expression * * @param left * @param right * @return */ public static Predicate or(Predicate left, Predicate right) { left = (Predicate) extract(left); right = (Predicate) extract(right); if (left == null) { return right; } else if (right == null) { return left; } else { return PredicateOperation.create(Ops.OR, left, right); } }
@Override public void addHaving(Predicate e) { if (e == null) { return; } e = (Predicate)ExpressionUtils.extract(e); if (e != null) { // having elements can't be validated, since they can refer to projection elements // that are declared later having = and(having, e); } }
/** * Get an intersection of this and the given expression * * @param right right hand side of the union * @return {@code this && right} */ public BooleanExpression and(@Nullable Predicate right) { right = (Predicate) ExpressionUtils.extract(right); if (right != null) { return BooleanOperation.create(Ops.AND, mixin, right); } else { return this; } }
/** * Get a union of this and the given expression * * @param right right hand side of the union * @return this || right */ public BooleanExpression or(@Nullable Predicate right) { right = (Predicate) ExpressionUtils.extract(right); if (right != null) { return BooleanOperation.create(Ops.OR, mixin, right); } else { return this; } }
public Query toQuery(Expression<?> expr, QueryMetadata metadata) { if (expr instanceof Operation<?>) { return toQuery((Operation<?>) expr, metadata); } else { return toQuery(ExpressionUtils.extract(expr), metadata); } }
@Override public void addWhere(Predicate e) { if (e == null) { return; } e = (Predicate)ExpressionUtils.extract(e); if (e != null) { validate(e); where = and(where, e); } }
@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; } }
@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; } } }