Java Code Examples for javax.persistence.criteria.CriteriaQuery#groupBy()

@Override
public Map<String, Long> selectTotalScoresByProblemJids(Set<String> problemJids) {
    if (problemJids.isEmpty()) {
        return Collections.emptyMap();
    }

    CriteriaBuilder cb = currentSession().getCriteriaBuilder();
    CriteriaQuery<Tuple> cq = cb.createTupleQuery();
    Root<StatsUserProblemModel> root = cq.from(getEntityClass());

    cq.select(cb.tuple(
            root.get(StatsUserProblemModel_.problemJid),
            cb.sum(root.get(StatsUserProblemModel_.score))));

    cq.where(
            root.get(StatsUserProblemModel_.problemJid).in(problemJids));

    cq.groupBy(
            root.get(StatsUserProblemModel_.problemJid));

    return currentSession().createQuery(cq).getResultList()
            .stream()
            .collect(Collectors.toMap(tuple -> tuple.get(0, String.class), tuple -> tuple.get(1, Long.class)));
}
 

@Override
public Map<String, Long> selectCountsAcceptedByProblemJids(Set<String> problemJids) {
    if (problemJids.isEmpty()) {
        return Collections.emptyMap();
    }

    CriteriaBuilder cb = currentSession().getCriteriaBuilder();
    CriteriaQuery<Tuple> cq = cb.createTupleQuery();
    Root<StatsUserProblemModel> root = cq.from(getEntityClass());

    cq.select(cb.tuple(
            root.get(StatsUserProblemModel_.problemJid),
            cb.count(root)));

    cq.where(
            cb.equal(root.get(StatsUserProblemModel_.verdict), Verdict.ACCEPTED.getCode()),
            root.get(StatsUserProblemModel_.problemJid).in(problemJids));

    cq.groupBy(
            root.get(StatsUserProblemModel_.problemJid));

    return currentSession().createQuery(cq).getResultList()
            .stream()
            .collect(Collectors.toMap(tuple -> tuple.get(0, String.class), tuple -> tuple.get(1, Long.class)));
}
 

@Override
public Map<String, Long> selectCountsTriedByProblemJids(Set<String> problemJids) {
    if (problemJids.isEmpty()) {
        return Collections.emptyMap();
    }

    CriteriaBuilder cb = currentSession().getCriteriaBuilder();
    CriteriaQuery<Tuple> cq = cb.createTupleQuery();
    Root<StatsUserProblemModel> root = cq.from(getEntityClass());

    cq.select(cb.tuple(
            root.get(StatsUserProblemModel_.problemJid),
            cb.count(root)));

    cq.where(
            root.get(StatsUserProblemModel_.problemJid).in(problemJids));

    cq.groupBy(
            root.get(StatsUserProblemModel_.problemJid));

    return currentSession().createQuery(cq).getResultList()
            .stream()
            .collect(Collectors.toMap(tuple -> tuple.get(0, String.class), tuple -> tuple.get(1, Long.class)));
}
 

@Override
public Map<String, Long> selectCountsVerdictByUserJid(String userJid) {
    CriteriaBuilder cb = currentSession().getCriteriaBuilder();
    CriteriaQuery<Tuple> cq = cb.createTupleQuery();
    Root<StatsUserProblemModel> root = cq.from(getEntityClass());

    cq.select(cb.tuple(
            root.get(StatsUserProblemModel_.verdict),
            cb.count(root)));

    cq.where(
            cb.equal(root.get(StatsUserProblemModel_.userJid), userJid));

    cq.groupBy(
            root.get(StatsUserProblemModel_.verdict));

    return currentSession().createQuery(cq).getResultList()
            .stream()
            .collect(Collectors.toMap(tuple -> tuple.get(0, String.class), tuple -> tuple.get(1, Long.class)));
}
 

