private TypedQuery<Long> getProductIdsUsingProductOptionByIdQuery(Long productOptionId, boolean count) { // Set up the criteria query that specifies we want to return Products CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Long> criteria = builder.createQuery(Long.class); // The root of our search is ProductOptionXref Root<ProductOptionXrefImpl> productOptionXref = criteria.from(ProductOptionXrefImpl.class); Join<ProductOptionXref, Product> product = productOptionXref.join("product"); Join<ProductOptionXref, ProductOption> productOption = productOptionXref.join("productOption"); if (count) { criteria.select(builder.count(product)); } else { // Product IDs are what we want back criteria.select(product.get("id").as(Long.class)); } criteria.distinct(true); List<Predicate> restrictions = new ArrayList<Predicate>(); restrictions.add(productOption.get("id").in(sandBoxHelper.mergeCloneIds(ProductOptionImpl.class, productOptionId))); // Execute the query with the restrictions criteria.where(restrictions.toArray(new Predicate[restrictions.size()])); return em.createQuery(criteria); }
/** * Create a new {@link JpaQueryCreator}. * * @param tree must not be {@literal null}. * @param type must not be {@literal null}. * @param builder must not be {@literal null}. * @param provider must not be {@literal null}. */ public JpaQueryCreator(PartTree tree, ReturnedType type, CriteriaBuilder builder, ParameterMetadataProvider provider) { super(tree); this.tree = tree; CriteriaQuery<? extends Object> criteriaQuery = createCriteriaQuery(builder, type); this.builder = builder; this.query = criteriaQuery.distinct(tree.isDistinct()); this.root = query.from(type.getDomainType()); this.provider = provider; this.returnedType = type; }
criteria.distinct(true).select(pathToUse.get(fieldName).as(fieldValueClass));
private <T> void useDistinctWhenLefOuterJoinsPresent(CriteriaQuery<T> criteriaQuery) { boolean useDistinct = false; Root<TaskImpl> taskRoot = null; ROOTS_FOR: for( Root root : criteriaQuery.getRoots() ) { if( TaskImpl.class.equals(root.getJavaType()) ) { taskRoot = (Root<TaskImpl>) root; for( Join<TaskImpl, ?> taskJoin : taskRoot.getJoins() ) { if( PeopleAssignmentsImpl.class.equals(taskJoin.getJavaType()) ) { Join<TaskImpl, PeopleAssignmentsImpl> peopleAssignJoin = (Join<TaskImpl, PeopleAssignmentsImpl>) taskJoin; if( JoinType.LEFT.equals(peopleAssignJoin.getJoinType()) ) { useDistinct = true; break ROOTS_FOR; } for( Join peopleAssignJoinJoin : peopleAssignJoin.getJoins() ) { if( JoinType.LEFT.equals(peopleAssignJoinJoin.getJoinType()) ) { useDistinct = true; break ROOTS_FOR; } } } } } } if( useDistinct ) { criteriaQuery.distinct(true); } }
private void findMatchingTagIds(String theResourceName, IIdType theResourceId, Set<Long> tagIds, Class<? extends BaseTag> entityClass) { { CriteriaBuilder builder = myEntityManager.getCriteriaBuilder(); CriteriaQuery<Tuple> cq = builder.createTupleQuery(); Root<? extends BaseTag> from = cq.from(entityClass); cq.multiselect(from.get("myTagId").as(Long.class)).distinct(true); if (theResourceName != null) { Predicate typePredicate = builder.equal(from.get("myResourceType"), theResourceName); if (theResourceId != null) { cq.where(typePredicate, builder.equal(from.get("myResourceId"), myIdHelperService.translateForcedIdToPid(theResourceName, theResourceId.getIdPart()))); } else { cq.where(typePredicate); } } TypedQuery<Tuple> query = myEntityManager.createQuery(cq); for (Tuple next : query.getResultList()) { tagIds.add(next.get(0, Long.class)); } } }
CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery cq = cb.createQuery(); Root<A> a = cq.from(A.class); Join<A, B> j = a.join("bcollection",JoinType.INNER); cq.distinct(true); Object r = em.createQuery(cq).getResultList();
@Override public CriteriaQuery<AggregationInterval> apply(CriteriaBuilder cb) { final CriteriaQuery<AggregationInterval> criteriaQuery = cb.createQuery(AggregationInterval.class); final Root<T> ba = criteriaQuery.from(aggregationEntityType); criteriaQuery.distinct(true); criteriaQuery.select(ba.get(BaseAggregationImpl_.interval)); return criteriaQuery; } });
@Override public CriteriaQuery<AggregatedGroupMappingImpl> apply( CriteriaBuilder cb) { final CriteriaQuery<AggregatedGroupMappingImpl> criteriaQuery = cb.createQuery(AggregatedGroupMappingImpl.class); final Root<T> ba = criteriaQuery.from(aggregationEntityType); criteriaQuery.distinct(true); criteriaQuery.select(ba.get(BaseAggregationImpl_.aggregatedGroup)); return criteriaQuery; } });
@Override public CriteriaQuery<String> apply(CriteriaBuilder cb) { final CriteriaQuery<String> criteriaQuery = cb.createQuery(String.class); final Root<LocalAccountPersonAttributeImpl> accountRoot = criteriaQuery.from(LocalAccountPersonAttributeImpl.class); criteriaQuery.select( accountRoot.get(LocalAccountPersonAttributeImpl_.name)); criteriaQuery.distinct(true); return criteriaQuery; } });
@Override public CriteriaQuery<String> apply(CriteriaBuilder cb) { final CriteriaQuery<String> criteriaQuery = cb.createQuery(String.class); final Root<LocalAccountPersonAttributeImpl> accountRoot = criteriaQuery.from(LocalAccountPersonAttributeImpl.class); criteriaQuery.select( accountRoot.get(LocalAccountPersonAttributeImpl_.name)); criteriaQuery.distinct(true); return criteriaQuery; } });
@Override public List<Company> findAll() { CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<Company> query = builder.createQuery(Company.class); Root<Company> root = query.from(Company.class); query.select(root).distinct(true); TypedQuery<Company> allQuery = entityManager.createQuery(query); return allQuery.getResultList(); }
public FixedJpaQueryCreator(PartTree tree, Class<?> domainClass, CriteriaBuilder builder, ParameterMetadataProvider provider) { super(tree); this.builder = builder; this.query = builder.createQuery().distinct(tree.isDistinct()); this.root = query.from(domainClass); this.provider = provider; }
public FixedJpaQueryCreator(PartTree tree, Class<?> domainClass, CriteriaBuilder builder, ParameterMetadataProvider provider) { super(tree); this.builder = builder; this.query = builder.createQuery().distinct(tree.isDistinct()); this.root = query.from(domainClass); this.provider = provider; }
public FixedJpaQueryCreator(PartTree tree, Class<?> domainClass, CriteriaBuilder builder, ParameterMetadataProvider provider) { super(tree); this.builder = builder; this.query = builder.createQuery().distinct(tree.isDistinct()); this.root = query.from(domainClass); this.provider = provider; }
/** * Methode d'ajout des Proprietes a charger a la requete de recherche * @param root Entités objet du from * @param query Requete sur l'entité * @param properties Conteneur de propriétés */ protected void addProperties(Root<T> root, CriteriaQuery<T> query, Set<String> properties) { // Ajout des ppt addProperties(root, properties); // On positionne le distict query.distinct(true); }
@Override public List<URI> serviceIds() { CriteriaQuery<URI> query = entityManager(). getCriteriaBuilder(). createQuery(URI.class); Root<Service> service = query.from(Service.class); query. select(service.<URI>get("serviceId")). distinct(true); return entityManager().createQuery(query).getResultList(); }
@Override public List<URI> executionIds() { final CriteriaQuery<URI> query = entityManager(). getCriteriaBuilder(). createQuery(URI.class); final Root<Execution> execution = query.from(Execution.class); query. select(execution.<URI>get("executionId")). distinct(true); return entityManager().createQuery(query).getResultList(); }
@Override public List<URI> repositoryLocations() { final CriteriaQuery<URI> query = entityManager(). getCriteriaBuilder(). createQuery(URI.class); final Root<Repository> service = query.from(Repository.class); query. select(service.<URI>get("location")). distinct(true); return entityManager().createQuery(query).getResultList(); }
@Override public long countByRsql(final String targetFilterQuery) { final Specification<JpaTarget> specs = RSQLUtility.parse(targetFilterQuery, TargetFields.class, virtualPropertyReplacer, database); return targetRepository.count((root, query, cb) -> { query.distinct(true); return specs.toPredicate(root, query, cb); }); }
@Override public long countByRsql(final String targetFilterQuery) { final Specification<JpaTarget> specs = RSQLUtility.parse(targetFilterQuery, TargetFields.class, virtualPropertyReplacer, database); return targetRepository.count((root, query, cb) -> { query.distinct(true); return specs.toPredicate(root, query, cb); }); }