En JPA 2, à l'aide d'un CriteriaQuery, comment calculer le nombre de résultats

Je suis plutôt nouvelle pour JPA 2 et c'est CriteriaBuilder /CriteriaQuery API:

CriteriaQuery javadoc

CriteriaQuery dans le tutoriel Java EE 6

Je voudrais compter les résultats d'une CriteriaQuery sans réellement à les retrouver. Est-ce possible, je n'ai pas trouvé une telle méthode, le seul moyen serait de faire:

CriteriaBuilder cb = entityManager.getCriteriaBuilder();

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

//initialize predicates here

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

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

Est-il une solution?

  • Il serait très utile si quelqu'un peut aider ou de les inclure dans les réponses ci-dessous. Comment atteindre suivantes compter de la requête en utilisant JPA critères de l'API? select count(distinct col1, col2, col3) from ma_table;
InformationsquelleAutor Sean Patrick Floyd | 2010-05-21
  1. 193

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

    Évidemment, vous voulez construire votre expression avec toutes les restrictions et les groupements etc vous avez sauté dans l'exemple.

    • C'est ce que j'avais compris moi-même, merci. Mais cela signifie que je ne peux pas utiliser la même requête en instance à la requête pour le nombre de résultats et les résultats réels qui je sais est analogue à SQL, mais qui ferait de cette API beaucoup plus de la programmation orientée objet-comme. Eh bien, au moins je peux réutiliser certains des prédicats, je suppose.
    • si c'est un assez grand comte, vous ne voulez probablement pas à charger une liste de centaines ou de milliers d'entités en mémoire juste pour savoir combien il y en a!
    • il est utilisé en cas de pagination beaucoup. D'où la nécessité pour un nombre total et seulement un sous-ensemble des lignes réelles.
    • L'esprit que le qb.count est fait sur la Root<MyEntity> de votre requête (Root<MyEntity> myEntity = cq.à partir de(MyEntity.class)) et c'est souvent déjà dans votre normale sélectionnez le code et quand vous l'oubliez, vous vous retrouvez avec une jointure de soi.
    • Pour réutiliser les mêmes critères pour la récupération d'objets et le nombre vous pourriez avoir besoin d'utiliser des pseudonymes sur la racine, voir forum.hibernate.org/viewtopic.php?p=2471522#p2471522 pour un exemple.
    • ce code était d'accord avec moi quand j'ai eu une clé primaire, quand j'ai une clé primaire composite (à l'aide de l'Id de classe ou intégrable ), j'ai eu une exception, toute l'adea pourquoi?
    • Pas de travail pour moi avec la condition where. Il me donne le nombre total d'enregistrements de la table. Ignorant où la condition, aucune raison pour que?

    InformationsquelleAutor Affe
  2. 30

    J'ai trié ce à l'aide de la cb.createQuery() (sans le résultat de paramètre de type):

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

    Espère que cela aide 🙂

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