/**
 * Return the data count base on the criteria query
 *
 * @param session : hibernate session
 * @param root : entity root which is further used for getting sub filed path from it and set in
 *     criteria where clause. Ex: Root<ProjectEntity> projectRoot =
 *     criteriaQuery.from(ProjectEntity.class);
 * @param criteria : Hibernate criteria query reference for further process
 * @param <T> : T = entity name like ProjectEntity, DatasetEntity, ExperimentEntity etc.
 * @return {@link Long} : total records count
 */
public static <T> long count(Session session, Root<T> root, CriteriaQuery<T> criteria) {
  final CriteriaBuilder builder = session.getCriteriaBuilder();
  final CriteriaQuery<Long> countCriteria = builder.createQuery(Long.class);

  countCriteria.select(builder.count(root));
  countCriteria.getRoots().addAll(criteria.getRoots());

  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 session.createQuery(countCriteria).getSingleResult();
}
 

@Test
public void callSizeFunction() {
	log.info("... callSizeFunction ...");

	EntityManager em = emf.createEntityManager();
	em.getTransaction().begin();

	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createTupleQuery();
	Root<Author> root = cq.from(Author.class);
	cq.multiselect(root, cb.size(root.get(Author_.books)));
	cq.groupBy(root.get(Author_.id));
	
	TypedQuery<Tuple> q = em.createQuery(cq);
	List<Tuple> results = q.getResultList();
	
	for (Tuple r :  results) {
		log.info(r.get(0) + " wrote " +  r.get(1) + " books.");
	}

	em.getTransaction().commit();
	em.close();
}
 

/**
 * Copy criteria without selection and order.
 * @param from source Criteria.
 * @param to destination Criteria.
 */
private static void copyCriteriaWithoutSelectionAndOrder(
		CriteriaQuery<?> from, CriteriaQuery<?> to, boolean copyFetches) {
	if (isEclipseLink(from) && from.getRestriction() != null) {
		// EclipseLink adds roots from predicate paths to critera. Skip copying 
		// roots as workaround.
	}
	else {
		 // Copy Roots
		 for (Root<?> root : from.getRoots()) {
			 Root<?> dest = to.from(root.getJavaType());
			 dest.alias(getOrCreateAlias(root));
			 copyJoins(root, dest);
			 if (copyFetches)
				 copyFetches(root, dest);
		 }
	}
	
	to.groupBy(from.getGroupList());
	to.distinct(from.isDistinct());
	
	if (from.getGroupRestriction() != null)
		to.having(from.getGroupRestriction());
	
	Predicate predicate = from.getRestriction();
	if (predicate != null)
		to.where(predicate);
}
 

public static void applyGroupBy(List<String> groupBys, CriteriaQuery<?> query, Map<String, Expression> selectionMap) {
    List<Expression<?>> grouping = new LinkedList<>();
    groupBys.stream().forEach(groupBy -> {
        Expression<?> filterExpr = selectionMap.get(groupBy);
        if (filterExpr == null) {
            throw new InvalidArgumentException(String.format("Given filter name [%s] is not existed.", groupBy));
        }
        grouping.add(filterExpr);
        
    });
    query.groupBy(grouping);
}
 

/**
 * Get a predicate using the specified parameters.
 *
 * @param root     The {@link Root} (from) for this query
 * @param cq       The {@link CriteriaQuery} instance this predicate is for
 * @param cb       The {@link CriteriaBuilder} for the query
 * @param name     The name of the command
 * @param user     The name of the user who created the command
 * @param statuses The status of the command
 * @param tags     The set of tags to search the command for
 * @return A {@link Predicate} object used for querying
 */
