Hibernate Criteria API - clause HAVING contourner

J'ai écrit une requête à l'aide de Hibernate Critères de l'API à s'emparer d'une somme d'une valeur particulière, maintenant, j'ai besoin d'être en mesure de restreindre le résultat de lignes où cette somme est supérieure ou égale à une valeur particulière.

Normalement, je voudrais utiliser une clause HAVING dans mon SQL pour ce faire, mais les Critères de l'API ne semble pas soutenir qu'en ce moment.

En raw SQL c'est ce que je dois faire:

SELECT user_pk, sum(amount) as amountSum
FROM transaction
GROUP BY user_pk
HAVING amountSum >=50;

Une façon de contourner ce que j'ai pensé est d'utiliser une sous-requête dans la clause from attrape cette sommation de la valeur et de l'utilisation d'une requête externe de la restreindre à l'aide d'une clause where.

Donc, en raw SQL il ressemblera à quelque chose comme:

SELECT user_pk, amountSum
FROM (SELECT user_pk, sum(amount) as amountSum
      FROM transaction
      GROUP BY user_pk)
WHERE amountSum > 50;

Quelqu'un peut me pointer dans la bonne direction quant à la façon dont je pourrais écrire cela à l'aide de Critères de l'API, ou d'autres suggestions/solutions de rechange que je peux utiliser pour résoudre l'AVOIR en question?

Ce sont les Critères du code de l'API que j'ai pour l'exemple ci-dessus

DetachedCriteria criteria = DetachedCriteria.forClass(Transaction.class,"transaction");
criteria.setProjection(criteria.setProjection(Projections.projectionList().add(
        Projections.groupProperty("user.userPK").as("user_pk")).add(
            Projections.sum("transaction.amount").as("amountSum")));

Merci!

source d'informationauteur user57701

  1. 8

    Je ne sais pas de manière à Hibernate/NHibernate utiliser une sous-requête dans la clause from, mais vous pouvez utiliser dans la clause where.
    Excuses pour les Java/Hibernate des erreurs dans le code, je suis plus familier avec le C#/NHibernate.

    
DetachedCriteria subQuery = DetachedCriteria.forClass(Transaction.class);
subQuery.setProjection(Projections.sum("amount"));
subQuery.add(Expression.eqProperty("userPk", "tOuter.userPk"));

DetachedCriteria outerQuery = DetachedCriteria.forClass(Transaction.class, "tOuter");
outerQuery.setProjection(Projections.projectionList()
    .Add(Projections.sum("amount").as("sumAmount"))
    .Add(Projections.groupProperty("userPk").as("user_pk"));
outerQuery.add(Subqueries.le(50, subQuery));

    Ce code devrait se traduire en SQL similaires à:

    
SELECT tOuter.userPk as user_pk, sum(tOuter.amount) as sumAmount
FROM transaction tOuter
WHERE 50 <= (SELECT sum(amount) FROM transaction WHERE userPk = tOuter.userPk)
GROUP BY tOuter.userPk

    L'inconvénient de cette approche est qu'il calcule chacun des montants deux fois, cela pourrait avoir un effet néfaste sur les performances en fonction de la quantité de données impliquées dans ce cas vous devrez utiliser une requête HQL qui prend en charge la clause HAVING.

  2. 2

    HHH-1700 a été marquée comme un double de HHH-1043, et, par conséquent, ne sera pas corrigé. Vous allez trouver ma solution et une solution de contournement, ainsi que d'autres peuples, sur HHH-1043.