@SuppressWarnings("unchecked") protected CollectionOperation(Class<? super E> type, Operator op, ImmutableList<Expression<?>> args) { super(ExpressionUtils.operation((Class) Collection.class, op, args)); this.opMixin = (OperationImpl) super.mixin; this.elementType = (Class<E>) type; }
/** * Create a BooleanBuilder with the given initial value * * @param initial initial value */ public BooleanBuilder(Predicate initial) { predicate = (Predicate) ExpressionUtils.extract(initial); }
@SuppressWarnings("unchecked") protected ArrayPath(Class<? super A> type, PathMetadata metadata) { super(ExpressionUtils.path((Class) type, metadata)); this.pathMixin = (PathImpl<A>) mixin; this.componentType = Primitives.wrap((Class<E>) type.getComponentType()); }
@SuppressWarnings("unchecked") @Nullable protected Predicate createJoinFilter(QueryMetadata metadata) { LinkedMultiValueMap<Expression<?>, Predicate> predicates = new LinkedMultiValueMap<>(); 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<? extends Object> ids = getIds(target.getType(), filter); if (ids.isEmpty()) { return ExpressionUtils.predicate(QuerydslMongoOps.NO_MATCH, source); } Path<?> path = ExpressionUtils.path(String.class, source, "$id"); predicates.add(source.getRoot(), ExpressionUtils.in((Path<Object>) path, ids)); } Path<?> source = (Path) ((Operation) joins.get(0).getTarget()).getArg(0); return allOf(predicates.get(source.getRoot())); }
@SuppressWarnings("unchecked") @Override public Expression<?> visit(Path<?> expr, @Nullable Void context) { expr = (Path<?>) super.visit(expr, null); PathMetadata pathMetadata = expr.getMetadata(); if (pathMetadata.getPathType() == PathType.LISTVALUE || pathMetadata.getPathType() == PathType.LISTVALUE_CONSTANT) { Path<?> replacement = replacements.get(expr); if (replacement == null) { // join parent as path123 on index(path123) = ... Path parent = shorten(pathMetadata.getParent(), true); replacement = ExpressionUtils.path(expr.getType(), ExpressionUtils.createRootVariable(parent, replacements.size())); metadata.addJoin(JoinType.LEFTJOIN, ExpressionUtils.as(parent, replacement)); metadata.addJoinCondition(ExpressionUtils.eq( (Expression) Expressions.operation(Integer.class, JPQLOps.INDEX, replacement), ExpressionUtils.toExpression(pathMetadata.getElement()))); replacements.put(expr, replacement); } return replacement; } else { return super.visit(expr, context); } }
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 operation(String.class, Ops.CONCAT, lhs, rhs);
@SuppressWarnings("unchecked") @Nullable protected Predicate createJoinFilter(QueryMetadata metadata) { Multimap<Expression<?>, Predicate> predicates = HashMultimap.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<? extends Object> ids = getIds(target.getType(), filter); if (ids.isEmpty()) { throw new NoResults(); } Path<?> path = ExpressionUtils.path(String.class, source, "$id"); predicates.put(source.getRoot(), ExpressionUtils.in((Path<Object>) path, ids)); } Path<?> source = (Path) ((Operation) joins.get(0).getTarget()).getArg(0); return allOf(predicates.get(source.getRoot())); }
@SuppressWarnings("unchecked") @Override public Expression<?> visit(Operation<?> expr, @Nullable Void context) { if (expr.getOperator() == Ops.CONTAINS_KEY) { ParameterizedExpression map = (ParameterizedExpression<?>) expr.getArg(0); Expression key = expr.getArg(1); Path replacement = ExpressionUtils.path(map.getParameter(1), ExpressionUtils.createRootVariable((Path<?>) map, Math.abs(expr.hashCode()))); metadata.addJoin(JoinType.LEFTJOIN, ExpressionUtils.as(map, replacement)); metadata.addJoinCondition(ExpressionUtils.eq( Expressions.operation(map.getParameter(0), JPQLOps.KEY, replacement), key)); return ExpressionUtils.isNotNull(replacement); } else if (expr.getOperator() == Ops.CONTAINS_VALUE) { ParameterizedExpression<?> map = (ParameterizedExpression<?>) expr.getArg(0); Expression<?> value = expr.getArg(1); return Expressions.predicate(JPQLOps.MEMBER_OF, value, map); } else { return super.visit(expr, context); } }
@Override public Expression<?> visit(Operation<?> expr, C context) { ImmutableList<Expression<?>> args = visit(expr.getArgs(), context); if (args.equals(expr.getArgs())) { return expr; } else if (expr instanceof Predicate) { return ExpressionUtils.predicate(expr.getOperator(), args); } else { return ExpressionUtils.operation(expr.getType(), expr.getOperator(), args); } }
private Predicate allOf(Collection<Predicate> predicates) { return predicates != null ? ExpressionUtils.allOf(predicates) : null; }
/** * Create a {@code left in right} expression * * @param <D> type of expressions * @param left lhs of expression * @param right rhs of expression * @return left in right */ public static <D> Predicate in(Expression<D> left, SubQueryExpression<? extends D> right) { return predicate(Ops.IN, left, right); }
@SuppressWarnings("unchecked") protected <D> Expression<D> createAlias(Expression<?> expr, Path<D> alias) { assertRoot(alias); return ExpressionUtils.as((Expression) expr, alias); }
@SuppressWarnings("unchecked") private void addCondition(Context context, int i, Path<?> path, boolean where) { paths.add(path); EntityPath<?> alias = context.replacements.get(i); leftJoin((Expression) path.getMetadata().getParent(), context.replacements.get(i)); Expression index = ExpressionUtils.operation(Integer.class, JPQLOps.INDEX, alias); Object element = path.getMetadata().getElement(); if (!(element instanceof Expression)) { element = ConstantImpl.create(element); } Predicate condition = ExpressionUtils.eq(index, (Expression) element); if (where) { super.where(condition); } else { super.having(condition); } }
@SuppressWarnings("unchecked") public Predicate on(RelationalPath<E> entity) { BooleanBuilder builder = new BooleanBuilder(); for (int i = 0; i < localColumns.size(); i++) { Expression<Object> local = (Expression<Object>) localColumns.get(i); Expression<?> foreign = ExpressionUtils.path(local.getType(), entity, foreignColumns.get(i)); builder.and(ExpressionUtils.eq(local,foreign)); } return builder.getValue(); }
@SuppressWarnings("unchecked") @Override protected Predicate exists(Context c, Predicate condition) { JPAQueryMixin<?> query = new JPAQueryMixin<Object>(); query.setProjection(Expressions.ONE); for (int i = 0; i < c.paths.size(); i++) { Path<?> child = c.paths.get(i).getMetadata().getParent(); EntityPath<Object> replacement = (EntityPath<Object>) c.replacements.get(i); if (c.paths.get(i).getType().isAnnotationPresent(Entity.class)) { query.addJoin(i == 0 ? JoinType.DEFAULT : JoinType.INNERJOIN, Expressions.as( Expressions.listPath((Class) c.paths.get(i).getType(), SimplePath.class, child.getMetadata()), replacement)); } else { // join via parent Path<?> parent = child.getMetadata().getParent(); EntityPathBase<Object> newParent = new EntityPathBase<Object>(parent.getType(), ExpressionUtils.createRootVariable(parent, Math.abs(condition.hashCode()))); EntityPath<Object> newChild = new EntityPathBase<Object>(child.getType(), PathMetadataFactory.forProperty(newParent, child.getMetadata().getName())); query.from(newParent); query.addJoin(JoinType.INNERJOIN, Expressions.as(newChild, replacement)); query.where(ExpressionUtils.eq(newParent, parent)); } } c.clear(); query.where(condition); return ExpressionUtils.predicate(Ops.EXISTS, asExpression(query.getMetadata())); }
/** * Create a {@code left in right or...} expression for each list * * @param <D> element type * @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; }
/** * Create a {@code left == constant} expression * * @param <D> type of expressions * @param left lhs of expression * @param constant rhs of expression * @return left == constant */ public static <D> Predicate eqConst(Expression<D> left, D constant) { return eq(left, ConstantImpl.create(constant)); }