public List<Company> retrieveCompanys(String name, String category) { EntityManager em = createEntityManager(); List<Company> company = null; try { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Company> cq = cb.createQuery(Company.class); Root<Company> c = cq.from(Company.class); List<Predicate> conditions = new ArrayList<Predicate>(); if (name != null) { Predicate nameCondition = cb.like(c.get(Company_.name), "%" + name + "%"); conditions.add(nameCondition); } if (category != null) { Path<CompanyCategory> companyCategoryPath = c.get(Company_.category); Path<String> companyCategoryNamePath = companyCategoryPath.get(CompanyCategory_.categoryName); Predicate categoryCondition = cb.like(companyCategoryNamePath, category + "%"); conditions.add(categoryCondition); } cq.where(conditions.toArray(new Predicate[0])); TypedQuery<Company> query = em.createQuery(cq); company = query.getResultList(); } finally { em.close(); } return company; }
public static CriteriaQuery<Organization> buildSearchQuery( String name, String email, String phone, String type, String region, String district, String locality, String streetToSearch, String sortCriteria, String sortOrder, EntityManager em) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Organization> criteriaQuery = cb.createQuery(Organization.class); Root<Organization> root = criteriaQuery.from(Organization.class); Predicate predicate = ArchivalOrganizationsQueryConstructorAdmin.buildPredicate( name, email, type, phone, region, district, locality, streetToSearch, root, cb); if ((sortCriteria != null) && (sortOrder != null)) { criteriaQuery.orderBy( SortCriteriaOrganization.valueOf(sortCriteria.toUpperCase()) .getSortOrder(root, cb, sortOrder)); } else { criteriaQuery.orderBy(cb.desc(root.get("id"))); } criteriaQuery.select(root); criteriaQuery.where(predicate); return criteriaQuery; }
@Transactional(propagation = Propagation.NOT_SUPPORTED) public List<AccessKey> list( Long userId, String label, String labelPattern, Integer type, String sortField, Boolean sortOrderAsc, Integer take, Integer skip) { CriteriaBuilder cb = genericDAO.criteriaBuilder(); CriteriaQuery<AccessKey> cq = cb.createQuery(AccessKey.class); Root<AccessKey> from = cq.from(AccessKey.class); Predicate[] predicates = CriteriaHelper.accessKeyListPredicates( cb, from, userId, ofNullable(label), ofNullable(labelPattern), ofNullable(type)); cq.where(predicates); CriteriaHelper.order(cb, cq, from, ofNullable(sortField), Boolean.TRUE.equals(sortOrderAsc)); TypedQuery<AccessKey> query = genericDAO.createQuery(cq); ofNullable(skip).ifPresent(query::setFirstResult); ofNullable(take).ifPresent(query::setMaxResults); genericDAO.cacheQuery(query, of(CacheConfig.bypass())); return query.getResultList(); }
protected static Predicate getPredicate( final Class clazz, final Restriction searchTerms, Root<Persistable> root, CriteriaBuilder cb) { LinkedList<Predicate> predicates = new LinkedList<Predicate>(); Predicate predicate; // process child restrictions if (!CollectionUtils.isEmpty(searchTerms.getRestrictions())) { for (Restriction restriction : searchTerms.getRestrictions()) { predicates.add(getPredicate(clazz, restriction, root, cb)); } } // process main restriction if (StringUtils.isNotBlank(searchTerms.getField())) { String propertyName = searchTerms.getField(); addPredicate( clazz, root, cb, predicates, searchTerms.getValues().toArray(new String[searchTerms.getValues().size()]), propertyName); } if (searchTerms.getJunction().equals(Restriction.Junction.OR)) { predicate = cb.or(predicates.toArray(new Predicate[predicates.size()])); } else { predicate = cb.and(predicates.toArray(new Predicate[predicates.size()])); } return predicate; }
@Override public <T extends StoredObject> List<T> getStoredObjects(final Class<T> tClass) { List<T> list = Collections.emptyList(); emLock.lock(); try { final Future<List<T>> future = executorService.submit( () -> { final CriteriaBuilder cb = em.getCriteriaBuilder(); final CriteriaQuery<T> cq = cb.createQuery(tClass); final Root<T> root = cq.from(tClass); cq.select(root); final TypedQuery<T> q = em.createQuery(cq); return new ArrayList<>(q.getResultList()); }); list = future.get(); } catch (InterruptedException | ExecutionException e) { logger.log(Level.SEVERE, e.getLocalizedMessage(), e); } finally { emLock.unlock(); } return stripMarkedForRemoval(list); }
/** This test provides a demonstration of testing membership in a collection. */ @Test public void testMemberOf() { log.info("*** testMemberOf() ***"); CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Clerk> qdef = cb.createQuery(Clerk.class); // select c from Clerk c where c.firstName = 'Manny' Root<Clerk> c = qdef.from(Clerk.class); qdef.select(c).where(cb.equal(c.get("firstName"), "Manny")); Clerk clerk = em.createQuery(qdef).getSingleResult(); // find all sales that involve this clerk CriteriaQuery<Sale> qdef2 = cb.createQuery(Sale.class); // select s from Sale s // where :clerk MEMBER OF s.clerks", Root<Sale> s = qdef2.from(Sale.class); qdef2.select(s).where(cb.isMember(clerk, s.<List<Clerk>>get("clerks"))); List<Sale> sales = em.createQuery(qdef2).getResultList(); for (Sale result : sales) { log.info("found=" + result); } assertEquals("unexpected number of rows", 2, sales.size()); }
/** This test demonstrates the use of DISTINCT to limit the results to only unique values */ @Test public void testDISTINCT() { log.info("*** testDISTINCT() ***"); CriteriaBuilder cb = em.getCriteriaBuilder(); { CriteriaQuery<String> qdef = cb.createQuery(String.class); // select DISTINCT c.lastName from Customer c Root<Customer> c = qdef.from(Customer.class); qdef.select(c.<String>get("lastName")).distinct(true); int rows = executeQuery(qdef).size(); assertEquals("unexpected number of rows", 3, rows); } { CriteriaQuery<String> qdef = cb.createQuery(String.class); // select DISTINCT c.firstName from Customer c Root<Customer> c = qdef.from(Customer.class); qdef.select(c.<String>get("firstName")).distinct(true); int rows = executeQuery(qdef).size(); assertEquals("unexpected number of rows for DISTINCT", 2, rows); } }
@Test @Transactional public void testCopy() { EntityManager em = bookDao.getEntityManager(); CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Book> criteria = cb.createQuery(Book.class); // Fetch join Root<Book> root = criteria.from(Book.class); Path<String> path = root.join("author").<String>get("name"); root.fetch("author"); criteria.select(root); // SubQuery Subquery<String> sq = criteria.subquery(String.class); Root<Author> author = sq.from(Author.class); sq.select(author.<String>get("name")); sq.where(cb.equal(author.<String>get("name"), "Rod")); criteria.where(cb.in(path).value(sq)); CriteriaQuery<Book> copy = cb.createQuery(Book.class); JpaUtils.copyCriteria(criteria, copy); List<Book> copyBooks = em.createQuery(copy).getResultList(); List<Book> books = em.createQuery(criteria).getResultList(); assertEquals(books, copyBooks); }
/** Load business rules */ private void loadList() { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<BusinessRule> c = cb.createQuery(BusinessRule.class); Root<BusinessRule> obj = c.from(BusinessRule.class); c.select(obj).where(cb.equal(obj.get("project"), this.project)).orderBy(cb.asc(obj.get("id"))); this.businessRules = em.createQuery(c).getResultList(); }
@Override public ReferenceNumberType getByCode(String code) { ReferenceNumberType org = null; try { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<ReferenceNumberType> query = builder.createQuery(ReferenceNumberType.class); Root<ReferenceNumberType> rootEntity = query.from(ReferenceNumberType.class); ParameterExpression<String> p = builder.parameter(String.class); query.select(rootEntity).where(builder.equal(rootEntity.get("code"), p)); TypedQuery<ReferenceNumberType> typedQuery = em.createQuery(query); typedQuery.setParameter(p, code); org = typedQuery.getSingleResult(); // TypedQuery<ReferenceNumberType> q = em.createQuery("select o from // com.conx.logistics.mdm.domain.referencenumber.ReferenceNumberType o WHERE o.code = // :code",ReferenceNumberType.class); // q.setParameter("code", code); // org = q.getSingleResult(); } catch (NoResultException e) { } catch (Exception e) { e.printStackTrace(); } catch (Error e) { StringWriter sw = new StringWriter(); e.printStackTrace(new PrintWriter(sw)); String stacktrace = sw.toString(); logger.error(stacktrace); } return org; }
/** load authUsers */ private void loadList() { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<AuthUser> c = cb.createQuery(AuthUser.class); Root<AuthUser> obj = c.from(AuthUser.class); c.select(obj).orderBy(cb.asc(obj.get("name"))); this.authUsers = em.createQuery(c).getResultList(); }
public List<Service> findByContract(Contract contract) { CriteriaBuilder cb = getEntityManager().getCriteriaBuilder(); CriteriaQuery<Service> cq = cb.createQuery(Service.class); Root<Service> rt = cq.from(Service.class); cq.select(rt).where(cb.equal(rt.get(Service_.contract), contract)); return getEntityManager().createQuery(cq).getResultList(); }
public List<Gestion> findAll() { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Gestion> criteria = cb.createQuery(Gestion.class); Root<Gestion> gestion = criteria.from(Gestion.class); criteria.select(gestion); return em.createQuery(criteria).getResultList(); }
@Override public List<TrashObject> getTrashObjects() { List<TrashObject> trashObjectList = Collections.emptyList(); emLock.lock(); try { final Future<List<TrashObject>> future = executorService.submit( () -> { final CriteriaBuilder cb = em.getCriteriaBuilder(); final CriteriaQuery<TrashObject> cq = cb.createQuery(TrashObject.class); final Root<TrashObject> root = cq.from(TrashObject.class); cq.select(root); final TypedQuery<TrashObject> q = em.createQuery(cq); return new ArrayList<>(q.getResultList()); }); trashObjectList = future.get(); } catch (final InterruptedException | ExecutionException e) { logger.log(Level.SEVERE, e.getLocalizedMessage(), e); } finally { emLock.unlock(); } return trashObjectList; }
/** * TODO A COMMENTER * * @param stepArray TODO A COMMENTER * @return TODO A COMMENTER * @throws PersistenceException TODO A COMMENTER */ protected CriteriaQuery<SALE> getCriteriaForStep(Step... stepArray) throws PersistenceException { CriteriaBuilder builder = this.getCriteriaBuilder(); CriteriaQuery<SALE> criteria = this.createCriteria(); Root<SALE> sale_ = criteria.from(this.getEntityClass()); if (stepArray.length != 0) { Path<SaleStep> saleStep_ = this.getSaleStepPath(sale_); Bid4WinSet<Step> stepSet = new Bid4WinSet<Step>(); for (Step step : stepArray) { stepSet.add(step); stepSet.addAll(step.getRecursiveSubtypeSet()); } Predicate[] predicates = new Predicate[stepSet.size()]; int i = 0; try { for (Step step : stepSet) { predicates[i++] = builder.equal(saleStep_, new SaleStep(step)); } } catch (UserException ex) { throw new PersistenceException(ex); } Predicate condition = builder.or(predicates); criteria.where(condition); } return criteria; }
protected Predicate[] getPredicates(CriteriaBuilder cb, Root<OutgoingDocument> root) { List<Predicate> predicates = new ArrayList<>(); predicates.add( cb.notEqual(root.get(OutgoingDocument_.documentCondition), DocumentCondition.DELETED)); predicates.add(cb.equal(root.get(OutgoingDocument_.registratorEmployee), getCurrentEmployee())); return predicates.toArray(new Predicate[predicates.size()]); }
public List<MyClass138> findByCriteria(MyClass138Criteria myClass138Criteria) { javax.persistence.criteria.CriteriaBuilder cb = this.entityManager.getCriteriaBuilder(); javax.persistence.criteria.CriteriaQuery<MyClass138> c = cb.createQuery(MyClass138.class); javax.persistence.criteria.Root<MyClass138> emp = c.from(MyClass138.class); c.select(emp); List<javax.persistence.criteria.Predicate> criteria = new java.util.ArrayList<javax.persistence.criteria.Predicate>(); if (myClass138Criteria.getId() != null) { javax.persistence.criteria.Expression<Long> p = emp.get("id"); javax.persistence.criteria.Expression<Long> val = cb.parameter(Long.class, "id"); criteria.add(cb.equal(p, val)); } if (criteria.size() == 1) { c.where(criteria.get(0)); } else { c.where(cb.and(criteria.toArray(new javax.persistence.criteria.Predicate[0]))); } javax.persistence.TypedQuery<MyClass138> q = this.entityManager.createQuery(c); if (myClass138Criteria.getId() != null) { q.setParameter("id", myClass138Criteria.getId()); } return new java.util.ArrayList<MyClass138>(q.getResultList()); }
public static <E> Predicate byRanges( Root<E> root, CriteriaQuery<?> query, CriteriaBuilder builder, final List<Range<?, ?>> ranges, final Class<E> type) { List<Predicate> predicates = newArrayList(); for (Range<?, ?> r : ranges) { @SuppressWarnings("unchecked") Range<E, ?> range = (Range<E, ?>) r; if (range.isSet()) { Predicate rangePredicate = buildRangePredicate(range, root, builder); if (rangePredicate != null) { if (!range.isIncludeNullSet() || range.getIncludeNull() == FALSE) { predicates.add(rangePredicate); } else { predicates.add(builder.or(rangePredicate, builder.isNull(root.get(range.getField())))); } } // no range at all, let's take the opportunity to keep only null... if (TRUE == range.getIncludeNull()) { predicates.add(builder.isNull(root.get(range.getField()))); } else if (FALSE == range.getIncludeNull()) { predicates.add(builder.isNotNull(root.get(range.getField()))); } } } return JpaUtil.andPredicate(builder, predicates); }
/** This test provides an example collection path using an LEFT OUTER JOIN */ @Test public void testOuterJoin() { log.info("*** testOuterJoin() ***"); CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Object[]> qdef = cb.createQuery(Object[].class); // select c.id, c.firstName, sale.amount // from Clerk c // LEFT JOIN c.sales sale Root<Clerk> c = qdef.from(Clerk.class); Join<Clerk, Sale> sale = c.join("sales", JoinType.LEFT); qdef.select(cb.array(c.get("id"), c.get("firstName"), sale.get("amount"))); TypedQuery<Object[]> query = em.createQuery(qdef); List<Object[]> results = query.getResultList(); assertTrue("no results", results.size() > 0); for (Object[] result : results) { assertEquals("unexpected result length", 3, result.length); Long id = (Long) result[0]; String name = (String) result[1]; BigDecimal amount = (BigDecimal) result[2]; log.info("clerk.id=" + id + ", clerk.firstName=" + name + ", amount=" + amount); } }
/** * Count the objects in the database * * @return Number of objects */ public int count() { CriteriaBuilder b = getBuilder(); CriteriaQuery<Long> criteria = b.createQuery(Long.class); criteria.select(b.count(criteria.from(domainClass))); return em.createQuery(criteria).getSingleResult().intValue(); }
/** This test provides an example of testing whether the collection is empty */ @Test public void testIsEmpty() { log.info("*** testIsEmpty() ***"); CriteriaBuilder cb = em.getCriteriaBuilder(); { CriteriaQuery<Clerk> qdef = cb.createQuery(Clerk.class); // select c from Clerk c // where c.sales IS EMPTY Root<Clerk> c = qdef.from(Clerk.class); qdef.select(c).where(cb.isEmpty(c.<List<Sale>>get("sales"))); int rows = executeQuery(qdef).size(); assertEquals("unexpected number of rows", 1, rows); } { CriteriaQuery<Clerk> qdef = cb.createQuery(Clerk.class); // select c from Clerk c // where c.sales IS NOT EMPTY Root<Clerk> c = qdef.from(Clerk.class); qdef.select(c).where(cb.isNotEmpty(c.<List<Sale>>get("sales"))); int rows = executeQuery(qdef).size(); assertEquals("unexpected number of rows", 2, rows); } }
public List<Artikel> findArtikelByIds(List<Long> ids) { if (ids == null || ids.isEmpty()) { return Collections.emptyList(); } /* * SELECT a FROM Artikel a WHERE a.id = ? OR a.id = ? OR ... */ final CriteriaBuilder builder = em.getCriteriaBuilder(); final CriteriaQuery<Artikel> criteriaQuery = builder.createQuery(Artikel.class); final Root<Artikel> a = criteriaQuery.from(Artikel.class); final Path<Long> idPath = a.get("id"); // final Path<String> idPath = a.get(Artikel_.id); // Metamodel-Klassen funktionieren nicht mit // Eclipse Predicate pred = null; if (ids.size() == 1) { // Genau 1 id: kein OR notwendig pred = builder.equal(idPath, ids.get(0)); } else { // Mind. 2x id, durch OR verknuepft final Predicate[] equals = new Predicate[ids.size()]; int i = 0; for (Long id : ids) { equals[i++] = builder.equal(idPath, id); } pred = builder.or(equals); } criteriaQuery.where(pred); return em.createQuery(criteriaQuery).getResultList(); }
/** This test provides a demonstration of using an explicit subquery */ @Test public void testSubqueries() { log.info("*** testSubqueries() ***"); CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Customer> qdef = cb.createQuery(Customer.class); // select c from Customer c // where c.id IN // (select s.buyerId from Sale s // where s.amount > 100) // form subquery Subquery<Long> sqdef = qdef.subquery(Long.class); Root<Sale> s = sqdef.from(Sale.class); sqdef .select(s.<Long>get("buyerId")) .where(cb.greaterThan(s.<BigDecimal>get("amount"), new BigDecimal(100))); // form outer query Root<Customer> c = qdef.from(Customer.class); qdef.select(c).where(cb.in(c.get("id")).value(sqdef)); int rows = executeQuery(qdef).size(); assertEquals("unexpected number of rows", 1, rows); }
public void testMetamodelOnClauseOverCollection() { EntityManager em = createEntityManager(); Query query = em.createQuery("Select e from Employee e join e.phoneNumbers p on p.areaCode = '613'"); List baseResult = query.getResultList(); CriteriaBuilder qb = em.getCriteriaBuilder(); CriteriaQuery<Employee> cq = qb.createQuery(Employee.class); Metamodel metamodel = em.getMetamodel(); EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class); EntityType<PhoneNumber> entityPhone_ = metamodel.entity(PhoneNumber.class); Root<Employee> root = cq.from(entityEmp_); Join phoneNumber = root.join(entityEmp_.getCollection("phoneNumbers")); phoneNumber.on(qb.equal(phoneNumber.get(entityPhone_.getSingularAttribute("areaCode")), "613")); List testResult = em.createQuery(cq).getResultList(); clearCache(); closeEntityManager(em); if (baseResult.size() != testResult.size()) { fail( "Criteria query using ON clause did not match JPQL results; " + baseResult.size() + " were expected, while criteria query returned " + testResult.size()); } }
@Override public final List<T> findListByProperty( final Object[] values, final SingularAttribute<T, ? extends Object>... properties) { final CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(persistentClass); final Root<T> root = criteriaQuery.from(persistentClass); criteriaQuery.select(root); final Object value = values[0]; final SingularAttribute<T, ? extends Object> property = properties[0]; Predicate condition; condition = QueryHelper.equalsIgnoreCaseIfStringPredicate(criteriaBuilder, root, value, property); if (values.length > 1) { for (int i = 1; i < properties.length; i++) { final SingularAttribute<T, ? extends Object> property2 = properties[i]; final Object value2 = values[i]; final Predicate condition2 = QueryHelper.equalsIgnoreCaseIfStringPredicate(criteriaBuilder, root, value2, property2); condition = criteriaBuilder.and(condition, condition2); } } criteriaQuery.where(condition); final TypedQuery<T> typedQuery = getEntityManager().createQuery(criteriaQuery); addCacheHints(typedQuery, "findListByProperty"); return typedQuery.getResultList(); }
public void testMetamodelOnClauseWithLeftJoin() { EntityManager em = createEntityManager(); Query query = em.createQuery( "Select e from Employee e left join e.address a on a.city = 'Ottawa' " + "where a.postalCode is not null"); List baseResult = query.getResultList(); Metamodel metamodel = em.getMetamodel(); EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class); EntityType<Address> entityAddr_ = metamodel.entity(Address.class); CriteriaBuilder qb = em.getCriteriaBuilder(); CriteriaQuery<Employee> cq = qb.createQuery(Employee.class); Root<Employee> root = cq.from(entityEmp_); Join address = root.join(entityEmp_.getSingularAttribute("address"), JoinType.LEFT); address.on(qb.equal(address.get(entityAddr_.getSingularAttribute("city")), "Ottawa")); cq.where(qb.isNotNull(address.get(entityAddr_.getSingularAttribute("postalCode")))); List testResult = em.createQuery(cq).getResultList(); clearCache(); closeEntityManager(em); if (baseResult.size() != testResult.size()) { fail( "Criteria query using ON clause with a left join did not match JPQL results; " + baseResult.size() + " were expected, while criteria query returned " + testResult.size()); } }
protected static Predicate getPredicate( final Class clazz, final Map<String, String[]> searchTerms, Root<Persistable> root, CriteriaBuilder cb) { LinkedList<Predicate> predicates = new LinkedList<Predicate>(); Predicate predicate; if (!CollectionUtils.isEmpty(searchTerms)) { Set<String> propertyNames = searchTerms.keySet(); // put aside nested AND/OR param groups NestedJunctions junctions = new NestedJunctions(); for (String propertyName : propertyNames) { String[] values = searchTerms.get(propertyName); if (!junctions.addIfNestedJunction(propertyName, values)) { addPredicate(clazz, root, cb, predicates, values, propertyName); } } // add nested AND/OR param groups Map<String, Map<String, String[]>> andJunctions = junctions.getAndJunctions(); addJunctionedParams(clazz, root, cb, predicates, andJunctions, AND); Map<String, Map<String, String[]>> orJunctions = junctions.getOrJunctions(); addJunctionedParams(clazz, root, cb, predicates, orJunctions, OR); } if (searchTerms.containsKey(SEARCH_MODE) && searchTerms.get(SEARCH_MODE)[0].equalsIgnoreCase(OR)) { predicate = cb.or(predicates.toArray(new Predicate[predicates.size()])); } else { predicate = cb.and(predicates.toArray(new Predicate[predicates.size()])); } return predicate; }
public List<Equipment> findAllOrderedByProductionDate() { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Equipment> criteria = cb.createQuery(Equipment.class); Root<Equipment> equipment = criteria.from(Equipment.class); criteria.select(equipment).orderBy(cb.desc(equipment.get("productionDate"))); return em.createQuery(criteria).getResultList(); }
/** * Service method to return all StockCategory from database * * @return */ public List<StockCategory> findAllStockCategories() { CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder(); CriteriaQuery<StockCategory> criteria = criteriaBuilder.createQuery(StockCategory.class); Root<StockCategory> stockCategory = criteria.from(StockCategory.class); criteria.select(stockCategory); return entityManager.createQuery(criteria).getResultList(); }
public <E> Predicate byEntitySelectors( Root<E> root, CriteriaBuilder builder, SearchParameters sp) { List<EntitySelector<?, ?, ?>> selectors = sp.getEntities(); List<Predicate> predicates = newArrayList(); for (EntitySelector<?, ?, ?> s : selectors) { @SuppressWarnings("unchecked") EntitySelector<? super E, ? extends Identifiable<?>, ?> selector = (EntitySelector<? super E, ? extends Identifiable<?>, ?>) s; if (selector.isNotEmpty()) { List<Predicate> selectorPredicates = newArrayList(); for (Identifiable<?> selection : selector.getSelected()) { selectorPredicates.add(builder.equal(getExpression(root, selector), selection.getId())); } if (TRUE == selector.getIncludeNull()) { selectorPredicates.add(builder.or(builder.isNull(getExpression(root, selector)))); } predicates.add(JpaUtil.orPredicate(builder, selectorPredicates)); } else if (selector.isIncludeNullSet()) { if (selector.getIncludeNull()) { predicates.add(builder.isNull(getExpression(root, selector))); } else { predicates.add(builder.isNotNull(getExpression(root, selector))); } } } return JpaUtil.concatPredicate(sp, builder, predicates); }