@Test public void test_criteria_from_join_example() { doInJPA( this::entityManagerFactory, entityManager -> { //tag::criteria-from-join-example[] CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<Phone> criteria = builder.createQuery( Phone.class ); Root<Phone> root = criteria.from( Phone.class ); // Phone.person is a @ManyToOne Join<Phone, Person> personJoin = root.join( Phone_.person ); // Person.addresses is an @ElementCollection Join<Person, String> addressesJoin = personJoin.join( Person_.addresses ); criteria.where( builder.isNotEmpty( root.get( Phone_.calls ) ) ); List<Phone> phones = entityManager.createQuery( criteria ).getResultList(); //end::criteria-from-join-example[] assertEquals(2, phones.size()); }); }
@Test public void test_criteria_from_fetch_example() { doInJPA( this::entityManagerFactory, entityManager -> { //tag::criteria-from-fetch-example[] CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<Phone> criteria = builder.createQuery( Phone.class ); Root<Phone> root = criteria.from( Phone.class ); // Phone.person is a @ManyToOne Fetch<Phone, Person> personFetch = root.fetch( Phone_.person ); // Person.addresses is an @ElementCollection Fetch<Person, String> addressesJoin = personFetch.fetch( Person_.addresses ); criteria.where( builder.isNotEmpty( root.get( Phone_.calls ) ) ); List<Phone> phones = entityManager.createQuery( criteria ).getResultList(); //end::criteria-from-fetch-example[] assertEquals(2, phones.size()); }); }
@Test public void test_criteria_from_multiple_root_example() { doInJPA( this::entityManagerFactory, entityManager -> { String address = "Earth"; String prefix = "J%"; //tag::criteria-from-multiple-root-example[] CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<Tuple> criteria = builder.createQuery( Tuple.class ); Root<Person> personRoot = criteria.from( Person.class ); Root<Partner> partnerRoot = criteria.from( Partner.class ); criteria.multiselect( personRoot, partnerRoot ); Predicate personRestriction = builder.and( builder.equal( personRoot.get( Person_.address ), address ), builder.isNotEmpty( personRoot.get( Person_.phones ) ) ); Predicate partnerRestriction = builder.and( builder.like( partnerRoot.get( Partner_.name ), prefix ), builder.equal( partnerRoot.get( Partner_.version ), 0 ) ); criteria.where( builder.and( personRestriction, partnerRestriction ) ); List<Tuple> tuples = entityManager.createQuery( criteria ).getResultList(); //end::criteria-from-multiple-root-example[] assertEquals(2, tuples.size()); }); }
return type.equals(IS_NOT_EMPTY) ? builder.isNotEmpty(collectionPath) : builder.isEmpty(collectionPath);
CriteriaBuilder cb = ... CriteriaQuery<UserProfile> q = cb.createQuery(UserProfile .class); Root<UserProfile> userProfile= q.from(UserProfile .class); q.select(userProfile) q.where(cb.isNotEmpty(userProfile.get("person"));
public List<Post> getMostCommentedPosts(int page, int postsPerPage){ CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Post> cq = cb.createQuery(Post.class); Root<Post> p = cq.from(Post.class); cq.select(p).where(cb.isNotEmpty(p.get("comments"))); List list = em.createQuery(cq).getResultList(); for(Set each : list) { System.out.println(each.size()); } }
protected <X> Specification<ENTITY> byFieldEmptiness(Function<Root<ENTITY>, Expression<Set<X>>> metaclassFunction, final boolean specified) { return specified ? (root, query, builder) -> builder.isNotEmpty(metaclassFunction.apply(root)) : (root, query, builder) -> builder.isEmpty(metaclassFunction.apply(root)); }
protected <X> Specification<ENTITY> byFieldSpecified(SetAttribute<ENTITY, X> field, final boolean specified) { return specified ? (root, query, builder) -> builder.isNotEmpty(root.get(field)) : (root, query, builder) -> builder.isEmpty(root.get(field)); }
@Override public List<Predicate> build(CriteriaBuilder builder, Path<E> path) { return Arrays.asList(builder.isNotEmpty(path.get(att))); }
@Override public List<Predicate> build(CriteriaBuilder builder, Path<E> path) { return Arrays.asList(builder.isNotEmpty(path.get(getAtt()))); }
@Override public List<WorkspaceItem> findWithSupervisedGroup(Context context) throws SQLException { CriteriaBuilder criteriaBuilder = getCriteriaBuilder(context); CriteriaQuery criteriaQuery = getCriteriaQuery(criteriaBuilder, WorkspaceItem.class); Root<WorkspaceItem> workspaceItemRoot = criteriaQuery.from(WorkspaceItem.class); criteriaQuery.select(workspaceItemRoot); criteriaQuery.where(criteriaBuilder.isNotEmpty(workspaceItemRoot.get(WorkspaceItem_.supervisorGroups))); List<javax.persistence.criteria.Order> orderList = new LinkedList<>(); orderList.add(criteriaBuilder.asc(workspaceItemRoot.get(WorkspaceItem_.workspaceItemId))); criteriaQuery.orderBy(orderList); return list(context, criteriaQuery, false, WorkspaceItem.class, -1, -1); }
@Override public List<ValidationRule> getValidationRulesWithNotificationTemplates() { CriteriaBuilder builder = getCriteriaBuilder(); return getList( builder, newJpaParameters() .addPredicate( root -> builder.isNotEmpty( root.get( "notificationTemplates" ) ) ) .setUseDistinct( true ) ); } }
return getCriteriaBuilder().isNotEmpty(path.as(Collection.class)); } else { return null;
return type.equals(IS_NOT_EMPTY) ? builder.isNotEmpty(collectionPath) : builder.isEmpty(collectionPath);
return builder.isNotEmpty((Expression<Collection>)path); } else { return null;