在 JPA 2 中，使用 CriteriaQuery，如何计算结果

Question

我对 JPA 2 相当陌生，它是 CriteriaBuilder / CriteriaQuery API：

CriteriaQuery javadoc

Java EE 6 教程中的CriteriaQuery

我想计算 CriteriaQuery 的结果而不实际检索它们。这可能吗，我没有找到任何这样的方法，唯一的方法就是这样做：

CriteriaBuilder cb = entityManager.getCriteriaBuilder();

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

// initialize predicates here

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

这不可能是正确的方法......

有解决方案吗？

Answer 1

MyEntity 类型的查询将返回 MyEntity。您想要查询 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();

显然，您将希望使用示例中跳过的任何限制和分组等来构建您的表达式。

Answer 2

我已经使用 cb.createQuery() （没有结果类型参数）解决了这个问题：

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

希望它有帮助:)

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

由于其他答案是正确的，但太简单了，因此为了完整起见，我将提供下面的代码片段，以在复杂 JPA Criteria 查询（具有多个联接、获取）上执行 SELECT COUNT ， 状况）。

这个答案略有修改。

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

希望它可以节省某人的时间。

因为恕我直言，JPA Criteria API 不直观，也不太可读。

Answer 5

这有点棘手，具体取决于您使用的 JPA 2 实现，这个适用于 EclipseLink 2.4.1，但不适用于 Hibernate，这里是 EclipseLink 的通用 CriteriaQuery 计数：

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

前几天我从 EclipseLink 迁移到 Hibernate 并有将我的 count 函数更改为以下内容，因此请随意使用，因为这是一个很难解决的问题，它可能不适用于您的情况，它自 Hibernate 4.x 以来一直在使用，请注意，我并没有尝试猜测哪个是根，而是从查询中传递它，这样问题就解决了，有太多模棱两可的极端情况无法尝试猜测：

  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 6

您还可以使用投影：

ProjectionList projection = Projections.projectionList();
projection.add(Projections.rowCount());
criteria.setProjection(projection);

Long totalRows = (Long) criteria.list().get(0);

Answer 7

TypedQuery tq = entityManager.createQuery(criteria.getQuery());

Field f = CriteriaQueryTypeQueryAdapter.class.getDeclaredField("jpqlQuery");
f.setAccessible(true);
QueryImpl impl = (QueryImpl)f.get(tq);

HQLQueryPlan plan = impl.getQueryPlan();
Query q = entityManager.createNativeQuery("select count(*) from (" + plan.getSqlStrings()[0] + ")");

impl.getQueryParameters().getNamedParameters().forEach((key, value) -> {
    NamedParameterDescriptor desc = plan.getParameterMetadata().getNamedParameterDescriptor(key);
    for (int indx : desc.getSourceLocations()) {
        q.setParameter(indx + 1, value.getValue() instanceof Enum ? ((Enum) value.getValue()).name() : value.getValue());
    }
});