public static Predicate find(
    final Root<CommandEntity> root,
    final CriteriaQuery<?> cq,
    final CriteriaBuilder cb,
    @Nullable final String name,
    @Nullable final String user,
    @Nullable final Set<String> statuses,
    @Nullable final Set<TagEntity> tags
) {
    final List<Predicate> predicates = new ArrayList<>();
    if (StringUtils.isNotBlank(name)) {
        predicates.add(
            PredicateUtils.getStringLikeOrEqualPredicate(cb, root.get(CommandEntity_.name), name)
        );
    }
    if (StringUtils.isNotBlank(user)) {
        predicates.add(
            PredicateUtils.getStringLikeOrEqualPredicate(cb, root.get(CommandEntity_.user), user)
        );
    }
    if (statuses != null && !statuses.isEmpty()) {
        predicates.add(
            cb.or(
                statuses
                    .stream()
                    .map(status -> cb.equal(root.get(CommandEntity_.status), status))
                    .toArray(Predicate[]::new)
            )
        );
    }
    if (tags != null && !tags.isEmpty()) {
        final Join<CommandEntity, TagEntity> tagEntityJoin = root.join(CommandEntity_.tags);
        predicates.add(tagEntityJoin.in(tags));
        cq.groupBy(root.get(CommandEntity_.id));
        cq.having(cb.equal(cb.count(root.get(CommandEntity_.id)), tags.size()));
    }
    return cb.and(predicates.toArray(new Predicate[0]));
}
 

public List<Object[]> findCountByCategoryUsingCriteriaBuilder() {
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Object[]> query = builder.createQuery(Object[].class);
    Root<Product> product = query.from(Product.class);
    query.multiselect(product.get("category"), builder.count(product));
    query.groupBy(product.get("category"));
    List<Object[]> resultList = entityManager.createQuery(query).getResultList();
    return resultList;
}
 

@SuppressWarnings("unchecked")
public static <T> TypedQuery<Long> getCountQuery(CriteriaQuery<T> cq) {
	Class<T> domainClass = cq.getResultType();
	EntityManager em = getEntityManager(domainClass);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Long> countCq = cb.createQuery(Long.class);
	Root<T> root;
	if (cq.getRestriction() != null) {
		countCq.where(cq.getRestriction());
	}
	if (cq.getGroupRestriction() != null) {
		countCq.having(cq.getGroupRestriction());
	}
	if (cq.getRoots().isEmpty()) {
		root = countCq.from(domainClass);
	} else {
		countCq.getRoots().addAll(cq.getRoots());
		root = (Root<T>) countCq.getRoots().iterator().next();
	}
	countCq.groupBy(cq.getGroupList());
	if (cq.isDistinct()) {
		countCq.select(cb.countDistinct(root));
	} else {
		countCq.select(cb.count(root));
	}

	return em.createQuery(countCq);
}
 

@Override
public Map<String, Long> selectCounts(String containerJid, String userJid, Set<String> problemJids) {
    if (problemJids.isEmpty()) {
        return Collections.emptyMap();
    }

    CriteriaBuilder cb = currentSession().getCriteriaBuilder();
    CriteriaQuery<Tuple> cq = cb.createTupleQuery();
    Root<M> root = cq.from(getEntityClass());

    cq.select(cb.tuple(
            root.get(AbstractProgrammingSubmissionModel_.problemJid),
            cb.count(root)));

    cq.where(
            cb.equal(root.get(AbstractProgrammingSubmissionModel_.containerJid), containerJid),
            cb.equal(root.get(JudgelsModel_.createdBy), userJid),
            root.get(AbstractProgrammingSubmissionModel_.problemJid).in(problemJids));

    cq.groupBy(
            root.get(AbstractProgrammingSubmissionModel_.containerJid),
            root.get(JudgelsModel_.createdBy),
            root.get(AbstractProgrammingSubmissionModel_.problemJid));

    return currentSession().createQuery(cq).getResultList()
            .stream()
            .collect(Collectors.toMap(tuple -> tuple.get(0, String.class), tuple -> tuple.get(1, Long.class)));
}
 

