Java ListJoin类代码示例

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
public static Specification<User> byKeyword(String keyword, String role, String active){
    return (Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) -> {

        List<Predicate> predicates = new ArrayList<>();

        if (StringUtils.hasText(keyword)) {
            predicates.add(
                cb.or(
                    cb.like(root.get(User_.email), "%" + keyword + "%"),
                    cb.like(root.get(User_.username), "%" + keyword + "%")
                ));
        }

        if (StringUtils.hasText(role) && !"ALL".equals(role)) {

            ListJoin<User, String> roleJoin = root.join(User_.roles);
            predicates.add(cb.equal(roleJoin, role));
        }
        if (StringUtils.hasText(active)) {
            predicates.add(cb.equal(root.get(User_.active), Boolean.valueOf(active)));
        }
        return cb.and(predicates.toArray(new Predicate[predicates.size()]));
    };
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
public static Specification<HarvestReport> hasEndOfHuntingReportAndFieldsSpeciesIsPermitSpecies(final Long fieldsId) {
    return (root, query, cb) -> {
        final Subquery<Integer> permitQuery = query.subquery(Integer.class);
        final Root<HarvestPermit> permitRoot = permitQuery.from(HarvestPermit.class);

        final ListJoin<HarvestPermit, HarvestPermitSpeciesAmount> speciesAmounts = permitRoot.join(HarvestPermit_.speciesAmounts);
        final Path<GameSpecies> speciesAmountsSpecies = speciesAmounts.get(HarvestPermitSpeciesAmount_.gameSpecies);

        final Subquery<Integer> fieldsQuery = query.subquery(Integer.class);
        final Root<HarvestReportFields> fieldsRoot = fieldsQuery.from(HarvestReportFields.class);

        final Predicate permitSpeciesEqualToFieldsSpecies = cb.and(
                cb.equal(fieldsRoot.get(HarvestReportFields_.id), fieldsId),
                cb.equal(fieldsRoot.get(HarvestReportFields_.species), speciesAmountsSpecies));
        final Predicate fieldsExists = cb.exists(fieldsQuery.select(cb.literal(1)).where(permitSpeciesEqualToFieldsSpecies));

        return cb.exists(permitQuery
                .select(cb.literal(1))
                .where(cb.and(
                        cb.equal(permitRoot.join(HarvestPermit_.endOfHuntingReport), permitQuery.correlate(root)),
                        fieldsExists))
        );
    };
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
@Override
public Page<Target> findTargetsOfRolloutGroupByRsql(final Pageable pageable, final Long rolloutGroupId,
        final String rsqlParam) {

    throwExceptionIfRolloutGroupDoesNotExist(rolloutGroupId);

    final Specification<JpaTarget> rsqlSpecification = RSQLUtility.parse(rsqlParam, TargetFields.class,
            virtualPropertyReplacer);

    return convertTPage(targetRepository.findAll((root, query, criteriaBuilder) -> {
        final ListJoin<JpaTarget, RolloutTargetGroup> rolloutTargetJoin = root.join(JpaTarget_.rolloutTargetGroup);
        return criteriaBuilder.and(rsqlSpecification.toPredicate(root, query, criteriaBuilder),
                criteriaBuilder.equal(
                        rolloutTargetJoin.get(RolloutTargetGroup_.rolloutGroup).get(JpaRolloutGroup_.id),
                        rolloutGroupId));
    }, pageable), pageable);
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
@Override
public Page<String> findMessagesByActionStatusId(final Pageable pageable, final Long actionStatusId) {
    final CriteriaBuilder cb = entityManager.getCriteriaBuilder();

    final CriteriaQuery<Long> countMsgQuery = cb.createQuery(Long.class);
    final Root<JpaActionStatus> countMsgQueryFrom = countMsgQuery.distinct(true).from(JpaActionStatus.class);
    final ListJoin<JpaActionStatus, String> cJoin = countMsgQueryFrom.joinList("messages", JoinType.LEFT);
    countMsgQuery.select(cb.count(cJoin))
            .where(cb.equal(countMsgQueryFrom.get(JpaActionStatus_.id), actionStatusId));
    final Long totalCount = entityManager.createQuery(countMsgQuery).getSingleResult();

    final CriteriaQuery<String> msgQuery = cb.createQuery(String.class);
    final Root<JpaActionStatus> as = msgQuery.from(JpaActionStatus.class);
    final ListJoin<JpaActionStatus, String> join = as.joinList("messages", JoinType.LEFT);
    final CriteriaQuery<String> selMsgQuery = msgQuery.select(join);
    selMsgQuery.where(cb.equal(as.get(JpaActionStatus_.id), actionStatusId));

    final List<String> result = entityManager.createQuery(selMsgQuery).setFirstResult(pageable.getOffset())
            .setMaxResults(pageable.getPageSize()).getResultList().stream().collect(Collectors.toList());

    return new PageImpl<>(result, pageable, totalCount);
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
public List<Product> findForPurchaseCustomerPremium() {
    // main query on products
    CriteriaQuery<Product> query = em.getCriteriaBuilder().createQuery(Product.class);
    Root<Product> from = query.from(Product.class);
    
    // subquery on product ids
    Subquery<Long> subQuery = query.subquery(Long.class);
    Root<Customer> subFrom = subQuery.from(Customer.class);
    ListJoin<Customer, Purchase> joinPurchase = subFrom.join(Customer_.purchases);
    ListJoin<Purchase, Product> joinProduct = joinPurchase.join(Purchase_.products);
    // Explicitly add to SELECT clause; otherwise, throws Error Code: 30000 SQLSyntaxErrorException
    subQuery.select(joinProduct.get(Product_.id)).distinct(true);
    subQuery.where(em.getCriteriaBuilder().equal(subFrom.get(Customer_.premium), true));
    
    query.select(from);
    query.where(em.getCriteriaBuilder().in(from.get(Product_.id)).value(subQuery));
    return em.createQuery(query).getResultList();
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
public Map<Customer, Double> sumPriceByPurchaseCustomer() {
    // Create "tuple" query for use with groupBy; otherwise, throws PersistenceException: Exception [EclipseLink-6051]
    CriteriaQuery<Tuple> query = em.getCriteriaBuilder().createTupleQuery();
    Root<Customer> from = query.from(Customer.class);
    ListJoin<Customer, Purchase> joinPurchase = from.join(Customer_.purchases);
    ListJoin<Purchase, Product> joinProduct = joinPurchase.join(Purchase_.products);
    query.multiselect(from.get(BaseModel_.id), em.getCriteriaBuilder().sum(joinProduct.get(Product_.price)));
    query.groupBy(from.get(BaseModel_.id));
    List<Tuple> results = em.createQuery(query).getResultList();
    
    Map<Customer, Double> ret = new HashMap<>();
    for (Tuple result : results) {
        Object[] arr = result.toArray();
        ret.put(customerService.findById((Long)arr[0]), ((Double)arr[1]));
    }
    return ret;
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
public Reservation getByProviderRequestWithPessimisticWriteLock(String requesterNsa, String providerNsa, String correlationId) {
  CriteriaBuilder builder = entityManager.getCriteriaBuilder();
  CriteriaQuery<Reservation> query = builder.createQuery(Reservation.class);
  Root<Reservation> root = query.from(Reservation.class);

  ListJoin<Reservation, NsiV2Message> providerRequests = root.join(Reservation_.providerRequests);

  query.where(builder.and(
      builder.equal(providerRequests.get(NsiV2Message_.requesterNsa), requesterNsa),
      builder.equal(providerRequests.get(NsiV2Message_.providerNsa), providerNsa),
      builder.equal(providerRequests.get(NsiV2Message_.correlationId), correlationId),
      builder.equal(providerRequests.get(NsiV2Message_.role), NsiV2Message.Role.REQUESTER),
      builder.equal(providerRequests.get(NsiV2Message_.type), NsiV2Message.Type.REQUEST)));

  return entityManager.createQuery(query).setLockMode(LockModeType.PESSIMISTIC_WRITE).getSingleResult();
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
@Override
public QueryFilter<SemanticDescriptor> byService(long serviceId) {
    ListJoin<SemanticDescriptor, DataManipulationService> services = root
            .join(SemanticDescriptor_.describedServices);
    Predicate predicate = criteriaBuilder.equal(services.get(DataManipulationService_.id), serviceId);
    return constructQueryFilter(predicate);
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
/**
 * @param installedTargetId
 *            the targetID which is installed to a distribution set to
 *            search for.
 * @return the specification to search for a distribution set which is
 *         installed to the given targetId
 */
public static Specification<JpaDistributionSet> installedTarget(final String installedTargetId) {
    return (dsRoot, query, cb) -> {
        final ListJoin<JpaDistributionSet, JpaTarget> installedTargetJoin = dsRoot
                .join(JpaDistributionSet_.installedAtTargets, JoinType.INNER);
        return cb.equal(installedTargetJoin.get(JpaTarget_.controllerId), installedTargetId);
    };
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
/**
 * @param assignedTargetId
 *            the targetID which is assigned to a distribution set to search
 *            for.
 * @return the specification to search for a distribution set which is
 *         assigned to the given targetId
 */
public static Specification<JpaDistributionSet> assignedTarget(final String assignedTargetId) {
    return (dsRoot, query, cb) -> {
        final ListJoin<JpaDistributionSet, JpaTarget> assignedTargetJoin = dsRoot
                .join(JpaDistributionSet_.assignedToTargets, JoinType.INNER);
        return cb.equal(assignedTargetJoin.get(JpaTarget_.controllerId), assignedTargetId);
    };
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
/**
 * {@link Specification} for retrieving {@link Target}s that don't have the
 * given distribution set in their action history
 *
 * @param distributionSetId
 *            the ID of the distribution set which must not be assigned
 * @return the {@link Target} {@link Specification}
 */
public static Specification<JpaTarget> hasNotDistributionSetInActions(final Long distributionSetId) {
    return (targetRoot, query, cb) -> {
        final ListJoin<JpaTarget, JpaAction> actionsJoin = targetRoot.join(JpaTarget_.actions, JoinType.LEFT);
        actionsJoin.on(cb.equal(actionsJoin.get(JpaAction_.distributionSet).get(JpaDistributionSet_.id),
                distributionSetId));

        return cb.isNull(actionsJoin.get(JpaAction_.id));
    };
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
/**
 * {@link Specification} for retrieving {@link Target}s that are not in the
 * given {@link RolloutGroup}s
 *
 * @param groups
 *            the {@link RolloutGroup}s
 * @return the {@link Target} {@link Specification}
 */
public static Specification<JpaTarget> isNotInRolloutGroups(final Collection<Long> groups) {
    return (targetRoot, query, cb) -> {
        final ListJoin<JpaTarget, RolloutTargetGroup> rolloutTargetJoin = targetRoot
                .join(JpaTarget_.rolloutTargetGroup, JoinType.LEFT);
        final Predicate inRolloutGroups = rolloutTargetJoin.get(RolloutTargetGroup_.rolloutGroup)
                .get(JpaRolloutGroup_.id).in(groups);
        rolloutTargetJoin.on(inRolloutGroups);
        return cb.isNull(rolloutTargetJoin.get(RolloutTargetGroup_.target));
    };
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
/**
 * {@link Specification} for retrieving {@link Target}s that have no Action
 * of the {@link RolloutGroup}.
 *
 * @param group
 *            the {@link RolloutGroup}
 * @return the {@link Target} {@link Specification}
 */
public static Specification<JpaTarget> hasNoActionInRolloutGroup(final Long group) {
    return (targetRoot, query, cb) -> {
        final ListJoin<JpaTarget, RolloutTargetGroup> rolloutTargetJoin = targetRoot
                .join(JpaTarget_.rolloutTargetGroup, JoinType.INNER);
        rolloutTargetJoin.on(
                cb.equal(rolloutTargetJoin.get(RolloutTargetGroup_.rolloutGroup).get(JpaRolloutGroup_.id), group));

        final ListJoin<JpaTarget, JpaAction> actionsJoin = targetRoot.join(JpaTarget_.actions, JoinType.LEFT);
        actionsJoin.on(cb.equal(actionsJoin.get(JpaAction_.rolloutGroup).get(JpaRolloutGroup_.id), group));

        return cb.isNull(actionsJoin.get(JpaAction_.id));
    };
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
@Override
public Page<TargetWithActionStatus> findAllTargetsOfRolloutGroupWithActionStatus(final Pageable pageRequest,
        final Long rolloutGroupId) {
    throwExceptionIfRolloutGroupDoesNotExist(rolloutGroupId);

    final CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    final CriteriaQuery<Object[]> query = cb.createQuery(Object[].class);
    final CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);

    final Root<RolloutTargetGroup> targetRoot = query.distinct(true).from(RolloutTargetGroup.class);
    final Join<RolloutTargetGroup, JpaTarget> targetJoin = targetRoot.join(RolloutTargetGroup_.target);
    final ListJoin<RolloutTargetGroup, JpaAction> actionJoin = targetRoot.join(RolloutTargetGroup_.actions,
            JoinType.LEFT);

    final Root<RolloutTargetGroup> countQueryFrom = countQuery.distinct(true).from(RolloutTargetGroup.class);
    countQueryFrom.join(RolloutTargetGroup_.target);
    countQueryFrom.join(RolloutTargetGroup_.actions, JoinType.LEFT);
    countQuery.select(cb.count(countQueryFrom)).where(cb
            .equal(countQueryFrom.get(RolloutTargetGroup_.rolloutGroup).get(JpaRolloutGroup_.id), rolloutGroupId));
    final Long totalCount = entityManager.createQuery(countQuery).getSingleResult();

    final CriteriaQuery<Object[]> multiselect = query.multiselect(targetJoin, actionJoin.get(JpaAction_.status))
            .where(cb.equal(targetRoot.get(RolloutTargetGroup_.rolloutGroup).get(JpaRolloutGroup_.id),
                    rolloutGroupId));
    final List<TargetWithActionStatus> targetWithActionStatus = entityManager.createQuery(multiselect)
            .setFirstResult(pageRequest.getOffset()).setMaxResults(pageRequest.getPageSize()).getResultList()
            .stream().map(o -> new TargetWithActionStatus((Target) o[0], (Action.Status) o[1]))
            .collect(Collectors.toList());

    return new PageImpl<>(targetWithActionStatus, pageRequest, totalCount);
}
 

import javax.persistence.criteria.ListJoin; //导入依赖的package包/类
@Override
public ResolvedPermissions resolveSourceConfigPermissions(
		AuthorizedUserEntity etlUser, SourceConfigEntity entity) {
	EntityManager entityManager = getEntityManager();
	CriteriaBuilder cb = entityManager.getCriteriaBuilder();
	CriteriaQuery<Tuple> q = 
			cb.createQuery(Tuple.class);
	Root<SourceConfigGroupMembership> groupMembership = q.from(SourceConfigGroupMembership.class);
	q.select(
			cb.tuple(
					cb.greatest(cb.selectCase().when(cb.equal(groupMembership.get(SourceConfigGroupMembership_.groupRead), true), 1).otherwise(0).as(Integer.class)),
					cb.greatest(cb.selectCase().when(cb.equal(groupMembership.get(SourceConfigGroupMembership_.groupWrite), true), 1).otherwise(0).as(Integer.class)),
					cb.greatest(cb.selectCase().when(cb.equal(groupMembership.get(SourceConfigGroupMembership_.groupExecute), true), 1).otherwise(0).as(Integer.class))
			));
	ListJoin<EtlGroup, AuthorizedUserEntity> join = groupMembership.join(SourceConfigGroupMembership_.group).join(EtlGroup_.users);
	q.where(
			cb.and(
					cb.equal(groupMembership.get(SourceConfigGroupMembership_.sourceConfig).get(SourceConfigEntity_.id), entity.getId()), 
					cb.equal(join.get(AuthorizedUserEntity_.id), etlUser.getId())
			)
	);
	q.groupBy(groupMembership.get(SourceConfigGroupMembership_.sourceConfig).get(SourceConfigEntity_.id));
	List<Tuple> resultList = entityManager.createQuery(q).getResultList();
	if (resultList.isEmpty()) {
		return new ResolvedPermissions(false, false, false);
	} else {
		Tuple result = resultList.get(0);
		return new ResolvedPermissions(result.get(0, Integer.class) == 1, result.get(1, Integer.class) == 1, result.get(2, Integer.class) == 1);
	}
}