Examples with Root javax.persistence.criteria.Root used on opensource projects

Example 1 with Root

use of javax.persistence.criteria.Root in project robo4j by Robo4J.

the class DefaultRepository method findByFields.

@SuppressWarnings("unchecked")
@Override
public <T> List<T> findByFields(Class<T> clazz, Map<String, Object> map, int limit, SortType sort) {
    EntityManager em = dataSourceContext.getEntityManager(clazz);
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery cq = cb.createQuery(clazz);
    Root<T> rs = cq.from(clazz);
    List<Predicate> predicates = map.entrySet().stream().map(e -> cb.equal(rs.get(e.getKey()), e.getValue())).collect(Collectors.toList());
    CriteriaQuery<T> cq2 = cq.where(predicates.toArray(new Predicate[predicates.size()])).orderBy(getOrderById(cb, rs, sort)).select(rs);
    TypedQuery<T> tq = em.createQuery(cq2);
    //@formatter:off
    return tq.setMaxResults(limit).getResultList();
//@formatter:on
}

Example 2 with Root

use of javax.persistence.criteria.Root in project hibernate-orm by hibernate.

the class ManipulationCriteriaTest method testJoinsAndFetchesDisallowed.

@Test
public void testJoinsAndFetchesDisallowed() {
    EntityManager em = getOrCreateEntityManager();
    em.getTransaction().begin();
    CriteriaBuilder builder = em.getCriteriaBuilder();
    {
        try {
            CriteriaDelete<Customer> deleteCriteria = builder.createCriteriaDelete(Customer.class);
            Root<Customer> root = deleteCriteria.from(Customer.class);
            root.join(Customer_.spouse);
            em.createQuery(deleteCriteria).executeUpdate();
            fail("Expected failure dues to attempt to join");
        } catch (IllegalArgumentException expected) {
        }
    }
    {
        try {
            CriteriaDelete<Customer> deleteCriteria = builder.createCriteriaDelete(Customer.class);
            Root<Customer> root = deleteCriteria.from(Customer.class);
            root.fetch(Customer_.spouse);
            em.createQuery(deleteCriteria).executeUpdate();
            fail("Expected failure dues to attempt to fetch");
        } catch (IllegalArgumentException expected) {
        }
    }
    {
        try {
            CriteriaUpdate<Customer> updateCriteria = builder.createCriteriaUpdate(Customer.class);
            Root<Customer> root = updateCriteria.from(Customer.class);
            root.join(Customer_.spouse);
            em.createQuery(updateCriteria).executeUpdate();
            fail("Expected failure dues to attempt to join");
        } catch (IllegalArgumentException expected) {
        }
    }
    {
        try {
            CriteriaUpdate<Customer> updateCriteria = builder.createCriteriaUpdate(Customer.class);
            Root<Customer> root = updateCriteria.from(Customer.class);
            root.fetch(Customer_.spouse);
            em.createQuery(updateCriteria).executeUpdate();
            fail("Expected failure dues to attempt to fetch");
        } catch (IllegalArgumentException expected) {
        }
    }
    em.getTransaction().commit();
    em.close();
}

Example 3 with Root

use of javax.persistence.criteria.Root in project ART-TIME by Artezio.

the class UniqueConstraintValidator method buildCriteriaQuery.

private CriteriaQuery<?> buildCriteriaQuery(Object targetObject, String[] attributeNames, boolean addPrimaryKeyPredicate) {
    Class<?> targetObjectClass = targetObject.getClass();
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<?> criteriaQuery = criteriaBuilder.createQuery(targetObjectClass);
    Root rootObject = criteriaQuery.from(targetObjectClass);
    criteriaQuery.select(rootObject);
    List<Predicate> where = buildUniquenessPredicates(criteriaBuilder, rootObject, attributeNames);
    if (addPrimaryKeyPredicate) {
        String primaryKeyName = getPrimaryKeyName(targetObjectClass);
        Predicate predicate = createPrimaryKeyPredicate(criteriaBuilder, rootObject, primaryKeyName);
        where.add(predicate);
    }
    criteriaQuery.where(where.toArray(new Predicate[0]));
    return criteriaQuery;
}

Example 4 with Root

use of javax.persistence.criteria.Root in project CzechIdMng by bcvsolutions.

the class DefaultFormServiceItegrationTest method findOwnerByCriteria.