@Override
public Map<String, Long> selectCountProgrammingByChapterJids(Set<String> chapterJids) {
    if (chapterJids.isEmpty()) {
        return Collections.emptyMap();
    }

    CriteriaBuilder cb = currentSession().getCriteriaBuilder();
    CriteriaQuery<Tuple> cq = cb.createTupleQuery();
    Root<ChapterProblemModel> root = cq.from(getEntityClass());

    cq.select(cb.tuple(
            root.get(ChapterProblemModel_.chapterJid),
            cb.count(root)));

    cq.where(
            cb.equal(root.get(ChapterProblemModel_.status), "VISIBLE"),
            cb.equal(root.get(ChapterProblemModel_.type), ProblemType.PROGRAMMING.name()),
            root.get(ChapterProblemModel_.chapterJid).in(chapterJids));

    cq.groupBy(
            root.get(ChapterProblemModel_.chapterJid));

    return currentSession().createQuery(cq).getResultList()
            .stream()
            .collect(Collectors.toMap(tuple -> tuple.get(0, String.class), tuple -> tuple.get(1, Long.class)));

}
 

@Override
public Map<String, Long> selectCountsByProblemSetJids(Set<String> problemSetJids) {
    if (problemSetJids.isEmpty()) {
        return Collections.emptyMap();
    }

    CriteriaBuilder cb = currentSession().getCriteriaBuilder();
    CriteriaQuery<Tuple> cq = cb.createTupleQuery();
    Root<ProblemSetProblemModel> root = cq.from(getEntityClass());

    cq.select(cb.tuple(
            root.get(ProblemSetProblemModel_.problemSetJid),
            cb.count(root)));

    cq.where(
            cb.equal(root.get(ProblemSetProblemModel_.status), "VISIBLE"),
            cb.equal(root.get(ProblemSetProblemModel_.type), ProblemType.PROGRAMMING.name()),
            root.get(ProblemSetProblemModel_.problemSetJid).in(problemSetJids));

    cq.groupBy(
            root.get(ProblemSetProblemModel_.problemSetJid));

    return currentSession().createQuery(cq).getResultList()
            .stream()
            .collect(Collectors.toMap(tuple -> tuple.get(0, String.class), tuple -> tuple.get(1, Long.class)));

}
 

@Override
public Integer getBusinessObjectDataLimitedCountBySearchKey(BusinessObjectDataSearchKey businessObjectDataSearchKey, Integer recordCountLimit)
{
    // Create the criteria builder and the criteria.
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<String> criteria = builder.createQuery(String.class);

    // The criteria root is the business object data.
    Root<BusinessObjectDataEntity> businessObjectDataEntityRoot = criteria.from(BusinessObjectDataEntity.class);

    // Namespace and business object definition are required parameters, so fetch the relative business object definition entity to optimize the main query.
    BusinessObjectDefinitionEntity businessObjectDefinitionEntity = businessObjectDefinitionDao.getBusinessObjectDefinitionByKey(
        new BusinessObjectDefinitionKey(businessObjectDataSearchKey.getNamespace(), businessObjectDataSearchKey.getBusinessObjectDefinitionName()));

    // If specified business object definition does not exist, then return a zero record count.
    if (businessObjectDefinitionEntity == null)
    {
        return 0;
    }

    // If file type is specified, fetch the relative entity to optimize the main query.
    FileTypeEntity fileTypeEntity = null;
    if (StringUtils.isNotBlank(businessObjectDataSearchKey.getBusinessObjectFormatFileType()))
    {
        fileTypeEntity = fileTypeDao.getFileTypeByCode(businessObjectDataSearchKey.getBusinessObjectFormatFileType());

        // If specified file type does not exist, then return a zero record count.
        if (fileTypeEntity == null)
        {
            return 0;
        }
    }

    // Join to the other tables we can filter on.
    Join<BusinessObjectDataEntity, BusinessObjectFormatEntity> businessObjectFormatEntityJoin =
        businessObjectDataEntityRoot.join(BusinessObjectDataEntity_.businessObjectFormat);

    // Add select clause to the query. We use business object data partition value column for select, since this is enough to check the record count.
    criteria.select(businessObjectDataEntityRoot.get(BusinessObjectDataEntity_.partitionValue));

    // Add standard restrictions to the query. (i.e. the standard where clauses).
    try
    {
        criteria.where(getQueryPredicateBySearchKey(builder, businessObjectDataEntityRoot, businessObjectFormatEntityJoin, businessObjectDataSearchKey,
            businessObjectDefinitionEntity, fileTypeEntity));
    }
    catch (IllegalArgumentException ex)
    {
        // This exception means that there are no records found for the query, thus return 0 record count.
        return 0;
    }


    // If latest valid version filter is specified, ignore business object format and business object data versions when counting search results.
    // In order to do that, we group by all elements of business object data alternate key, except for the versions.  Please note that we need to apply
    // upper() call on business object format usage, since it is not a dictionary value (does not have the relative lookup table).
    if (BooleanUtils.isTrue(businessObjectDataSearchKey.isFilterOnLatestValidVersion()))
    {
        List<Expression<?>> groupBy = new ArrayList<>();
        groupBy.add(businessObjectFormatEntityJoin.get(BusinessObjectFormatEntity_.businessObjectDefinitionId));
        groupBy.add(builder.upper(businessObjectFormatEntityJoin.get(BusinessObjectFormatEntity_.usage)));
        groupBy.add(businessObjectFormatEntityJoin.get(BusinessObjectFormatEntity_.fileTypeCode));
        groupBy.add(businessObjectDataEntityRoot.get(BusinessObjectDataEntity_.partitionValue));
        groupBy.add(businessObjectDataEntityRoot.get(BusinessObjectDataEntity_.partitionValue2));
        groupBy.add(businessObjectDataEntityRoot.get(BusinessObjectDataEntity_.partitionValue3));
        groupBy.add(businessObjectDataEntityRoot.get(BusinessObjectDataEntity_.partitionValue4));
        groupBy.add(businessObjectDataEntityRoot.get(BusinessObjectDataEntity_.partitionValue5));
        criteria.groupBy(groupBy);
    }

    // Execute the query.
    List<String> businessObjectDataPartitionValues = entityManager.createQuery(criteria).setMaxResults(recordCountLimit).getResultList();

    // Return the size of the result list.
    return CollectionUtils.size(businessObjectDataPartitionValues);
}
 

