/** * 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)); }
@Test public void eq() { assertEquals("str = str2", ExpressionUtils.eq(str, str2).toString()); }
/** * 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)); }
@SuppressWarnings("unchecked") protected 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))); } } } }
@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") 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") @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())); }
@Override public Page<? extends ServiceLevelAssessment> findAll(String filter, Pageable pageable) { QJpaServiceLevelAssessment serviceLevelAssessment = QJpaServiceLevelAssessment.jpaServiceLevelAssessment; pageable = CommonFilterTranslations.resolveSortFilters(serviceLevelAssessment, pageable); QJpaObligationAssessment obligationAssessment = new QJpaObligationAssessment("obligationAssessment"); QJpaMetricAssessment metricAssessment = new QJpaMetricAssessment("metricAssessment"); QJpaServiceLevelAgreementDescription serviceLevelAgreementDescription = new QJpaServiceLevelAgreementDescription("slaDescription"); QJpaOpsManagerFeed feed = new QJpaOpsManagerFeed("feed"); BooleanBuilder assessmentPredicate = GenericQueryDslFilter.buildFilter(serviceLevelAssessment, filter); BooleanBuilder feedPredicate = GenericQueryDslFilter.buildFilter(feed, filter); boolean invalidQuery = false; //if there is not predicate found for the supplied 'filter' then fail the query if (StringUtils.isNotBlank(filter) && (!assessmentPredicate.hasValue() && !feedPredicate.hasValue())) { invalidQuery = true; } BooleanBuilder predicate = assessmentPredicate.and(feedPredicate); if (invalidQuery) { predicate.and(ExpressionUtils.eq(ConstantImpl.create("1"), ConstantImpl.create("2"))); } predicate.and(feed.isNull().or(feed.isNotNull().and(FeedAclIndexQueryAugmentor.generateExistsExpression(feed.id, accessController.isEntityAccessControlled())))); return findAllWithFetch(serviceLevelAssessment, predicate, true, pageable, QueryDslFetchJoin.innerJoin(serviceLevelAssessment.serviceLevelAgreementDescription, serviceLevelAgreementDescription), QueryDslFetchJoin.leftJoin(serviceLevelAgreementDescription.feeds, feed), QueryDslFetchJoin.leftJoin(serviceLevelAssessment.obligationAssessments, obligationAssessment), QueryDslFetchJoin.leftJoin(obligationAssessment.metricAssessments, metricAssessment)); }