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

Example 1 with Root

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

the class SaveOrUpdateTest method getRowCount.

private Long getRowCount(Session s, Class clazz) {
    CriteriaBuilder criteriaBuilder = s.getCriteriaBuilder();
    CriteriaQuery<Long> criteria = criteriaBuilder.createQuery(Long.class);
    Root root = criteria.from(clazz);
    criteria.select(criteriaBuilder.count(root));
    return s.createQuery(criteria).uniqueResult();
}

Example 2 with Root

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

the class AbstractQueryCacheResultTransformerTest method testAliasToEntityMapNoProjectionNullAndNonNullAliasList.

@Test
public void testAliasToEntityMapNoProjectionNullAndNonNullAliasList(SessionFactoryScope scope) throws Exception {
    CriteriaExecutor criteriaExecutor = new CriteriaExecutor() {

        @Override
        protected JpaCriteriaQuery getCriteria(Session s) {
            final CriteriaBuilder builder = s.getSessionFactory().getCriteriaBuilder();
            final JpaCriteriaQuery<Student> criteria = (JpaCriteriaQuery<Student>) builder.createQuery(Student.class);
            final Root<Student> studentRoot = criteria.from(Student.class);
            studentRoot.alias("s");
            studentRoot.join("addresses", JoinType.LEFT).alias("a");
            studentRoot.join("preferredCourse", JoinType.INNER);
            criteria.orderBy(builder.asc(studentRoot.get("studentNumber")));
            return criteria;
        // return s.createCriteria( Student.class, "s" )
        // .createAlias( "s.addresses", "a", CriteriaSpecification.LEFT_JOIN )
        // .setResultTransformer( CriteriaSpecification.ALIAS_TO_ENTITY_MAP )
        // .createCriteria( "s.preferredCourse", CriteriaSpecification.INNER_JOIN )
        // .addOrder( Order.asc( "s.studentNumber") );
        }
    };
    HqlExecutor hqlExecutor = new HqlExecutor() {

        @Override
        public Query getQuery(Session s) {
            return s.createQuery("from Student s left join s.addresses a left join s.preferredCourse order by s.studentNumber").setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        }
    };
    ResultChecker checker = results -> {
        List resultList = (List) results;
        assertEquals(2, resultList.size());
        Map yogiMap1 = (Map) resultList.get(0);
        assertEquals(2, yogiMap1.size());
        Map yogiMap2 = (Map) resultList.get(1);
        assertEquals(2, yogiMap2.size());
        assertEquals(yogiExpected, yogiMap1.get("s"));
        Address yogiAddress1 = (Address) yogiMap1.get("a");
        assertEquals(yogiExpected.getAddresses().get(yogiAddress1.getAddressType()), yogiMap1.get("a"));
        assertEquals(yogiExpected, yogiMap2.get("s"));
        Address yogiAddress2 = (Address) yogiMap2.get("a");
        assertEquals(yogiExpected.getAddresses().get(yogiAddress2.getAddressType()), yogiMap2.get("a"));
        assertSame(yogiMap1.get("s"), yogiMap2.get("s"));
        assertNotEquals(yogiAddress1.getAddressType(), yogiAddress2.getAddressType());
    };
    runTest(hqlExecutor, criteriaExecutor, checker, false, scope);
}

Example 3 with Root

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

the class AbstractQueryCacheResultTransformerTest method testMultiAggregatedPropProjectionSingleResult.