@Override
public List<BusinessObjectFormatKey> getBusinessObjectFormatsWithFilters(BusinessObjectDefinitionKey businessObjectDefinitionKey,
    String businessObjectFormatUsage, boolean latestBusinessObjectFormatVersion)
{
    // Create the criteria builder and a tuple style criteria query.
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Tuple> criteria = builder.createTupleQuery();

    // The criteria root is the business object format.
    Root<BusinessObjectFormatEntity> businessObjectFormatEntity = criteria.from(BusinessObjectFormatEntity.class);

    // Join to the other tables we can filter on.
    Join<BusinessObjectFormatEntity, BusinessObjectDefinitionEntity> businessObjectDefinitionEntity =
        businessObjectFormatEntity.join(BusinessObjectFormatEntity_.businessObjectDefinition);
    Join<BusinessObjectFormatEntity, FileTypeEntity> fileTypeEntity = businessObjectFormatEntity.join(BusinessObjectFormatEntity_.fileType);
    Join<BusinessObjectDefinitionEntity, NamespaceEntity> namespaceEntity = businessObjectDefinitionEntity.join(BusinessObjectDefinitionEntity_.namespace);

    // Get the columns.
    Path<String> namespaceCodeColumn = namespaceEntity.get(NamespaceEntity_.code);
    Path<String> businessObjectDefinitionNameColumn = businessObjectDefinitionEntity.get(BusinessObjectDefinitionEntity_.name);
    Path<String> businessObjectFormatUsageColumn = businessObjectFormatEntity.get(BusinessObjectFormatEntity_.usage);
    Path<String> fileTypeCodeColumn = fileTypeEntity.get(FileTypeEntity_.code);
    Path<Integer> businessObjectFormatVersionColumn = businessObjectFormatEntity.get(BusinessObjectFormatEntity_.businessObjectFormatVersion);
    Expression<Integer> maxBusinessObjectFormatVersionExpression =
        builder.max(businessObjectFormatEntity.get(BusinessObjectFormatEntity_.businessObjectFormatVersion));

    // Create the standard restrictions (i.e. the standard where clauses).
    Predicate queryRestriction =
        builder.equal(builder.upper(namespaceEntity.get(NamespaceEntity_.code)), businessObjectDefinitionKey.getNamespace().toUpperCase());
    queryRestriction = builder.and(queryRestriction, builder.equal(builder.upper(businessObjectDefinitionEntity.get(BusinessObjectDefinitionEntity_.name)),
        businessObjectDefinitionKey.getBusinessObjectDefinitionName().toUpperCase()));

    // Add the business object format usage where parameter is not empty
    if (StringUtils.isNotEmpty(businessObjectFormatUsage))
    {
        queryRestriction = builder.and(queryRestriction,
            builder.equal(builder.upper(businessObjectFormatEntity.get(BusinessObjectFormatEntity_.usage)), businessObjectFormatUsage.toUpperCase()));
    }

    // Add the select clause.
    criteria.multiselect(namespaceCodeColumn, businessObjectDefinitionNameColumn, businessObjectFormatUsageColumn, fileTypeCodeColumn,
        latestBusinessObjectFormatVersion ? maxBusinessObjectFormatVersionExpression : businessObjectFormatVersionColumn);

    // Add the where clause.
    criteria.where(queryRestriction);

    // If only the latest (maximum) business object format versions to be returned, create and apply the group by clause.
    if (latestBusinessObjectFormatVersion)
    {
        List<Expression<?>> grouping = new ArrayList<>();
        grouping.add(namespaceCodeColumn);
        grouping.add(businessObjectDefinitionNameColumn);
        grouping.add(businessObjectFormatUsageColumn);
        grouping.add(fileTypeCodeColumn);
        criteria.groupBy(grouping);
    }

    // Add the order by clause.
    List<Order> orderBy = new ArrayList<>();
    orderBy.add(builder.asc(businessObjectFormatUsageColumn));
    orderBy.add(builder.asc(fileTypeCodeColumn));
    if (!latestBusinessObjectFormatVersion)
    {
        orderBy.add(builder.asc(businessObjectFormatVersionColumn));
    }
    criteria.orderBy(orderBy);

    // Run the query to get a list of tuples back.
    List<Tuple> tuples = entityManager.createQuery(criteria).getResultList();

    // Populate the "keys" objects from the returned tuples (i.e. 1 tuple for each row).
    List<BusinessObjectFormatKey> businessObjectFormatKeys = new ArrayList<>();
    for (Tuple tuple : tuples)
    {
        BusinessObjectFormatKey businessObjectFormatKey = new BusinessObjectFormatKey();
        businessObjectFormatKeys.add(businessObjectFormatKey);
        businessObjectFormatKey.setNamespace(tuple.get(namespaceCodeColumn));
        businessObjectFormatKey.setBusinessObjectDefinitionName(tuple.get(businessObjectDefinitionNameColumn));
        businessObjectFormatKey.setBusinessObjectFormatUsage(tuple.get(businessObjectFormatUsageColumn));
        businessObjectFormatKey.setBusinessObjectFormatFileType(tuple.get(fileTypeCodeColumn));
        businessObjectFormatKey.setBusinessObjectFormatVersion(
            tuple.get(latestBusinessObjectFormatVersion ? maxBusinessObjectFormatVersionExpression : businessObjectFormatVersionColumn));
    }

    return businessObjectFormatKeys;
}
 

