Refine search
@Override public List<CustomerAddress> readBatchCustomerAddresses(int start, int pageSize) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<CustomerAddress> criteria = builder.createQuery(CustomerAddress.class); Root<CustomerAddressImpl> customer = criteria.from(CustomerAddressImpl.class); criteria.select(customer); TypedQuery<CustomerAddress> query = em.createQuery(criteria); query.setFirstResult(start); query.setMaxResults(pageSize); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.CustomerAddress"); return query.getResultList(); }
@Override public List<Customer> findByLastname(String lastname, int page, int pageSize) { TypedQuery<Customer> query = em.createQuery("select c from Customer c where c.lastname = ?1", Customer.class); query.setParameter(1, lastname); query.setFirstResult(page * pageSize); query.setMaxResults(pageSize); return query.getResultList(); } }
@Override public Long readTotalCategoryCount() { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Long> criteria = builder.createQuery(Long.class); criteria.select(builder.count(criteria.from(CategoryImpl.class))); TypedQuery<Long> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Catalog"); return query.getSingleResult(); }
@Override public List<Account> findByCustomer(Customer customer) { TypedQuery<Account> query = em.createQuery("select a from Account a where a.customer = ?1", Account.class); query.setParameter(1, customer); return query.getResultList(); } }
@Override public List<IndexField> readAllIndexFieldsByFieldId(Long fieldId) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<IndexField> criteria = builder.createQuery(IndexField.class); Root<IndexFieldImpl> search = criteria.from(IndexFieldImpl.class); criteria.select(search); criteria.where( builder.equal(search.join("field").get("id").as(Long.class), fieldId) ); TypedQuery<IndexField> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Search"); return query.getResultList(); }
@Override public List<Long> readAllGenericEntityId(Class<?> clazz) { clazz = DynamicDaoHelperImpl.getNonProxyImplementationClassIfNecessary(clazz); CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Long> criteria = builder.createQuery(Long.class); Root root = criteria.from(clazz); criteria.select(root.get(getIdField(clazz).getName()).as(Long.class)); criteria.orderBy(builder.asc(root.get(getIdField(clazz).getName()))); return em.createQuery(criteria).getResultList(); }
@Override public List<Page> readOnlineAndIncludedPages(int limit, int offset, String sortBy) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Page> criteria = builder.createQuery(Page.class); Root<PageImpl> page = criteria.from(PageImpl.class); criteria.select(page); criteria.where(builder.and( builder.or(builder.isFalse(page.get("offlineFlag").as(Boolean.class)), builder.isNull(page.get("offlineFlag").as(Boolean.class))), builder.or(builder.isFalse(page.get("excludeFromSiteMap").as(Boolean.class)), builder.isNull(page.get("excludeFromSiteMap").as(Boolean.class))))); criteria.orderBy(builder.asc(page.get(sortBy))); TypedQuery<Page> query = em.createQuery(criteria); query.setFirstResult(offset); query.setMaxResults(limit); query.setHint(QueryHints.HINT_CACHEABLE, true); return query.getResultList(); }
@Override public List<SearchFacet> readAllSearchFacets(FieldEntity entityType) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<SearchFacet> criteria = builder.createQuery(SearchFacet.class); Root<SearchFacetImpl> facet = criteria.from(SearchFacetImpl.class); criteria.select(facet); Path<Character> archived = facet.get("archiveStatus").get("archived"); criteria.where( builder.equal(facet.get("showOnSearch").as(Boolean.class), true), builder.or(builder.isNull(archived.as(String.class)), builder.notEqual(archived.as(Character.class), 'Y')), facet.join("fieldType") .join("indexField") .join("field") .get("entityType") .as(String.class) .in(entityType.getAllLookupTypes()) ); TypedQuery<SearchFacet> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Search"); return query.getResultList(); }
@Override public List<Order> readOrdersByDateRange(final Date startDate, final Date endDate) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Order> criteria = builder.createQuery(Order.class); Root<OrderImpl> order = criteria.from(OrderImpl.class); criteria.select(order); criteria.where(builder.between(order.<Date>get("submitDate"), startDate, endDate)); criteria.orderBy(builder.desc(order.get("submitDate"))); TypedQuery<Order> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Order"); return query.getResultList(); }
@Override public void removedExpiredAccounts(LocalDate reference) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Account> query = cb.createQuery(Account.class); Root<Account> account = query.from(Account.class); query.where(cb.lessThan(account.get("expiryDate").as(Date.class), reference.toDateTimeAtStartOfDay().toDate())); for (Account each : em.createQuery(query).getResultList()) { em.remove(each); } } }
@TestForIssue(jiraKey = "HHH-9296") @Test public void selectByParent() { doInJPA( this::entityManagerFactory, entityManager -> { Post post = entityManager.find( Post.class, 1 ); CriteriaBuilder cb = entityManager.getCriteriaBuilder(); CriteriaQuery<PostDetails> query = cb.createQuery( PostDetails.class ); Root<PostDetails> root = query.from( PostDetails.class ); query.where( cb.equal( root.get( "post" ), post ) ); final PostDetails result = entityManager.createQuery( query ).getSingleResult(); assertNotNull( result ); }); }
@Test public void test_criteria_param_example() { doInJPA( this::entityManagerFactory, entityManager -> { //tag::criteria-param-example[] CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<Person> criteria = builder.createQuery( Person.class ); Root<Person> root = criteria.from( Person.class ); ParameterExpression<String> nickNameParameter = builder.parameter( String.class ); criteria.where( builder.equal( root.get( Person_.nickName ), nickNameParameter ) ); TypedQuery<Person> query = entityManager.createQuery( criteria ); query.setParameter( nickNameParameter, "JD" ); List<Person> persons = query.getResultList(); //end::criteria-param-example[] assertEquals(1, persons.size()); }); }
protected List<Product> readFilteredActiveProductsByQueryInternal(String query, Date currentDate, SearchCriteria searchCriteria) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Product> criteria = builder.createQuery(Product.class); Root<ProductImpl> product = criteria.from(ProductImpl.class); Join<Product, Sku> sku = product.join("defaultSku"); criteria.select(product); String lq = query.toLowerCase(); restrictions.add( builder.or( builder.like(builder.lower(sku.get("name").as(String.class)), '%' + lq + '%'), builder.like(builder.lower(sku.get("longDescription").as(String.class)), '%' + lq + '%') criteria.where(restrictions.toArray(new Predicate[restrictions.size()])); TypedQuery<Product> typedQuery = em.createQuery(criteria); return typedQuery.getResultList();
@Override public Long countAllowedValuesForProductOptionById(Long productOptionId) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Long> criteria = builder.createQuery(Long.class); Root<ProductOptionValueImpl> root = criteria.from(ProductOptionValueImpl.class); criteria.select(builder.count(root)); List<Predicate> restrictions = new ArrayList<>(); List<Long> mergedIds = sandBoxHelper.mergeCloneIds(ProductOptionImpl.class, productOptionId); restrictions.add(root.get("productOption").in(mergedIds)); criteria.where(restrictions.toArray(new Predicate[restrictions.size()])); TypedQuery<Long> query = em.createQuery(criteria); return query.getSingleResult(); }
@Test public void test_hql_string_literals_example_1() { doInJPA( this::entityManagerFactory, entityManager -> { //tag::hql-string-literals-example[] List<Person> persons = entityManager.createQuery( "select p " + "from Person p " + "where p.name like 'Joe'", Person.class) .getResultList(); //end::hql-string-literals-example[] }); }
protected List<Product> readFilteredActiveProductsByCategoryInternal(Long categoryId, Date currentDate, SearchCriteria searchCriteria) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Product> criteria = builder.createQuery(Product.class); Root<CategoryProductXrefImpl> productXref = criteria.from(CategoryProductXrefImpl.class); Join<CategoryProductXref, Product> product = productXref.join("product"); Join<Product, Sku> sku = product.join("defaultSku"); Join<CategoryProductXref, Category> category = productXref.join("category"); criteria.select(product); restrictions.add(category.get("id").in(sandBoxHelper.mergeCloneIds(CategoryImpl.class, categoryId))); criteria.where(restrictions.toArray(new Predicate[restrictions.size()])); TypedQuery<Product> typedQuery = em.createQuery(criteria); return typedQuery.getResultList();
public List<User> myCustomBatchOperation() { CriteriaQuery<User> criteriaQuery = em.getCriteriaBuilder().createQuery(User.class); criteriaQuery.select(criteriaQuery.from(User.class)); return em.createQuery(criteriaQuery).getResultList(); } }
@Test public void test_criteria_from_join_example() { doInJPA( this::entityManagerFactory, entityManager -> { //tag::criteria-from-join-example[] CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<Phone> criteria = builder.createQuery( Phone.class ); Root<Phone> root = criteria.from( Phone.class ); // Phone.person is a @ManyToOne Join<Phone, Person> personJoin = root.join( Phone_.person ); // Person.addresses is an @ElementCollection Join<Person, String> addressesJoin = personJoin.join( Person_.addresses ); criteria.where( builder.isNotEmpty( root.get( Phone_.calls ) ) ); List<Phone> phones = entityManager.createQuery( criteria ).getResultList(); //end::criteria-from-join-example[] assertEquals(2, phones.size()); }); }
@Test public void test_hql_string_literals_example_3() { doInJPA( this::entityManagerFactory, entityManager -> { //tag::hql-numeric-literals-example[] // simple integer literal Person person = entityManager.createQuery( "select p " + "from Person p " + "where p.id = 1", Person.class) .getSingleResult(); //end::hql-numeric-literals-example[] }); }
@Test public void test_criteria_from_fetch_example() { doInJPA( this::entityManagerFactory, entityManager -> { //tag::criteria-from-fetch-example[] CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<Phone> criteria = builder.createQuery( Phone.class ); Root<Phone> root = criteria.from( Phone.class ); // Phone.person is a @ManyToOne Fetch<Phone, Person> personFetch = root.fetch( Phone_.person ); // Person.addresses is an @ElementCollection Fetch<Person, String> addressesJoin = personFetch.fetch( Person_.addresses ); criteria.where( builder.isNotEmpty( root.get( Phone_.calls ) ) ); List<Phone> phones = entityManager.createQuery( criteria ).getResultList(); //end::criteria-from-fetch-example[] assertEquals(2, phones.size()); }); }