/** * Negates the given {@link Specification}. * * @param <T> * @param spec can be {@literal null}. * @return * @since 2.0 */ static <T> Specification<T> not(@Nullable Specification<T> spec) { return spec == null // ? (root, query, builder) -> null// : (root, query, builder) -> builder.not(spec.toPredicate(root, query, builder)); }
} else if (op == Op.NOT_IN) { assert vals.length !=0 : String.format("Op.NOT_IN needs more than one value, but %s given", vals.length); preds.add(_builder.not(p.in(vals))); } else if (op == Op.NULL) { preds.add(_builder.isNull(p));
or = theBuilder.not(or); if (modifier == TokenParamModifier.NOT) { Predicate identityPredicate = theBuilder.equal(theFrom.get("myHashIdentity").as(Long.class), BaseResourceIndexedSearchParam.calculateHashIdentity(theResourceName, theParamName)); Predicate disjunctionPredicate = theBuilder.not(predicate); predicate = theBuilder.and(identityPredicate, disjunctionPredicate);
protected <T> void applyLimitedInClause(List<Long> ids, CriteriaBuilder builder, Root<T> root, List<Predicate> restrictions) { List<List<Long>> listsOfExcludeIds = Lists.partition(ids, RESTRICT_IN_CLAUSE_MAX_SIZE); List<Predicate> inRestrictions = new ArrayList<Predicate>(); for (List<Long> idSetToExclude : listsOfExcludeIds) { inRestrictions.add(builder.not(root.get("id").in(idSetToExclude))); } restrictions.add(builder.and(inRestrictions.toArray(new Predicate[inRestrictions.size()]))); }
subQ.select(subQfrom.get("myResourceId").as(Long.class)); myPredicates.add(myBuilder.not(myBuilder.in(myResourceTableRoot.get("myId")).value(subQ)));
/** * {@link Specification} for retrieving {@link Target}s by "not equal to * given {@link TargetUpdateStatus}". * * @param updateStatus * to be filtered on * * @return the {@link Target} {@link Specification} */ public static Specification<JpaTarget> notEqualToTargetUpdateStatus(final TargetUpdateStatus updateStatus) { return (targetRoot, query, cb) -> cb.not(cb.equal(targetRoot.get(JpaTarget_.updateStatus), updateStatus)); }
CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<MainGroup> query = cb.createQuery(MainGroup.class); Root<MainGroup> root = query.from(MainGroup.class); query.select(root); Subquery<Long> subquery = query.subquery(Long.class); Root<MainGroup> subRoot = subquery.from(MainGroup.class); subquery.select(subRoot.<Long>get("id")); Join<Holiday, Holiday> maingroups = subRoot.join("listHolidays"); subquery.where(cb.equal(maingroups.get("id"), holidayId)); query.where(cb.not(cb.in(root.get("id")).value(subquery))); TypedQuery<MainGroup> typedQuery = em.createQuery(query); List<MainGroup> result = typedQuery.getResultList();
/** * Adds a JPA Subquery to the predicates. * * @param subquery the subquery to add. */ void addNotExistsSubquery(Subquery<?> subquery) { predicates.add(builder.not( builder.exists(subquery)) ); }
@Override public Predicate build(final CriteriaBuilder cb, final Expression<?> x, final Object y) { final Predicate predicate = super.build(cb, x, y); final Predicate negate = cb.not(predicate); return negate; }
private Predicate getOutPredicate(final List<Object> transformedValues, final Path<Object> fieldPath) { final List<String> outParams = new ArrayList<>(); for (final Object param : transformedValues) { if (param instanceof String) { outParams.add(((String) param).toUpperCase()); } } if (!outParams.isEmpty()) { return cb.not(cb.upper(pathOfString(fieldPath)).in(outParams)); } else { return cb.not(fieldPath.in(transformedValues)); } }
/** * Add a Field Search Condition that will check if the id field exists in an array of values. eg. {@code field IN (values)} * * @param property The field id as defined in the Entity mapping class. * @param values The List of Ids to be compared to. */ protected void addIdNotInCollectionCondition(final Expression<?> property, final Collection<?> values) { if (values != null && !values.isEmpty()) { fieldConditions.add(getCriteriaBuilder().not(property.in(values))); } }
@Override @SuppressWarnings("unchecked") public Predicate build(Expression<?> path, CriteriaBuilder criteriaBuilder, ParameterBuilder parameterBuilder) { Predicate predicate = criteriaBuilder.isTrue((Expression<Boolean>) path); return getValue() ? predicate : criteriaBuilder.not(predicate); }
private void addTranslationMissingPredicate(KeySearchCriteria criteria, List<Predicate> predicates, String locale) { if (locale != null && criteria.getMissing() != null) { // SubQuery to find all the key which get a translation for the default locale //noinspection unchecked Subquery<String> keysWithTranslation = getAllKeysWithTranslationFor(locale); // Find all keys not in the above subQuery, ie. all the keys missing predicates.add(criteriaBuilder.not(criteriaBuilder.in(keyRoot.get(ENTITY_ID)).value(keysWithTranslation))); } }
public final Expression<Boolean> convert(final JPAUnaryBooleanOperatorImp jpaOperator) throws ODataApplicationException { if (jpaOperator.getOperator() == UnaryOperatorKind.NOT) return cb.not(jpaOperator.getLeft()); return dbConverter.convert(jpaOperator); }
/** * {@inheritDoc} */ @Override protected void addNotIn(TranslationContext criteria, String propertyPath, Collection values) { criteria.addPredicate(criteria.builder.not(criteria.attr(propertyPath).in(values))); }
@Override public Predicate toPredicate(Root<Privilege> root, CriteriaQuery<?> query, CriteriaBuilder builder) { Predicate predicate = buildPredicatesFromFilters(groupFilter, root, query, builder); Subquery<RoleR2Privilege> sq = query.subquery(RoleR2Privilege.class); Root<RoleR2Privilege> r2 = sq.from(RoleR2Privilege.class); sq.where(builder.equal(r2.get("privilege"), root), builder.equal(r2.get("role").get("id"), roleId)).select(r2); return builder.and(predicate, builder.not(builder.exists(sq))); } };
@Override public Predicate getNotMatchingLocaleString(final String locale) { final CriteriaBuilder criteriaBuilder = getCriteriaBuilder(); final Subquery<LanguageImage> subquery = getCriteriaQuery().subquery(LanguageImage.class); final Root<LanguageImage> from = subquery.from(LanguageImage.class); final Predicate languageImageEqual = criteriaBuilder.equal(getRootPath(), from.get("imageFile")); final Predicate localeEqual = criteriaBuilder.equal(from.get("locale").get("value"), locale); subquery.where(criteriaBuilder.and(languageImageEqual, localeEqual)); return criteriaBuilder.not(criteriaBuilder.exists(subquery)); }
@Override public Predicate getNotMatchTagString(final Integer tagId) { final CriteriaBuilder criteriaBuilder = getCriteriaBuilder(); final Subquery<TopicToTag> subQuery = getCriteriaQuery().subquery(TopicToTag.class); final Root<TopicToTag> from = subQuery.from(TopicToTag.class); final Predicate topic = criteriaBuilder.equal(from.get("topic"), getRootPath()); final Predicate tag = criteriaBuilder.equal(from.get("tag").get("tagId"), tagId); subQuery.select(from); subQuery.where(criteriaBuilder.and(topic, tag)); return criteriaBuilder.not(criteriaBuilder.exists(subQuery)); }
@Override public Predicate getNotMatchTagString(final Integer tagId) { final CriteriaBuilder criteriaBuilder = getCriteriaBuilder(); final Subquery<TopicToTag> subQuery = getCriteriaQuery().subquery(TopicToTag.class); final Root<TopicToTag> from = subQuery.from(TopicToTag.class); final Predicate topic = criteriaBuilder.equal(from.get("topic").get("topicId"), translatedTopic.get("topicId")); final Predicate tag = criteriaBuilder.equal(from.get("tag").get("tagId"), tagId); subQuery.select(from); subQuery.where(criteriaBuilder.and(topic, tag)); return criteriaBuilder.not(criteriaBuilder.exists(subQuery)); }
@Override public Expression<Boolean> get() throws ODataApplicationException { final CriteriaBuilder cb = converter.cb; return cb.and(cb.exists(getExistsQuery()), cb.not(cb.exists(getNotExistsQuery()))); }