How to count a group by result with JPA and CriteriaBuilder? - jpa-2.0

Question

I think this is nearly impossible or very tricky. I'm using CriteriaBuilder, JPA 2.0, Hibernate and MariaDB and want to build the following query with CriteriaBuilder:
SELECT COUNT(*) FROM
(SELECT DISTINCT(SomeColumn) // I think this is not possible?
FROM MyTable
WHERE ... COMPLEX CLAUSE ...
GROUP BY SomeColumn) MyTable
My Question: Possible? And if, how?
Thanks for wrapping your mind around this!
Mark

Answer 1

This example assumes that you're using Metamodel generation.
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Subquery<SomeColumnType> subcq = cq.subquery(SomeColumnType.class);
Root<MyTable> from = subcq.from(MyTable.class);
subcq.select(from.get(MyTable_.someColumn));
subcq.where(** complex where statements **);
subcq.groupBy(from.get(MyTable_.someColumn));
cq.select(cb.count(subcq));

Answer 2

I had a similar problem, counting distinct group by elements, and stumbled across this Thread, based on the already existing answers I came up with the following
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<Long> countQuery = builder.createQuery(Long.class);
Root<Jpa1> countRoot = countQuery.from(Jpa1.class);
Subquery<Long> query = countQuery.subquery(Long.class);
Root<Jpa1> root = query.from(Jpa1.class);
applyFilter(query, root);
query.groupBy(root.get("groupBy_column1"), root.get("groupBy_column2"));
query.select(builder.min(root.get("id_column")));
countQuery.where(builder.in(countRoot.get("id_column")).value(query));
return countQuery.select(builder.count(countRoot.get("id_column")));

Answer 3

In case you have Spring Boot and you want to do the same, there is a better workaround that can only work for MySql 5/Maria by using the native SQL_CALC_FOUND_ROWS and FOUND_ROWS (It won't work on MySQL 8);
The main idea of this integration is flexibility for Spring-Data and the ability to override the default JpaRepositoryFactoryBean as follow
Step #1 - Create a custom CustomJpaRepositoryFactoryBean:
/**
*
* #author ehakawati
*
* #param <R>
* #param <T>
* #param <I>
*/
public class CustomJpaRepositoryFactoryBean<R extends JpaRepository<T, I>, T, I extends Serializable>
extends JpaRepositoryFactoryBean<R, T, I> {
public CustomJpaRepositoryFactoryBean(Class<? extends R> repositoryInterface) {
super(repositoryInterface);
}
#Override
protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {
RepositoryFactorySupport repositoryFactorySupport = super.createRepositoryFactory(entityManager);
repositoryFactorySupport.setRepositoryBaseClass(CustomJpaRepository.class);
return repositoryFactorySupport;
}
}
Step #2 - Create a custom CustomJpaRepository
/**
*
* #author ehakawati
*
* #param <T>
* #param <ID>
*/
public class CustomJpaRepository<T, ID extends Serializable> extends SimpleJpaRepository<T, ID>
implements Repository<T, ID> {
private final EntityManager em;
/**
*
* #param entityInformation
* #param entityManager
*/
public CustomJpaRepository(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
super(entityInformation, entityManager);
this.em = entityManager;
}
/**
*
* #param domainClass
* #param entityManager
*/
public CustomJpaRepository(Class<T> domainClass, EntityManager entityManager) {
super(domainClass, entityManager);
this.em = entityManager;
}
/**
* Reads the given {#link TypedQuery} into a {#link Page} applying the given
* {#link Pageable} and {#link Specification}.
*
* #param query must not be {#literal null}.
* #param domainClass must not be {#literal null}.
* #param spec can be {#literal null}.
* #param pageable can be {#literal null}.
* #return
*/
protected <S extends T> Page<S> readPage(TypedQuery<S> query, final Class<S> domainClass, Pageable pageable,
#Nullable Specification<S> spec) {
if (pageable.isUnpaged()) {
return super.readPage(query, domainClass, pageable, spec);
}
query.setFirstResult((int) pageable.getOffset());
query.setMaxResults(pageable.getPageSize());
return PageableExecutionUtils.getPage(query.getResultList(), pageable, () -> getNativeCount());
}
/**
*
*/
protected long getNativeCount() {
final Query query = em.createNativeQuery("SELECT FOUND_ROWS() as `count`");
return ((BigInteger) query.getSingleResult()).longValue();
}
}
Step #3 - PageableQueriesInterceptor:
/**
*
* #author ehakawati
*
* #param <T>
* #param <ID>
*/
public class PageableQueriesInterceptor extends EmptyInterceptor {
private static final Pattern PATTERN = Pattern.compile(".*?limit \\?(, \\?)?$");
private static final long serialVersionUID = 1L;
#Override
public String onPrepareStatement(String sql) {
if (PATTERN.matcher(sql).find()) {
sql = sql.replaceFirst("select", "select SQL_CALC_FOUND_ROWS ");
}
return sql;
}
}
Step #4 - Enable PageableQueriesInterceptor:
sprint.jpa.properties.hibernate.ejb.interceptor= com.****.****.******.betterpaging.PageableQueriesInterceptor
Enjoy

Answer 4

The CriteriaBuilder.countDistinct() method works nicely for counting groupBy results.
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<MyEntity> root = cq.from(MyEntity);
cq.select(cb.countDistinct(root("entityField")));
cq.where(** your criteria **);
var result = em.createQuery(cq).getSingleResult();
var m = Math.toIntExact(result);
This would be like the SQL query
SELECT COUNT(DISTINCT myEntity.entityField) FROM myEntity WHERE **blah** ;
And, of course, the countDistinct (like the COUNT(DISTINCT ...)) can have multiple columns listed as needed for grouping purposes.