@Test
public void findOwnerByCriteria() {
    IdmRoleDto owner = helper.createRole();
    IdmRoleDto ownerTwo = helper.createRole();
    IdmFormDefinitionDto formDefinition = formService.getDefinition(IdmRole.class);
    IdmFormAttributeDto attribute = formDefinition.getFormAttributes().get(0);
    // 
    formService.saveValues(owner.getId(), IdmRole.class, attribute, Lists.newArrayList("test"));
    formService.saveValues(ownerTwo.getId(), IdmRole.class, attribute, Lists.newArrayList("test2"));
    Specification<IdmRole> criteria = new Specification<IdmRole>() {

        public Predicate toPredicate(Root<IdmRole> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
            Subquery<IdmRoleFormValue> subquery = query.subquery(IdmRoleFormValue.class);
            Root<IdmRoleFormValue> subRoot = subquery.from(IdmRoleFormValue.class);
            subquery.select(subRoot);
            Predicate predicate = builder.and(builder.equal(subRoot.get(IdmRoleFormValue_.owner), root), builder.equal(subRoot.get(IdmRoleFormValue_.formAttribute).get(IdmFormAttribute_.id), attribute.getId()), builder.equal(subRoot.get(IdmRoleFormValue_.stringValue), "test"));
            subquery.where(predicate);
            // 
            return query.where(builder.exists(subquery)).getRestriction();
        }
    };
    List<IdmRole> roles = roleRepository.findAll(criteria, (Pageable) null).getContent();
    assertEquals(1, roles.size());
    assertEquals(owner.getId(), roles.get(0).getId());
}

Example 5 with Root

use of javax.persistence.criteria.Root in project microservices by pwillhan.

the class Grouping method executeQueries.

@Test
public void executeQueries() throws Exception {
    storeTestData();
    CriteriaBuilder cb = JPA.getEntityManagerFactory().getCriteriaBuilder();
    UserTransaction tx = TM.getUserTransaction();
    try {
        tx.begin();
        EntityManager em = JPA.createEntityManager();
        {
            // Group
            CriteriaQuery criteria = cb.createQuery();
            Root<User> u = criteria.from(User.class);
            criteria.multiselect(u.get("lastname"), cb.count(u));
            criteria.groupBy(u.get("lastname"));
            Query q = em.createQuery(criteria);
            List<Object[]> result = q.getResultList();
            assertEquals(result.size(), 2);
            for (Object[] row : result) {
                assertTrue(row[0] instanceof String);
                assertTrue(row[1] instanceof Long);
            }
        }
        em.clear();
        {
            // Average
            CriteriaQuery criteria = cb.createQuery();
            Root<Bid> b = criteria.from(Bid.class);
            criteria.multiselect(b.get("item").get("name"), cb.avg(b.<BigDecimal>get("amount")));
            criteria.groupBy(b.get("item").get("name"));
            Query q = em.createQuery(criteria);
            List<Object[]> result = q.getResultList();
            assertEquals(result.size(), 2);
            for (Object[] row : result) {
                assertTrue(row[0] instanceof String);
                assertTrue(row[1] instanceof Double);
            }
        }
        em.clear();
        {
            // Average Workaround
            CriteriaQuery criteria = cb.createQuery();
            Root<Bid> b = criteria.from(Bid.class);
            Join<Bid, Item> i = b.join("item");
            criteria.multiselect(i, cb.avg(b.<BigDecimal>get("amount")));
            criteria.groupBy(i.get("id"), i.get("name"), i.get("createdOn"), i.get("auctionEnd"), i.get("auctionType"), i.get("approved"), i.get("buyNowPrice"), i.get("seller"));
            Query q = em.createQuery(criteria);
            List<Object[]> result = q.getResultList();
            assertEquals(result.size(), 2);
            for (Object[] row : result) {
                assertTrue(row[0] instanceof Item);
                assertTrue(row[1] instanceof Double);
            }
        }
        em.clear();
        {
            // Having
            CriteriaQuery criteria = cb.createQuery();
            Root<User> u = criteria.from(User.class);
            criteria.multiselect(u.get("lastname"), cb.count(u));
            criteria.groupBy(u.get("lastname"));
            criteria.having(cb.like(u.<String>get("lastname"), "D%"));
            Query q = em.createQuery(criteria);
            List<Object[]> result = q.getResultList();
            assertEquals(result.size(), 1);
            for (Object[] row : result) {
                assertTrue(row[0] instanceof String);
                assertTrue(row[1] instanceof Long);
            }
        }
        em.clear();
        tx.commit();
        em.close();
    } finally {
        TM.rollback();
    }
}