@Override public Map<Long, String> retrieveSandboxNamesForSandBoxes(Set<Long> sandBoxIds) { CriteriaBuilder builder = sandBoxEntityManager.getCriteriaBuilder(); CriteriaQuery<SandBox> criteria = builder.createQuery(SandBox.class); Root<SandBoxManagementImpl> sandbox = criteria.from(SandBoxManagementImpl.class); criteria.select(sandbox.get("sandBox").as(SandBox.class)); criteria.where( builder.and(builder.in(sandbox.get("sandBox").get("id")).value(sandBoxIds), builder.or(builder.isNull(sandbox.get("sandBox").get("archiveStatus").get("archived").as(String.class)), builder.notEqual(sandbox.get("sandBox").get("archiveStatus").get("archived").as(Character.class), 'Y'))) ); TypedQuery<SandBox> query = sandBoxEntityManager.createQuery(criteria); List<SandBox> results = query.getResultList(); Map<Long, String> map = new HashMap<Long, String>(); for (SandBox result : results) { map.put(result.getId(), result.getName()); } return map; }
throw new IllegalStateException("Unexpected " + varIdField.getClass().getName() + " when processing last variable query criteria!"); predicate = builder.in(expr).value(maxIdSubQuery); } else if( VAR_VALUE_ID_LIST.equals(criteria.getListId()) ) { assert criteria.getValues().size() == 1 : "Only 1 var id/value parameter expected!";
subQ.select(subQfrom.get("myResourceId").as(Long.class)); myPredicates.add(myBuilder.not(myBuilder.in(myResourceTableRoot.get("myId")).value(subQ)));
private static Predicate addTags(CriteriaBuilder cb, Root<News> news, SearchCriteria sc) { In<Object> in = cb.in(news.get("tagsSet").get("id")); for (Long id : sc.getTagIdsSet()) { in = in.value(id); } return in; }
final Path<String> valueExpression = theFrom.get("myValue"); for (Map.Entry<String, List<VersionIndependentConcept>> entry : map.entrySet()) { CriteriaBuilder.In<String> codePredicate = theBuilder.in(valueExpression); boolean haveAtLeastOneCode = false; for (VersionIndependentConcept nextCode : entry.getValue()) {
CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<User> cq = cb.createQuery(User.class); Root<User> user = cq.from(User.class); cq.select(user); cq.where(cb.in(user.get(User_.email)).value("john@google.com")); TypedQuery<User> q = em.createQuery(cq); List<User> allUsers = q.getResultList(); assertEquals(1, allUsers.size());
CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<News> cq = cb.createQuery(News.class); Root<News> news = cq.from(News.class); if (!parameters.get("author").isEmpty()) { cq.where(cb.in(news.get("author"), parameters.get("author")); } TypedQuery<News> query = em.createQuery(cq); return query.getResultList();
CriteriaBuilder criteriaBuilder = getEm().getCriteriaBuilder(); CriteriaQuery<Class1> criteriaQuery = criteriaBuilder.createQuery(Class1.class); Root<Class1> fromClass1 = criteriaQuery.from(Class1.class); List<Predicate> conditions = new ArrayList<Predicate>(); Subquery<Class2> qry = criteriaQuery.subquery(Class2.class); Root<Class2> fromClass2 = qry.from(Class2.class); qry.select(fromClass2); qry.where(criteriaBuilder.equal(fromClass2.get(Class2_.getId()), idParamGoesHere)); conditions.add(criteriaBuilder.in(.get(Class1_.getClass2()).value(qry)); criteriaQuery.where(conditions.toArray(new Predicate[0])); TypedQuery<Class1> query = getEm().createQuery(criteriaQuery); List<Class1> results = query.getResultList();
// inner query CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<YourClass> innerCriteriaQuery = cb.createQuery(YourClass.class); Root<YourClass> yourClass = innerCriteriaQuery.from(YourClass.class); innerCriteriaQuery.select(yourClass).where( cb.equal(yourClass.get(YourClass_.stateCode), someStateValue)); // list of 100 parent ids List<YourClass> list = em.createQuery(innerCriteriaQuery).setMaxResults(100).getResultList(); // outer query CriteriaQuery<YourClass> criteriaQuery = cb.createQuery(YourClass.class); Root<YourClass> yourClass = criteriaQuery.from(YourClass.class); criteriaQuery.select(yourClass).where( cb.in(yourClass.get(YourClass_.parentId)).value(list); return em.createQuery(criteriaQuery).getResultList();
Predicate compare(CriteriaBuilder builder, Expression expression, Object object) { return builder.in(expression).value(object); } };
protected <X> Specification<ENTITY> valueIn(SingularAttribute<? super ENTITY, X> field, final Collection<X> values) { return (root, query, builder) -> { In<X> in = builder.in(root.get(field)); for (X value : values) { in = in.value(value); } return in; }; }
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();
CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<News> cq = cb.createQuery(News.class); Root<News> news = cq.from(News.class); List<Predicate> predicates = new ArrayList<Predicate>(); if (!parameters.get("author").isEmpty()) { predicates.add(cb.in(news.get("author"), parameters.get("author"))); } // Other params here. cq.where(cb.and(predicates.toArray(new Predicate[predicates.size()])); TypedQuery<News> query = em.createQuery(cq); return query.getResultList();
protected <X> Specification<ENTITY> valueIn(Function<Root<ENTITY>, Expression<X>> metaclassFunction, final Collection<X> values) { return (root, query, builder) -> { In<X> in = builder.in(metaclassFunction.apply(root)); for (X value : values) { in = in.value(value); } return in; }; }
private <T extends ResourceEntity> long getTotalResults(Class<T> clazz, Subquery<Long> internalIdQuery) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Long> resourceQuery = cb.createQuery(Long.class); Root<T> resourceRoot = resourceQuery.from(clazz); resourceQuery.select(cb.count(resourceRoot)).where( cb.in(resourceRoot.get(ResourceEntity_.internalId)).value(internalIdQuery)); Long total = em.createQuery(resourceQuery).getSingleResult(); return total; }
protected <OTHER, X> Specification<ENTITY> valueIn(SingularAttribute<? super ENTITY, OTHER> reference, SingularAttribute<OTHER, X> valueField, final Collection<X> values) { return (root, query, builder) -> { In<X> in = builder.in(root.get(reference).get(valueField)); for (X value : values) { in = in.value(value); } return in; }; }
@Override public List<Predicate> build(CriteriaBuilder builder, Path<P> path) { Path<V> p = path.get(singular); CriteriaBuilder.In<V> in = builder.in(p); for (V value : values) { if (value != null) { in.value(value); } } return Arrays.asList((Predicate) in); }
@Override public List<Predicate> build(CriteriaBuilder builder, Path<P> path) { Path<V> p = path.get(singular); CriteriaBuilder.In<V> in = builder.in(p); for (V value : values) { if (value != null) { in.value(value); } } return Arrays.asList((Predicate) in); }
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 static Predicate createAttributeInPredicate(final CriteriaBuilder criteriaBuilder, final Path path, final SubQueryImp uaiSubQuery) { uaiSubQuery.prepareSubQuery(); return criteriaBuilder.in(path).value(uaiSubQuery.getSubQuery()); } }