/** * 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)); } }
private Predicate allOf(Collection<Predicate> predicates) { return predicates != null ? ExpressionUtils.allOf(predicates) : null; }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override public JDOUpdateClause set(List<? extends Path<?>> paths, List<?> values) { for (int i = 0; i < paths.size(); i++) { if (values.get(i) != null) { metadata.addProjection(ExpressionUtils.eqConst(((Expression)paths.get(i)), values.get(i))); } else { metadata.addProjection(ExpressionUtils.eq(((Expression)paths.get(i)), new NullExpression(paths.get(i).getType()))); } } return this; }
private void addKeyConditions(FilteredClause query) { List<? extends Path<?>> keys = getKeys(); for (int i=0; i < columns.size(); i++) { if (keys.contains(columns.get(i))) { if (values.get(i) instanceof NullExpression) { query.where(ExpressionUtils.isNull(columns.get(i))); } else { query.where(ExpressionUtils.eq(columns.get(i),(Expression)values.get(i))); } } } }
/** * Create a BooleanBuilder with the given initial value * * @param initial */ public BooleanBuilder(Predicate initial) { predicate = (Predicate)ExpressionUtils.extract(initial); }
/** * Create an left equals constant expression * * @param <D> * @param left * @param constant * @return */ public static <D> Predicate eqConst(Expression<D> left, D constant) { return eq(left, ConstantImpl.create(constant)); }
public static Expression<?> union(SubQueryExpression<?>[] union, Path<?> alias, boolean unionAll) { final Expression<?> rv = union(union, unionAll); return ExpressionUtils.as((Expression)rv, alias); }
@Nullable protected Predicate createJoinFilter(QueryMetadata metadata) { Multimap<Expression<?>, Predicate> predicates = HashMultimap.<Expression<?>, Predicate>create(); List<JoinExpression> joins = metadata.getJoins(); for (int i = joins.size() - 1; i >= 0; i--) { JoinExpression join = joins.get(i); Path source = (Path)((Operation<?>)join.getTarget()).getArg(0); Path target = (Path)((Operation<?>)join.getTarget()).getArg(1); Collection<Predicate> extraFilters = predicates.get(target.getRoot()); Predicate filter = ExpressionUtils.allOf(join.getCondition(), allOf(extraFilters)); List<Object> ids = getIds(target.getType(), filter); if (ids.isEmpty()) { throw new NoResults(); } Path path = new PathImpl<String>(String.class, source, "$id"); predicates.put(source.getRoot(), ExpressionUtils.in(path, ids)); } Path source = (Path)((Operation)joins.get(0).getTarget()).getArg(0); return allOf(predicates.get(source.getRoot())); }
rhs = (Predicate) transform(expr.getArg(1), filters); return lhs == null ? rhs : (rhs == null ? lhs : ExpressionUtils.and(lhs, rhs)); expr = (Operation) ExpressionUtils.eq(lhs, (Expression) expr.getArg(1)); } else if (leftPath && rightConstant) { Collection col = (Collection) ((Constant) expr.getArg(1)).getConstant(); BooleanBuilder builder = new BooleanBuilder(); for (Object o : col) { builder.or(ExpressionUtils.eq(lhs, new ConstantImpl(o))); expr = (Operation<?>) ExpressionUtils.and( PredicateOperation.create(first, expr.getArg(0), expr.getArg(1)), PredicateOperation.create(second, expr.getArg(0), expr.getArg(2))); expr = (Operation<?>) ExpressionUtils.eq(expr.getArg(0), new ConstantImpl(RDF.nil)); expr = (Operation<?>) ExpressionUtils.eq((Path) path, expr.getArg(1));
/** * Convert the given like pattern to a regex pattern * * @param expr * @return */ public static Expression<String> likeToRegex(Expression<String> expr) { return likeToRegex(expr, true); }
Expression<String> string = (Expression<String>) args.get(0); @SuppressWarnings("unchecked") //This is the expected type for like Expression<String> regex = ExpressionUtils.likeToRegex((Expression<String>) args.get(1), false); if (operator == Ops.LIKE_IC || operator == Ops.LIKE_ESCAPE_IC) { string = ExpressionUtils.toLower(string); regex = ExpressionUtils.toLower(regex);
private static Predicate and(Predicate lhs, Predicate rhs) { if (lhs == null) { return rhs; } else { return ExpressionUtils.and(lhs, rhs); } }
/** * Get an intersection of this and the union of the given predicates * * @param predicates * @return */ public BooleanExpression andAnyOf(Predicate... predicates) { return and(ExpressionUtils.anyOf(predicates)); }
/** * Create a {@code left in right or...} expression for each list * * @param <D> * @param left * @param lists * @return a {@code left in right or...} expression */ public static <D> Predicate inAny(Expression<D> left, Iterable<? extends Collection<? extends D>> lists) { BooleanBuilder rv = new BooleanBuilder(); for (Collection<? extends D> list : lists) { rv.or(in(left, list)); } return rv; }
@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; } }
@Override public <T> JDOUpdateClause set(Path<T> path, Expression<? extends T> expression) { metadata.addProjection(ExpressionUtils.eq(path, expression)); return this; }
protected <D> Expression<D> createAlias(Expression<?> expr, Path<?> alias) { assertRoot(alias); return ExpressionUtils.as((Expression)expr, (Path)alias); }
Operation<?> o = (Operation<?>)expr; if (o.getOperator() == Ops.CONCAT) { Expression<String> lhs = likeToRegex((Expression<String>) o.getArg(0), false); Expression<String> rhs = likeToRegex((Expression<String>) o.getArg(1), false); if (lhs != o.getArg(0) || rhs != o.getArg(1)) { return OperationImpl.create(String.class, Ops.CONCAT, lhs, rhs);
/** * Create the intersection of the given arguments * * @param exprs * @return */ @Nullable public static Predicate allOf(Collection<Predicate> exprs) { Predicate rv = null; for (Predicate b : exprs) { if (b != null) { rv = rv == null ? b : ExpressionUtils.and(rv,b); } } return rv; }
/** * Create the intersection of this and the union of the given args * {@code (this && (arg1 || arg2 ... || argN))} * * @param args * @return */ public BooleanBuilder andAnyOf(Predicate... args) { if (args.length > 0) { and(ExpressionUtils.anyOf(args)); } return this; }