@Override public Expression<?> visit(Path<?> expr, Context context) { if (expr.getMetadata().getPathType() == PathType.COLLECTION_ANY) { Path<?> parent = (Path<?>) expr.getMetadata().getParent().accept(this, context); expr = ExpressionUtils.path(expr.getType(), PathMetadataFactory.forCollectionAny(parent)); EntityPath<?> replacement = new EntityPathBase<Object>(expr.getType(), ExpressionUtils.createRootVariable(expr, replacedCounter++)); context.add(expr, replacement); return replacement; } else if (expr.getMetadata().getParent() != null) { Context c = new Context(); Path<?> parent = (Path<?>) expr.getMetadata().getParent().accept(this, c); if (c.replace) { context.add(c); return replaceParent(expr, parent); } } return expr; }
@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); } }
@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.MAPVALUE || pathMetadata.getPathType() == PathType.MAPVALUE_CONSTANT) { Path<?> replacement = replacements.get(expr); if (replacement == null) { // join parent as path123 on key(path123) = ... Path parent = shorten(pathMetadata.getParent(), true); ParameterizedExpression parExpr = (ParameterizedExpression) pathMetadata.getParent(); replacement = ExpressionUtils.path(parExpr.getParameter(1), ExpressionUtils.createRootVariable(parent, replacements.size())); metadata.addJoin(JoinType.LEFTJOIN, ExpressionUtils.as(parent, replacement)); metadata.addJoinCondition(ExpressionUtils.eq( Expressions.operation(parExpr.getParameter(0), JPQLOps.KEY, replacement), ExpressionUtils.toExpression(pathMetadata.getElement()))); replacements.put(expr, replacement); } return replacement; } else { return super.visit(expr, context); } }
@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); } }
@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())); }
Path<T> newPath = ExpressionUtils.path(type, ExpressionUtils.createRootVariable(path)); leftJoin(path, newPath); return newPath; Path<T> oldPath = ExpressionUtils.path(path.getType(), new PathMetadata(parent, metadata.getElement(), metadata.getPathType())); Path<T> newPath = ExpressionUtils.path(type, ExpressionUtils.createRootVariable(oldPath)); aliases.put(path, newPath); leftJoin(oldPath, newPath);
/** * Shorten the parent path to a length of max 2 elements */ private Path<?> shorten(Path<?> path, boolean outer) { if (aliases.containsKey(path)) { return aliases.get(path); } else if (path.getMetadata().isRoot()) { return path; } else if (path.getMetadata().getParent().getMetadata().isRoot() && outer) { return path; } else { Class<?> type = JPAQueryMixin.getElementTypeOrType(path); Path<?> parent = shorten(path.getMetadata().getParent(), false); Path oldPath = ExpressionUtils.path(path.getType(), new PathMetadata(parent, path.getMetadata().getElement(), path.getMetadata().getPathType())); if (oldPath.getMetadata().getParent().getMetadata().isRoot() && outer) { return oldPath; } else { Path newPath = ExpressionUtils.path(type, ExpressionUtils.createRootVariable(oldPath)); aliases.put(path, newPath); metadata.addJoin(JoinType.LEFTJOIN, ExpressionUtils.as(oldPath, newPath)); return newPath; } } }
/** * Shorten the parent path to a length of max 2 elements */ private Path<?> shorten(Path<?> path, boolean outer) { if (aliases.containsKey(path)) { return aliases.get(path); } else if (path.getMetadata().isRoot()) { return path; } else if (path.getMetadata().getParent().getMetadata().isRoot() && outer) { return path; } else { Class<?> type = JPAQueryMixin.getElementTypeOrType(path); Path<?> parent = shorten(path.getMetadata().getParent(), false); Path oldPath = ExpressionUtils.path(path.getType(), new PathMetadata(parent, path.getMetadata().getElement(), path.getMetadata().getPathType())); if (oldPath.getMetadata().getParent().getMetadata().isRoot() && outer) { return oldPath; } else { Path newPath = ExpressionUtils.path(type, ExpressionUtils.createRootVariable(oldPath)); aliases.put(path, newPath); metadata.addJoin(JoinType.LEFTJOIN, ExpressionUtils.as(oldPath, newPath)); return newPath; } } }
@Override public Expression<?> visit(Path<?> expr, Context context) { if (expr.getMetadata().getPathType() == PathType.COLLECTION_ANY) { Path<?> parent = (Path<?>) expr.getMetadata().getParent().accept(this, context); expr = ExpressionUtils.path(expr.getType(), PathMetadataFactory.forCollectionAny(parent)); EntityPath<?> replacement = new EntityPathBase<Object>(expr.getType(), ExpressionUtils.createRootVariable(expr, replacedCounter++)); context.add(expr, replacement); return replacement; } else if (expr.getMetadata().getParent() != null) { Context c = new Context(); Path<?> parent = (Path<?>) expr.getMetadata().getParent().accept(this, c); if (c.replace) { context.add(c); return replaceParent(expr, parent); } } return expr; }