/**
 * Get a {@link Predicate} using the specified parameters.
 *
 * @param root     The {@link Root} (from) for this query
 * @param cq       The {@link CriteriaQuery} instance this predicate is for
 * @param cb       The {@link CriteriaBuilder} for the query
 * @param name     The name of the application
 * @param user     The name of the user who created the application
 * @param statuses The status of the application
 * @param tags     The set of tags to search with
 * @param type     The type of applications to fine
 * @return A specification object used for querying
 */
public static Predicate find(
    final Root<ApplicationEntity> root,
    final CriteriaQuery<?> cq,
    final CriteriaBuilder cb,
    @Nullable final String name,
    @Nullable final String user,
    @Nullable final Set<String> statuses,
    @Nullable final Set<TagEntity> tags,
    @Nullable final String type
) {
    final List<Predicate> predicates = new ArrayList<>();
    if (StringUtils.isNotBlank(name)) {
        predicates.add(
            PredicateUtils.getStringLikeOrEqualPredicate(cb, root.get(ApplicationEntity_.name), name)
        );
    }
    if (StringUtils.isNotBlank(user)) {
        predicates.add(
            PredicateUtils.getStringLikeOrEqualPredicate(cb, root.get(ApplicationEntity_.user), user)
        );
    }
    if (statuses != null && !statuses.isEmpty()) {
        predicates.add(
            cb.or(
                statuses
                    .stream()
                    .map(status -> cb.equal(root.get(ApplicationEntity_.status), status))
                    .toArray(Predicate[]::new)
            )
        );
    }
    if (tags != null && !tags.isEmpty()) {
        final Join<ApplicationEntity, TagEntity> tagEntityJoin = root.join(ApplicationEntity_.tags);
        predicates.add(tagEntityJoin.in(tags));
        cq.groupBy(root.get(ApplicationEntity_.id));
        cq.having(cb.equal(cb.count(root.get(ApplicationEntity_.id)), tags.size()));
    }
    if (StringUtils.isNotBlank(type)) {
        predicates.add(
            PredicateUtils.getStringLikeOrEqualPredicate(cb, root.get(ApplicationEntity_.type), type)
        );
    }
    return cb.and(predicates.toArray(new Predicate[0]));
}
 

