/** * 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); }
/** * 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 left is null expression * * @param left * @return */ public static Predicate isNull(Expression<?> left) { return PredicateOperation.create(Ops.IS_NULL, left); }
/** * Create a left is not null expression * * @param left * @return */ public static Predicate isNotNull(Expression<?> left) { return PredicateOperation.create(Ops.IS_NOT_NULL, left); }
@Override public Predicate not() { if (not == null) { not = PredicateOperation.create(Ops.NOT, this); } return not; }
/** * 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 Predicate not() { if (not == null) { not = PredicateOperation.create(Ops.NOT, this); } return not; }
/** * 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); }
/** * Create an left not in right expression * * @param <D> * @param left * @param right * @return */ public static <D> Predicate notIn(Expression<D> left, Collection<? extends D> right) { if (right.size() == 1) { return neConst(left, right.iterator().next()); } else { return PredicateOperation.create(Ops.NOT_IN, left, ConstantImpl.create(right)); } }
/** * Create an left in right expression * * @param <D> * @param left * @param right * @return */ public static <D> Predicate in(Expression<D> left, Collection<? extends D> right) { if (right.size() == 1) { return eqConst(left, right.iterator().next()); } else { return PredicateOperation.create(Ops.IN, left, ConstantImpl.create(right)); } }
/** * Adds a qualify expression * * @param predicate * @return */ public TeradataQuery qualify(Predicate predicate) { predicate = PredicateOperation.create(SQLOps.QUALIFY, predicate); return queryMixin.addFlag(new QueryFlag(QueryFlag.Position.BEFORE_ORDER, predicate)); }
public MongodbQuery<K> on(Predicate... conditions) { return queryMixin.where(PredicateOperation.create( MongodbOps.ELEM_MATCH, collection, ExpressionUtils.allOf(conditions))); }
/** * 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); } }
@SuppressWarnings("unchecked") private void addCondition(Context context, int i, Path<?> path, boolean where) { EntityPath<?> alias = context.replacements.get(i); from(alias); Predicate condition = PredicateOperation.create(Ops.IN, alias, path.getMetadata().getParent()); if (where) { super.where(condition); } else { super.having(condition); } }
@SuppressWarnings("unchecked") private Operation<?> transformPathEqNeConstant(Operation<?> operation) { Path<?> path = (Path<?>) operation.getArg(0); Constant<?> constant = (Constant<?>) operation.getArg(1); MappedPath mappedPath = getMappedPath(path); // id property if (path.getMetadata().getPathType() == PathType.PROPERTY && constant.getType().equals(String.class) && mappedPath.getPredicatePath().isEmpty()) { operation = PredicateOperation.create((Operator) operation.getOperator(), path, new ConstantImpl<ID>(session.getId(new LID(constant.toString())))); // localized property } else if (mappedPath.getMappedProperty().isLocalized()) { Locale locale; if (path.getMetadata().getPathType() == PathType.PROPERTY) { locale = session.getCurrentLocale(); } else { locale = (Locale) path.getMetadata().getElement(); } operation = PredicateOperation.create((Operator) operation.getOperator(), path, new ConstantImpl<LIT>(new LIT(constant.toString(), locale))); } return operation; }
@Test public void Like_as_Matches() { visitor.setLikeAsMatches(true); visitor.handle(PredicateOperation.create(Ops.LIKE, QNODE.o, new ConstantImpl(LIT.class, new LIT("x%")))); assertEquals("regex(?o, ?_c2)", visitor.toString()); assertTrue(visitor.getConstantToLabel().containsKey(new LIT("x.*"))); }
@Test public void Like_as_Matches_2() { visitor.setLikeAsMatches(true); visitor.handle(PredicateOperation.create(Ops.LIKE, QNODE.o, new ConstantImpl(LIT.class, new LIT("x_")))); assertEquals("regex(?o, ?_c2)", visitor.toString()); assertTrue(visitor.getConstantToLabel().containsKey(new LIT("x."))); }
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));