En JPA 2, en utilisant un CriteriaQuery, comment compter les résultats

Question

Je suis assez nouveau pour JPA 2 et API CriteriaBuilder/de CriteriaQuery:

CriteriaQuery javadoc

CriteriaQuery in the Java EE 6 tutorial

je voudrais compter les résultats d'une CriteriaQuery sans les récupérer. Est-ce possible, je ne trouve pas une telle méthode, la seule façon serait de le faire:

CriteriaBuilder cb = entityManager.getCriteriaBuilder(); 

CriteriaQuery<MyEntity> cq = cb 
     .createQuery(MyEntityclass); 

// initialize predicates here 

return entityManager.createQuery(cq).getResultList().size(); 

Et ce ne peut pas être la bonne façon de le faire ...

Y at-il un Solution?

Answer 1

Une requête de type MyEntity va revenir MyEntity. Vous voulez une requête pour un Long.

CriteriaBuilder qb = entityManager.getCriteriaBuilder(); 
CriteriaQuery<Long> cq = qb.createQuery(Long.class); 
cq.select(qb.count(cq.from(MyEntity.class))); 
cq.where(/*your stuff*/); 
return entityManager.createQuery(cq).getSingleResult(); 

De toute évidence, vous voudrez construire votre expression avec les restrictions et les groupements etc. que vous avez omis dans l'exemple.

Answer 2

CriteriaBuilder cb = em.getCriteriaBuilder(); 
CriteriaQuery<Long> cq = cb.createQuery(Long.class); 
cq.select(cb.count(cq.from(MyEntity.class))); 

return em.createQuery(cq).getSingleResult(); 

Answer 3

Utilisez countDistinct au lieu de count.

Answer 4

J'ai triés ceci en utilisant la cb.createQuery() (sans le paramètre de type de résultat):

public class Blah() { 

    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder(); 
    CriteriaQuery query = criteriaBuilder.createQuery(); 
    Root<Entity> root; 
    Predicate whereClause; 
    EntityManager entityManager; 
    Class<Entity> domainClass; 

    ... Methods to create where clause ... 

    public Blah(EntityManager entityManager, Class<Entity> domainClass) { 
     this.entityManager = entityManager; 
     this.domainClass = domainClass; 
     criteriaBuilder = entityManager.getCriteriaBuilder(); 
     query = criteriaBuilder.createQuery(); 
     whereClause = criteriaBuilder.equal(criteriaBuilder.literal(1), 1); 
     root = query.from(domainClass); 
    } 

    public CriteriaQuery<Entity> getQuery() { 
     query.select(root); 
     query.where(whereClause); 
     return query; 
    } 

    public CriteriaQuery<Long> getQueryForCount() { 
     query.select(criteriaBuilder.count(root)); 
     query.where(whereClause); 
     return query; 
    } 

    public List<Entity> list() { 
     TypedQuery<Entity> q = this.entityManager.createQuery(this.getQuery()); 
     return q.getResultList(); 
    } 

    public Long count() { 
     TypedQuery<Long> q = this.entityManager.createQuery(this.getQueryForCount()); 
     return q.getSingleResult(); 
    } 
} 

Hope it helps :)

Answer 5

Il est un peu difficile, selon la JPA 2 mise en œuvre que vous utilisez, celui-ci travaille pour EclipseLink 2.4.1, mais ne pas Hibernate, ici un nombre de CriteriaQuery générique pour EclipseLink:

public static Long count(final EntityManager em, final CriteriaQuery<?> criteria) 
    { 
    final CriteriaBuilder builder=em.getCriteriaBuilder(); 
    final CriteriaQuery<Long> countCriteria=builder.createQuery(Long.class); 
    countCriteria.select(builder.count(criteria.getRoots().iterator().next())); 
    final Predicate 
      groupRestriction=criteria.getGroupRestriction(), 
      fromRestriction=criteria.getRestriction(); 
    if(groupRestriction != null){ 
     countCriteria.having(groupRestriction); 
    } 
    if(fromRestriction != null){ 
     countCriteria.where(fromRestriction); 
    } 
    countCriteria.groupBy(criteria.getGroupList()); 
    countCriteria.distinct(criteria.isDistinct()); 
    return em.createQuery(countCriteria).getSingleResult(); 
    } 

Answer 6

réponses Comme les autres sont corrects, mais trop simple, donc pour l'exhaustivité je présente ci-dessous l'extrait de code pour effectuer SELECT COUNT sur un sophistiqué Requête de critères JPA (avec plusieurs jointures, extractions, conditions).

Il est légèrement modifié this answer.

public <T> long count(final CriteriaBuilder cb, final CriteriaQuery<T> selectQuery, 
     Root<T> root) { 
    CriteriaQuery<Long> query = createCountQuery(cb, selectQuery, root); 
    return this.entityManager.createQuery(query).getSingleResult(); 
} 

private <T> CriteriaQuery<Long> createCountQuery(final CriteriaBuilder cb, 
     final CriteriaQuery<T> criteria, final Root<T> root) { 

    final CriteriaQuery<Long> countQuery = cb.createQuery(Long.class); 
    final Root<T> countRoot = countQuery.from(criteria.getResultType()); 

    doJoins(root.getJoins(), countRoot); 
    doJoinsOnFetches(root.getFetches(), countRoot); 

    countQuery.select(cb.count(countRoot)); 
    countQuery.where(criteria.getRestriction()); 

    countRoot.alias(root.getAlias()); 

    return countQuery.distinct(criteria.isDistinct()); 
} 

@SuppressWarnings("unchecked") 
private void doJoinsOnFetches(Set<? extends Fetch<?, ?>> joins, Root<?> root) { 
    doJoins((Set<? extends Join<?, ?>>) joins, root); 
} 

private void doJoins(Set<? extends Join<?, ?>> joins, Root<?> root) { 
    for (Join<?, ?> join : joins) { 
     Join<?, ?> joined = root.join(join.getAttribute().getName(), join.getJoinType()); 
     joined.alias(join.getAlias()); 
     doJoins(join.getJoins(), joined); 
    } 
} 

private void doJoins(Set<? extends Join<?, ?>> joins, Join<?, ?> root) { 
    for (Join<?, ?> join : joins) { 
     Join<?, ?> joined = root.join(join.getAttribute().getName(), join.getJoinType()); 
     joined.alias(join.getAlias()); 
     doJoins(join.getJoins(), joined); 
    } 
} 

Espérons que cela fasse gagner du temps à quelqu'un. Parce que l'API IMHO JPA Criteria n'est pas intuitive ni assez lisible.

Answer 7

Vous pouvez également utiliser les projections:

ProjectionList projection = Projections.projectionList(); 
projection.add(Projections.rowCount()); 
criteria.setProjection(projection); 

Long totalRows = (Long) criteria.list().get(0);