return em.createQuery(cq).getSingleResult();
    InformationsquelleAutor axtavt
  4. 10

    Que d'autres réponses sont correctes, mais trop simple, donc, pour être complet, je vais présenter ci-dessous un extrait de code pour effectuer SELECT COUNT sur un sophistiqué JPA Critères de la requête (avec plusieurs jointures, les extractions, les conditions).

    Il est légèrement modifié cette réponse.

    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ère qu'il sauve quelqu'un moment.

    Parce que à mon humble avis JPA Critères de l'API n'est pas intuitif, ni tout à fait lisible.

    • bien sûr, il n'est pas parfait - par exemple la solution ci-dessus est toujours manquant récursive des jointures sur les extractions. Mais pensez-vous que juste parce que de ce que je ne devrais pas partager mes pensées? À mon humble avis, le partage des connaissances est l'idée principale derrière StackOverfow.
    • La récursivité sur les bases de données sont toujours la pire solution possible et imaginables ... c'est une des débutants erreur.
    • sur les bases de données? Je parlais de la récursivité sur le niveau de l'API. Ne confondez pas ces concepts 🙂 JPA est livré avec très puissant/ complexe API qui permet de faire plusieurs jointures/ extrait/ agrégations/ alias etc dans une seule requête. Vous avez à traiter avec elle lors du dépouillement.
    • Apparemment vous n'avez pas encore compris comment JPA œuvres - la grande majorité critères seront mappées sur approprié requêtes de base de données, y compris ces (très bizarre) rejoint. Activer SQL de sortie et d'observer votre erreur - il n'y a pas de "couche API", JPA est une couche d'ABSTRACTION
    • très probablement, vous allez voir beaucoup de cascade Rejoint - parce que JPA cant encore de créer des fonctions SQL automatiquement; mais qui va changer parfois ... probablement avec JPA 3, je me souviens de discussions à propos de ces choses
    • Laissez-nous continuer cette discussion dans le chat.

    InformationsquelleAutor G. Demecki
  5. 3

    C'est un peu délicat, en fonction de la JPA 2 application que vous utilisez, celui-ci travaille pour EclipseLink 2.4.1, mais n'a pas pour Hibernate, voici un générique CriteriaQuery compter 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é à partir de EclipseLink pour Hiberner et dû changer ma fonction de comptage pour le suivant, donc n'hésitez pas à utiliser car c'est un problème difficile à résoudre, il pourrait ne pas fonctionner pour votre cas, il a été en usage depuis Hibernate 4.x, notez que je n'essayez pas de deviner qui est la racine, au lieu de cela je le passe à partir de la requête si le problème est résolu, trop ambigu cas du coin 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();
}
    • que faire si la requête a join(s)?
    • Je pense que le seul cas qui serait dangereux, c'est quand vous avez une jointure gauche et la cueillies à la racine n'est pas la principale entité. Sinon, il n'a pas d'importance, parce que le comte sera le même quel que soit le repris de l'entité. Comme pour left join entités, je suis tout à fait sûr de la première entité dans le select est la référence, par exemple, si vous avez des étudiants left join cours en choissant l'étudiant devrait être la chose naturelle, car il pourrait y avoir des cours que l'étudiant n'est pas inscrit.
    • Si la requête d'origine est groupBy requête, le résultat serait un chef d'accusation pour chaque groupe. Si nous pouvons faire un CriteriaQuery dans une sous-Requête, puis de compter le sous-requête, ce serait dans tous les cas. Pouvons-nous le faire?
    • Salut @Dave, je suis arrivé à la même conclusion que vous, la vraie solution serait d'être capable de transformer les requêtes dans les sous-requêtes, qui pourrait fonctionner pour tous les cas, même pour le comptage des lignes après un groupBy. En fait, je n'arrive pas à trouver une raison pour expliquer pourquoi les différents clases pour CriteriaQuery et sous-Requête, ou à lea le fait que l'interface commune qu'ils partagent, AbstractQuery, ne permet pas de définir une méthode de sélection. De ce fait, il n'y a aucun moyen de la réutilisation de presque rien. Avez vous trouver une solution propre pour la réutilisation d'une groupped par requête pour compter les lignes?
    InformationsquelleAutor Guido Medina
  6. 1

    Vous pouvez également utiliser des Projections:

    ProjectionList projection = Projections.projectionList();
projection.add(Projections.rowCount());
criteria.setProjection(projection);
Long totalRows = (Long) criteria.list().get(0);
    • J'ai peur des Projections de l'API Hibernate est spécifique, mais la question se pose au sujet de JPA 2.
    • Pourtant, je trouve un complément utile, mais peut-être qu'il aurait dû être un commentaire. Pouvez-vous développer votre réponse à inclure la pleine mise en veille prolongée-réponse spécifique?
    • gersonZaragocin d'accord, mais il n'y a pas de blocs de code dans les commentaires
    InformationsquelleAutor Pavel Evstigneev