JPA动态查询中countDistinct的EXISTS子句优化与替代方案

Root<Foo> from = criteriaQuery.from(Foo.class);
//... predicates
CriteriaQuery<Long> countQuery = criteriaBuilder.createQuery(Long.class)
        .select(criteriaBuilder.countDistinct(from))
        .where(predicates.toArray(new Predicate[predicates.size()]));
Long numberResults = entityManager.createQuery(countQuery).getSingleResult();

SELECT COUNT(t0.REFERENCE) 
FROM foo t0 
WHERE EXISTS (
  SELECT t1.REFERENCE 
  FROM foo t1 
  WHERE ((((t0.REFERENCE = t1.REFERENCE) AND (t0.VERSION_NUM = t1.VERSION_NUM)) AND (t0.ISSUER = t1.ISSUER)) AND (t1.REFERENCE LIKE ? AND (t1.VERSION_STATUS = ?)))
);

import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.List;

// 假设 Foo 是你的实体类，包含 'reference' 字段
public class Foo {
    private String reference;
    private String versionNum;
    private String issuer;
    private String versionStatus;
    // ... 其他字段和getter/setter

    // 示例构造函数和getter
    public Foo(String reference) {
        this.reference = reference;
    }
    public String getReference() { return reference; }
    // ...
}

public class JpaCountOptimizer {

    private EntityManager entityManager; // 假设已注入或通过其他方式获取

    /**
     * 在内存中统计符合条件且唯一的引用数量。
     * @param predicates 查询条件列表。
     * @return 符合条件的唯一引用数量。
     */
    public int countDistinctReferences(List<Predicate> predicates) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        // 假设 reference 是 String 类型
        CriteriaQuery<String> query = cb.createQuery(String.class);
        Root<Foo> root = query.from(Foo.class);

        query
          .select(root.get("reference")) // 选择唯一标识符字段
          .distinct(true) // 确保结果唯一
          .where(predicates.toArray(new Predicate[predicates.size()])); // 应用查询条件

        List<String> references = entityManager.createQuery(query).getResultList();
        return references.size(); // 在内存中统计数量
    }
}

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

public class JpaInMemoryPaginator {

    private EntityManager entityManager; // 假设已注入或通过其他方式获取

    /**
     * 获取分页结果，所有数据先加载到内存中。
     * 仅适用于数据集非常小的情况。
     * @param predicates 查询条件列表。
     * @param pageNumber 当前页码（从0开始）。
     * @param pageSize 每页记录数。
     * @return 包含分页数据和总记录数的结果对象。
     */
    public PagedResult<Foo> getPagedFooResults(List<Predicate> predicates, int pageNumber, int pageSize) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<Foo> query = cb.createQuery(Foo.class);
        Root<Foo> root = query.from(Foo.class);

        query.select(root)
             .where(predicates.toArray(new Predicate[predicates.size()]));

        List<Foo> allResults = entityManager.createQuery(query).getResultList(); // 加载所有数据

        int totalResults = allResults.size();
        int startIndex = pageNumber * pageSize;
        int endIndex = Math.min(startIndex + pageSize, totalResults);

        // 根据计算出的索引获取当前页的数据
        List<Foo> pageResults = (startIndex < totalResults) ? allResults.subList(startIndex, endIndex) : List.of();

        return new PagedResult<>(pageResults, totalResults);
    }

    // 简单的分页结果包装类
    static class PagedResult<T> {
        private List<T> content;
        private int totalElements;

        public PagedResult(List<T> content, int totalElements) {
            this.content = content;
            this.totalElements = totalElements;
        }
        // getter methods
        public List<T> getContent() { return content; }
        public int getTotalElements() { return totalElements; }
    }
}