Dans JPA 2, en utilisant une CriteriaQuery, comment compter les résultats ?

Question

Je suis plutôt novice en matière de JPA 2 et de son API CriteriaBuilder / CriteriaQuery :

CriteriaQuery javadoc

CriteriaQuery dans le tutoriel Java EE 6

Je voudrais compter les résultats d'une CriteriaQuery sans les récupérer réellement. Est-ce possible, je n'ai pas trouvé de méthode de ce type, la seule façon serait de faire ceci :

CriteriaBuilder cb = entityManager.getCriteriaBuilder();

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

// initialize predicates here

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

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

Y a-t-il une solution ?

Answer 1

Une requête de type MyEntity va retourner 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();

Il est évident que vous voudrez construire votre expression avec les restrictions, les regroupements, etc. que vous avez omis dans l'exemple.

Answer 2

J'ai résolu le problème en utilisant la méthode 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();
    }
}

J'espère que cela vous aidera :)

Answer 3

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 4

C'est un peu délicat, cela dépend de l'implémentation de JPA 2 que vous utilisez, celle-ci fonctionne pour EclipseLink 2.4.1, mais pas pour Hibernate, voici un compte générique de CriteriaQuery 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();
  }

L'autre jour, j'ai migré d'EclipseLink vers Hibernate et j'ai dû changer ma fonction de comptage pour la suivante, alors n'hésitez pas à utiliser l'une ou l'autre car c'est un problème difficile à résoudre, cela peut ne pas fonctionner pour votre cas, c'est utilisé depuis Hibernate 4.x, remarquez que je n'essaie pas de deviner quelle est la racine, au lieu de cela je la passe depuis la requête, donc problème résolu, trop de cas de coin ambigus pour essayer de deviner :

  public static <T> long count(EntityManager em,Root<T> root,CriteriaQuery<T> criteria)
  {
    final CriteriaBuilder builder=em.getCriteriaBuilder();
    final CriteriaQuery<Long> countCriteria=builder.createQuery(Long.class);

    countCriteria.select(builder.count(root));

    for(Root<?> fromRoot : criteria.getRoots()){
      countCriteria.getRoots().add(fromRoot);
    }

    final Predicate whereRestriction=criteria.getRestriction();
    if(whereRestriction!=null){
      countCriteria.where(whereRestriction);
    }

    final Predicate groupRestriction=criteria.getGroupRestriction();
    if(groupRestriction!=null){
      countCriteria.having(groupRestriction);
    }

    countCriteria.groupBy(criteria.getGroupList());
    countCriteria.distinct(criteria.isDistinct());
    return em.createQuery(countCriteria).getSingleResult();
  }

Answer 5

Utilisez countDistinct au lieu de count .