如何将双步Criteria查询合并为带子查询的单个Criteria查询？

我需要把以下JPQL查询转换成Criteria Query，该查询用于获取订单总金额最高用户的最常用标签：

SELECT new Tag(t.id, t.name)
FROM GiftCertificate gc
JOIN gc.tags t
JOIN Order o ON o.giftCertificate = gc
JOIN o.user u
WHERE u = (
      SELECT ou
      FROM Order o2
      JOIN o2.user ou
      GROUP BY ou
      HAVING SUM(o2.orderCost) = (
            SELECT MAX(totalOrderCost)
            FROM (
                  SELECT SUM(o3.orderCost) AS totalOrderCost
                  FROM Order o3
                  GROUP BY o3.user
            ) subquery
      )
)
GROUP BY t.id, t.name
ORDER BY COUNT(gc) DESC

目前我只能通过两步分步查询实现：

第一步：查询订单总金额最高的用户 #

CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        
CriteriaQuery<User> userQuery = cb.createQuery(User.class);
Root<Order> userQueryRoot = userQuery.from(Order.class);
Join<Order, User> user = userQueryRoot.join("user");
userQuery.select(user)
         .groupBy(user)
         .orderBy(cb.desc(cb.sum(userQueryRoot.get("orderCost"))));
User mostOrdersCostUser = entityManager.createQuery(userQuery)
                                       .setMaxResults(1)
                                       .getSingleResult();

第二步：根据用户查询最常用标签 #

CriteriaQuery<Tag> tagQuery = cb.createQuery(Tag.class);
Root<Order> tagQueryroot = tagQuery.from(Order.class);
Join<Order, GiftCertificate> giftCertificate = tagQueryroot.join("giftCertificate");
Join<GiftCertificate, Tag> tag = giftCertificate.join("tags");
tagQuery.select(tag)
        .where(cb.equal(tagQueryroot.get("user"), mostOrdersCostUser))
        .groupBy(tag)
        .orderBy(cb.desc(cb.count(giftCertificate)));
Tag mostUsedtag = entityManager.createQuery(tagQuery).setMaxResults(1).getSingleResult();

分步查询存在明显弊端，但我受限于Subquery的使用限制，无法构建包含子查询的单个Criteria Query。请问是否有比分步查询更好的实现方式？

可以通过嵌套子查询的方式构建单条Criteria Query，完全对应原JPQL的逻辑，避免分步查询的一致性问题（比如分步期间数据变化）。以下是完整实现：

CriteriaBuilder cb = entityManager.getCriteriaBuilder();

// 主查询：获取目标用户的最常用标签
CriteriaQuery<Tag> mainQuery = cb.createQuery(Tag.class);
Root<GiftCertificate> gcRoot = mainQuery.from(GiftCertificate.class);
Join<GiftCertificate, Tag> tagJoin = gcRoot.join("tags");
Join<GiftCertificate, Order> orderJoin = gcRoot.join("orders"); // 需与GiftCertificate实体中关联Order的属性名一致
Join<Order, User> userJoin = orderJoin.join("user");

// 子查询1：计算每个用户的订单总金额（对应JPQL最内层子查询）
Subquery<BigDecimal> userTotalCostSubquery = mainQuery.subquery(BigDecimal.class);
Root<Order> o3Root = userTotalCostSubquery.from(Order.class);
userTotalCostSubquery.select(cb.sum(o3Root.get("orderCost")))
                     .groupBy(o3Root.get("user"));

// 子查询2：获取最高的订单总金额
Subquery<BigDecimal> maxTotalCostSubquery = mainQuery.subquery(BigDecimal.class);
maxTotalCostSubquery.select(cb.max(userTotalCostSubquery.getSelection()));

// 子查询3：找到订单总金额等于最高值的用户
Subquery<User> targetUserSubquery = mainQuery.subquery(User.class);
Root<Order> o2Root = targetUserSubquery.from(Order.class);
Join<Order, User> ouJoin = o2Root.join("user");
targetUserSubquery.select(ouJoin)
                  .groupBy(ouJoin)
                  .having(cb.equal(cb.sum(o2Root.get("orderCost")), maxTotalCostSubquery));

// 组装主查询条件、分组和排序
mainQuery.select(tagJoin)
         .where(cb.equal(userJoin, targetUserSubquery))
         .groupBy(tagJoin.get("id"), tagJoin.get("name")) // 显式指定分组字段，避免JPA分组歧义
         .orderBy(cb.desc(cb.count(gcRoot)));

// 执行查询，取第一条结果
Tag mostUsedTag = entityManager.createQuery(mainQuery)
                               .setMaxResults(1)
                               .getSingleResult();

关键说明： #

• 所有子查询需从主查询创建，确保上下文关联正确
• 关联属性名必须与实体类中的映射字段完全一致（比如GiftCertificate到Order的关联名）
• 分组时显式指定tag.id和tag.name，避免部分JPA实现对实体分组的限制
• 该实现保持原JPQL的原子性，避免分步查询期间数据变更导致的结果不一致问题

内容的提问来源于stack exchange，提问作者Oleksandr Myronets