@Test
public void testMultiAggregatedPropProjectionSingleResult(SessionFactoryScope scope) throws Exception {
    CriteriaExecutor criteriaExecutor = new CriteriaExecutor() {

        @Override
        protected ResultTransformer getResultTransformer() {
            return null;
        }

        @Override
        protected JpaCriteriaQuery getCriteria(Session s) {
            CriteriaBuilder builder = s.getCriteriaBuilder();
            JpaCriteriaQuery criteria = (JpaCriteriaQuery) builder.createQuery(Object[].class);
            Root<Enrolment> root = criteria.from(Enrolment.class);
            criteria.multiselect(builder.min(root.get("studentNumber")), builder.max(root.get("studentNumber")));
            return criteria;
        // return s.createCriteria( Enrolment.class )
        // .setProjection(
        // Projections.projectionList()
        // .add( Projections.min( "studentNumber" ).as( "minStudentNumber" ) )
        // .add( Projections.max( "studentNumber" ).as( "maxStudentNumber" ) )
        // );
        }
    };
    HqlExecutor hqlExecutor = new HqlExecutor() {

        @Override
        public Query getQuery(Session s) {
            return s.createQuery("select min( e.studentNumber ) as minStudentNumber, max( e.studentNumber ) as maxStudentNumber from Enrolment e");
        }
    };
    ResultChecker checker = results -> {
        assertTrue(results instanceof Object[]);
        Object[] resultObjects = (Object[]) results;
        assertEquals(yogiExpected.getStudentNumber(), resultObjects[0]);
        assertEquals(shermanExpected.getStudentNumber(), resultObjects[1]);
    };
    runTest(hqlExecutor, criteriaExecutor, checker, true, scope);
}

Example 4 with Root

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

the class AbstractQueryCacheResultTransformerTest method testOneEntityProjectionUnique.

@Test
public void testOneEntityProjectionUnique(SessionFactoryScope scope) throws Exception {
    CriteriaExecutor criteriaExecutor = new CriteriaExecutor() {

        @Override
        protected ResultTransformer getResultTransformer() {
            return null;
        }

        @Override
        protected JpaCriteriaQuery getCriteria(Session s) {
            CriteriaBuilder builder = s.getCriteriaBuilder();
            JpaCriteriaQuery criteria = (JpaCriteriaQuery) builder.createQuery();
            Root<Enrolment> root = criteria.from(Enrolment.class);
            criteria.select(root.get("student"));
            criteria.where(builder.equal(root.get("studentNumber"), yogiExpected.getStudentNumber()));
            return criteria;
        // should use PassThroughTransformer by default
        // return s.createCriteria( Enrolment.class )
        // .setProjection( Projections.property( "student" ) )
        // .add( Restrictions.eq( "studentNumber", Long.valueOf( yogiExpected.getStudentNumber() ) ) );
        }
    };
    HqlExecutor hqlExecutor = new HqlExecutor() {

        @Override
        public Query getQuery(Session s) {
            return s.createQuery("select e.student from Enrolment e where e.studentNumber = :studentNumber").setParameter("studentNumber", Long.valueOf(yogiExpected.getStudentNumber()));
        }
    };
    ResultChecker checker = results -> {
        assertTrue(results instanceof Student);
        Student student = (Student) results;
        // TODO: following is initialized for hql and uninitialied for criteria; why?
        // assertFalse( Hibernate.isInitialized( student ) );
        assertEquals(yogiExpected.getStudentNumber(), student.getStudentNumber());
    };
    runTest(hqlExecutor, criteriaExecutor, checker, true, scope);
}

Example 5 with Root

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

the class AbstractQueryCacheResultTransformerTest method testListElementsProjectionList.

@Test
public void testListElementsProjectionList(SessionFactoryScope scope) throws Exception {
    CriteriaExecutor criteriaExecutor = new CriteriaExecutor() {

        @Override
        protected ResultTransformer getResultTransformer() {
            return null;
        }

        @Override
        protected JpaCriteriaQuery getCriteria(Session s) {
            CriteriaBuilder builder = s.getCriteriaBuilder();
            JpaCriteriaQuery criteria = (JpaCriteriaQuery) builder.createQuery();
            Root<Enrolment> root = criteria.from(Student.class);
            final ListJoin<Object, Object> secretCodes = root.joinList("secretCodes");
            criteria.select(secretCodes);
            return criteria;
        }
    };
    HqlExecutor hqlExecutor = new HqlExecutor() {

        @Override
        public Query getQuery(Session s) {
            return s.createQuery("select elements(s.secretCodes) from Student s");
        }
    };
    ResultChecker checker = results -> {
        List resultList = (List) results;
        assertEquals(3, resultList.size());
        assertTrue(resultList.contains(yogiExpected.getSecretCodes().get(0)));
        assertTrue(resultList.contains(shermanExpected.getSecretCodes().get(0)));
        assertTrue(resultList.contains(shermanExpected.getSecretCodes().get(1)));
    };
    runTest(hqlExecutor, criteriaExecutor, checker, false, scope);
}