/**
 * Generate a {@link Predicate} given the parameters.
 *
 * @param root          The {@link Root} of the query
 * @param cq            The {@link CriteriaQuery}
 * @param cb            The {@link CriteriaBuilder}
 * @param name          The name of the cluster to find
 * @param statuses      The statuses of the clusters to find
 * @param tags          The tags of the clusters to find
 * @param minUpdateTime The minimum updated time of the clusters to find
 * @param maxUpdateTime The maximum updated time of the clusters to find
 * @return The {@link Predicate} representing these parameters
 */
public static Predicate find(
    final Root<ClusterEntity> root,
    final CriteriaQuery<?> cq,
    final CriteriaBuilder cb,
    @Nullable final String name,
    @Nullable final Set<String> statuses,
    @Nullable final Set<TagEntity> tags,
    @Nullable final Instant minUpdateTime,
    @Nullable final Instant maxUpdateTime
) {
    final List<Predicate> predicates = new ArrayList<>();
    if (StringUtils.isNotBlank(name)) {
        predicates.add(
            PredicateUtils.getStringLikeOrEqualPredicate(cb, root.get(ClusterEntity_.name), name)
        );
    }
    if (minUpdateTime != null) {
        predicates.add(cb.greaterThanOrEqualTo(root.get(ClusterEntity_.updated), minUpdateTime));
    }
    if (maxUpdateTime != null) {
        predicates.add(cb.lessThan(root.get(ClusterEntity_.updated), maxUpdateTime));
    }
    if (tags != null && !tags.isEmpty()) {
        final Join<ClusterEntity, TagEntity> tagEntityJoin = root.join(ClusterEntity_.tags);
        predicates.add(tagEntityJoin.in(tags));
        cq.groupBy(root.get(ClusterEntity_.id));
        cq.having(cb.equal(cb.count(root.get(ClusterEntity_.id)), tags.size()));
    }
    if (statuses != null && !statuses.isEmpty()) {
        //Could optimize this as we know size could use native array
        predicates.add(
            cb.or(
                statuses
                    .stream()
                    .map(status -> cb.equal(root.get(ClusterEntity_.status), status))
                    .toArray(Predicate[]::new)
            )
        );
    }

    return cb.and(predicates.toArray(new Predicate[0]));
}