/** * Create an left equals right expression * * @param <D> * @param left * @param right * @return */ public static <D> Predicate eq(Expression<D> left, Expression<? extends D> right) { return PredicateOperation.create(Ops.EQ, left, right); }
/** * Create a new Operation expression * * @param operator operator * @param args operation arguments * @return operation expression */ public static PredicateOperation predicate(Operator<Boolean> operator, ImmutableList<Expression<?>> args) { return new PredicateOperation(operator, args); }
@Override public BooleanExpression not() { if (opMixin.getOperator() == Ops.NOT && opMixin.getArg(0) instanceof BooleanExpression) { return (BooleanExpression) opMixin.getArg(0); } else { return super.not(); } }
expr = PredicateOperation.create(Ops.MATCHES, expr.getArg(0), new ConstantImpl(new LIT("^" + expr.getArg(1)))); expr = PredicateOperation.create(Ops.MATCHES_IC, expr.getArg(0), new ConstantImpl(new LIT("^" + expr.getArg(1)))); expr = PredicateOperation.create(Ops.MATCHES, expr.getArg(0), new ConstantImpl(new LIT(expr.getArg(1) + "$"))); expr = PredicateOperation.create(Ops.MATCHES_IC, expr.getArg(0), new ConstantImpl(new LIT(expr.getArg(1) + "$"))); expr = PredicateOperation.create(Ops.MATCHES, expr.getArg(0), new ConstantImpl(new LIT(".*" + expr.getArg(1) + ".*"))); expr = PredicateOperation.create(Ops.MATCHES_IC, expr.getArg(0), new ConstantImpl(new LIT(".*" + expr.getArg(1) + ".*"))); Operator<Boolean> first = Ops.GOE, second = Ops.LOE; expr = (Operation<?>) ExpressionUtils.and( PredicateOperation.create(first, expr.getArg(0), expr.getArg(1)), PredicateOperation.create(second, expr.getArg(0), expr.getArg(2))); return PredicateOperation.create(Ops.IS_NULL, transform(expr.getArg(0), filters)); return new PredicateOperation((Operator) expr.getOperator(), ImmutableList.copyOf(args)); } else { return new OperationImpl(expr.getType(), expr.getOperator(), ImmutableList.copyOf(args));
@Override public List<Expression<?>> getArgs() { return opMixin.getArgs(); }
@Override public Expression<?> getArg(int index) { return opMixin.getArg(index); }
@Override public Operator<? super Boolean> getOperator() { return opMixin.getOperator(); }
/** * Create a left is null expression * * @param left * @return */ public static Predicate isNull(Expression<?> left) { return PredicateOperation.create(Ops.IS_NULL, left); }
protected BooleanOperation(Operator<? super Boolean> op, ImmutableList<Expression<?>> args) { super(new PredicateOperation((Operator)op, args)); opMixin = (PredicateOperation)mixin; }
/** * Create an left in right expression * * @param <D> * @param left * @param right * @return */ public static <D> Predicate in(Expression<D> left, CollectionExpression<?,? extends D> right) { return PredicateOperation.create(Ops.IN, left, right); }
public static PredicateOperation create(Operator<Boolean> operator, Expression<?> one) { return new PredicateOperation(operator, ImmutableList.<Expression<?>>of(one)); }
/** * Create a left is not null expression * * @param left * @return */ public static Predicate isNotNull(Expression<?> left) { return PredicateOperation.create(Ops.IS_NOT_NULL, left); }
public static PredicateOperation create(Operator<Boolean> operator, Expression<?> one, Expression<?> two) { return new PredicateOperation(operator, ImmutableList.of(one, two)); }
@Override public Predicate not() { if (not == null) { not = PredicateOperation.create(Ops.NOT, this); } return not; }
/** * Create a new Operation expression * * @param type type of expression * @param operator operator * @param args operation arguments * @return operation expression */ @SuppressWarnings("unchecked") public static <T> Operation<T> operation(Class<? extends T> type, Operator<T> operator, ImmutableList<Expression<?>> args) { if (type.equals(Boolean.class)) { return (Operation<T>) new PredicateOperation((Operator<Boolean>) operator, args); } else { return new OperationImpl<T>(type, operator, args); } }
/** * Create a left not equals right expression * * @param <D> * @param left * @param right * @return */ public static <D> Predicate ne(Expression<D> left, Expression<? super D> right) { return PredicateOperation.create(Ops.NE, left, right); }
@Override public Expression<?> visit(Operation<?> expr, @Nullable Void context) { ImmutableList<Expression<?>> args = visit(expr.getArgs()); if (args.equals(expr.getArgs())) { return expr; } else if (expr instanceof Predicate) { return new PredicateOperation((Operator)expr.getOperator(), args); } else { return new OperationImpl(expr.getType(), expr.getOperator(), args); } }
@Override public Predicate not() { if (not == null) { not = PredicateOperation.create(Ops.NOT, this); } return not; }
@SuppressWarnings("unchecked") @Override public Expression<?> visit(Operation<?> expr, Context context) { final Expression<?>[] args = new Expression<?>[expr.getArgs().size()]; for (int i = 0; i < args.length; i++) { Context c = new Context(); args[i] = expr.getArg(i).accept(this, c); context.add(c); } if (context.replace) { if (expr.getType().equals(Boolean.class)) { Predicate predicate = new PredicateOperation((Operator)expr.getOperator(), ImmutableList.copyOf(args)); return !context.paths.isEmpty() ? exists(context, predicate) : predicate; } else { return new OperationImpl(expr.getType(), expr.getOperator(), ImmutableList.copyOf(args)); } } else { return expr; } }
/** * Create an left not in right expression * * @param <D> * @param left * @param right * @return */ public static <D> Predicate notIn(Expression<D> left, CollectionExpression<?,? extends D> right) { return PredicateOperation.create(Ops.NOT_IN, left, right); }