In JPA 2, ein CriteriaQuery verwenden, wie die Ergebnisse zählen

Question

Ich bin ziemlich neu in JPA 2 und es ist CriteriaBuilder/CriteriaQuery API:

CriteriaQuery javadoc

CriteriaQuery in the Java EE 6 tutorial

Ich möchte die Ergebnisse zählen einer CriteriaQuery, ohne sie tatsächlich abzurufen. Ist das möglich, ich habe keine solche Methode finden, ist der einzige Weg wäre, dies zu tun:

CriteriaBuilder cb = entityManager.getCriteriaBuilder(); 

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

// initialize predicates here 

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

Und das kann nicht der richtige Weg, es zu tun ...

Gibt es ein Lösung?

Answer 1

Eine Abfrage des Typs MyEntity wird MyEntity zurückzukehren. Sie möchten eine Abfrage für eine .

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(); 

Offensichtlich werden Sie Ihren Ausdruck mit den im Beispiel übersprungenen Einschränkungen und Gruppierungen etc. aufbauen wollen.

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

Verwenden Sie countDistinct anstelle von count.

Answer 4

ich die cb.createQuery mit diesem heraus sortiert haben() (ohne den Ergebnistyp Parameter):

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(); 
    } 
} 

Hoffe, es hilft :)

Answer 5

Es ist ein bisschen schwierig ist, auf die je JPA 2 Implementierung Sie verwenden, diese funktioniert für Eclipse 2.4.1, aber nicht für Hibernate, hier eine allgemeine CriteriaQuery Zahl für 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

Wie andere Antworten sind richtig, aber zu einfach, so zur Vollständigkeit präsentiere ich unten Codeausschnitt, um SELECT COUNT auf einer ausgefeilten JPA Kriterienabfrage durchzuführen (mit mehrfachen Verbindungen, Fetches, Bedingungen).

Es ist leicht modifiziert 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); 
    } 
} 

Ich hoffe, es spart jemand Zeit.

Da IMHO JPA-Kriterien-API ist nicht intuitiv noch gut lesbar.

Answer 7

Sie können auch Projektionen verwenden:

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

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