À l'aide de 'l'affaire...quand...then...else...end" construire dans le "avoir des" clause dans JPA critères de requête

C'est très rare d'être d'un bug en mode veille prolongée. Il y avait une erreur technique dans la fabrication des critères de requête donnée. En prenant le même exemple, mais dans une forme plus simple.

Supposons que nous nous intéressons à la génération de la requête SQL suivante.

SELECT
    p.prod_id,
    p.prod_name,
    CASE
        WHEN sum(r.rating_num)/count(DISTINCT r.rating_id) IS NULL THEN 0
        ELSE round(sum(r.rating_num)/count(DISTINCT r.rating_id))
    END AS avg_rating
FROM
    product p
LEFT OUTER JOIN
    rating r
        ON p.prod_id=r.prod_id
GROUP BY
    p.prod_id,
    p.prod_name 
HAVING
    CASE
        WHEN sum(r.rating_num)/count(DISTINCT r.rating_id) IS NULL THEN 0
        ELSE round(sum(r.rating_num)/count(DISTINCT r.rating_id))
    END>=1

Basé sur la table dans MySQL.

mysql> desc rating;
+-------------+---------------------+------+-----+---------+----------------+
| Field       | Type                | Null | Key | Default | Extra          |
+-------------+---------------------+------+-----+---------+----------------+
| rating_id   | bigint(20) unsigned | NO   | PRI | NULL    | auto_increment |
| prod_id     | bigint(20) unsigned | YES  | MUL | NULL    |                |
| rating_num  | int(10) unsigned    | YES  |     | NULL    |                |
| ip_address  | varchar(45)         | YES  |     | NULL    |                |
| row_version | bigint(20) unsigned | NO   |     | 0       |                |
+-------------+---------------------+------+-----+---------+----------------+
5 rows in set (0.08 sec)

Ce tableau rating a évidemment plusieurs-à-une relation avec une autre table product (prod_id est la clé étrangère référençant la clé primaire prod_id dans le product tableau).

Dans cette question, nous nous intéressons uniquement à la CASE construire dans le HAVING clause.

Les critères suivants requête,

CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<Tuple> criteriaQuery = criteriaBuilder.createTupleQuery();
Root<Product> root = criteriaQuery.from(entityManager.getMetamodel().entity(Product.class));
ListJoin<Product, Rating> prodRatingJoin = root.join(Product_.ratingList, JoinType.LEFT);
List<Expression<?>> expressions = new ArrayList<Expression<?>>();
expressions.add(root.get(Product_.prodId));
expressions.add(root.get(Product_.prodName));
Expression<Integer> sum = criteriaBuilder.sum(prodRatingJoin.get(Rating_.ratingNum));
Expression<Long> count = criteriaBuilder.countDistinct(prodRatingJoin.get(Rating_.ratingId));
Expression<Number> quotExpression = criteriaBuilder.quot(sum, count);
Expression<Integer> roundExpression = criteriaBuilder.function("round", Integer.class, quotExpression);
Expression<Integer> selectExpression = criteriaBuilder.<Integer>selectCase().when(quotExpression.isNull(), criteriaBuilder.literal(0)).otherwise(roundExpression);
expressions.add(selectExpression);
criteriaQuery.multiselect(expressions.toArray(new Expression[0]));
expressions.remove(expressions.size() - 1);
criteriaQuery.groupBy(expressions.toArray(new Expression[0]));
criteriaQuery.having(criteriaBuilder.greaterThanOrEqualTo(selectExpression, criteriaBuilder.literal(1)));
List<Tuple> list = entityManager.createQuery(criteriaQuery).getResultList();
for (Tuple tuple : list) {
System.out.println(tuple.get(0) + " : " + tuple.get(1) + " : " + tuple.get(2));
}

Génère la suite de corriger les requêtes SQL comme prévu.

select
product0_.prod_id as col_0_0_,
product0_.prod_name as col_1_0_,
case 
when sum(ratinglist1_.rating_num)/count(distinct ratinglist1_.rating_id) is null then 0 
else round(sum(ratinglist1_.rating_num)/count(distinct ratinglist1_.rating_id)) 
end as col_2_0_ 
from
projectdb.product product0_ 
left outer join
projectdb.rating ratinglist1_ 
on product0_.prod_id=ratinglist1_.prod_id 
group by
product0_.prod_id ,
product0_.prod_name 
having
case 
when sum(ratinglist1_.rating_num)/count(distinct ratinglist1_.rating_id) is null then 0 
else round(sum(ratinglist1_.rating_num)/count(distinct ratinglist1_.rating_id)) 
end>=1

Pour le point de vue technique, regardez la ligne suivante dans les critères ci-dessus requête.

criteriaQuery.having(criteriaBuilder.greaterThanOrEqualTo(selectExpression, criteriaBuilder.literal(1)));

Son analogue de la ligne en question a été rédigé comme suit.

createQuery.having(criteriaBuilder.greaterThanOrEqualTo(selectExpression, 1));

Voir l'expression d'origine dans la question de faire exactement la même chose :

Expression<Integer> selectExpression = criteriaBuilder.<Integer>selectCase()
                                       .when(quotExpression.isNull(), 0)
                                       .<Integer>otherwise(roundExpression);

Cette expression a été tenté d'être passé à criteriaBuilder.greaterThanOrEqualTo() comme suit.

criteriaQuery.having(criteriaBuilder.greaterThanOrEqualTo(selectExpression, 0));

Accorder une attention particulière à la deuxième paramètre à greaterThanOrEqualTo() ci-dessus. Il est 0. Il doit avoir été criteriaBuilder.literal(0) plutôt que par conséquent, l'exception, comme mentionné dans la question.

Ainsi, toujours insister sur l'aide de CriteriaBuilder#literal(T value) pour des valeurs littérales chaque fois que nécessaire, comme l'a fait ci-dessus en utilisant des expressions dans la CriteriaBuilder#selectCase() construire.

_{Testé sur Hibernate 4.3.6 final, Hibernate 5.0.5 final sinon. je vais essayer d'exécuter la même requête sur EclipseLink (2.6.1 finale) plus tard. Il ne devrait pas être une bizarrerie de plus.}

_{EclipseLink a pas de problème avec la version modifiée de la requête, sauf qu'il implique un Object paramètre de type de l'argument du constructeur (paramètre formel), si le constructeur expressions sont utilisées à la place de Tuple qui cette question n'a rien à faire avec, après tout. C'est depuis longtemps un bug dans EclipseLink encore être fixe - un exemple analogue.}

OriginalL'auteur Tiny