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

Example 1 with Join

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

the class SqmSubQuery method getCorrelatedJoins.

@Override
public Set<Join<?, ?>> getCorrelatedJoins() {
    final Set<Join<?, ?>> correlatedJoins = new HashSet<>();
    final SqmFromClause fromClause = getQuerySpec().getFromClause();
    if (fromClause == null) {
        return correlatedJoins;
    }
    for (SqmRoot<?> root : fromClause.getRoots()) {
        if (root instanceof SqmCorrelation<?, ?>) {
            for (SqmJoin<?, ?> sqmJoin : root.getSqmJoins()) {
                if (sqmJoin instanceof SqmCorrelation<?, ?> && sqmJoin instanceof Join<?, ?>) {
                    correlatedJoins.add((Join<?, ?>) sqmJoin);
                }
            }
        }
    }
    return correlatedJoins;
}

Example 2 with Join

use of jakarta.persistence.criteria.Join 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 Join

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

the class AbstractQueryCacheResultTransformerTest method testJoinWithFetchJoinWithAliasedJoinedAndOwnerProjectedList.

@Test
public void testJoinWithFetchJoinWithAliasedJoinedAndOwnerProjectedList(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);
            JpaRoot<Student> root = criteria.from(Student.class);
            final JpaSelection<Student> st = root.alias("s");
            root.fetch("enrolments", JoinType.LEFT);
            final Selection<Object> pc = root.join("preferredCourse", JoinType.LEFT).alias("pc");
            criteria.orderBy(builder.asc(root.get("studentNumber")));
            criteria.multiselect(pc, st);
            return criteria;
        }
    };
    HqlExecutor hqlSelectNewMapExecutor = new HqlExecutor() {

        @Override
        public Query getQuery(Session s) {
            return s.createQuery("select pc, s from Student s left join fetch s.enrolments left join s.preferredCourse pc order by s.studentNumber");
        }
    };
    ResultChecker checker = results -> {
        List resultList = (List) results;
        assertEquals(2, resultList.size());
        Object[] yogiObjects = (Object[]) resultList.get(0);
        assertEquals(yogiExpected, yogiObjects[1]);
        assertEquals(yogiExpected.getPreferredCourse().getCourseCode(), ((Course) yogiObjects[0]).getCourseCode());
        Object[] shermanObjects = (Object[]) resultList.get(1);
        assertEquals(shermanExpected, shermanObjects[1]);
        assertNull(shermanObjects[0]);
        if (areDynamicNonLazyAssociationsChecked()) {
            assertEquals(yogiExpected.getPreferredCourse(), yogiObjects[0]);
            assertTrue(Hibernate.isInitialized(((Student) yogiObjects[1]).getEnrolments()));
            assertEquals(yogiExpected.getEnrolments(), ((Student) yogiObjects[1]).getEnrolments());
            assertTrue(Hibernate.isInitialized(((Student) shermanObjects[1]).getEnrolments()));
            assertEquals(shermanExpected.getEnrolments(), (((Student) shermanObjects[1]).getEnrolments()));
        }
    };
    runTest(hqlSelectNewMapExecutor, criteriaExecutor, checker, false, scope);
}

Example 4 with Join

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

the class AbstractQueryCacheResultTransformerTest method testJoinWithFetchJoinWithOwnerAndPropProjectedList.

@Test
public void testJoinWithFetchJoinWithOwnerAndPropProjectedList(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);
            JpaRoot<Student> root = criteria.from(Student.class);
            root.fetch("enrolments", JoinType.LEFT);
            root.join("preferredCourse", JoinType.LEFT);
            criteria.orderBy(builder.asc(root.get("studentNumber")));
            criteria.multiselect(root, root.get("name"));
            return criteria;
        }
    };
    HqlExecutor hqlSelectNewMapExecutor = new HqlExecutor() {

        @Override
        public Query getQuery(Session s) {
            return s.createQuery("select s, s.name from Student s left join fetch s.enrolments left join s.preferredCourse order by s.studentNumber");
        }
    };
    ResultChecker checker = results -> {
        List resultList = (List) results;
        assertEquals(2, resultList.size());
        Object[] yogiObjects = (Object[]) resultList.get(0);
        assertEquals(yogiExpected, yogiObjects[0]);
        assertEquals(yogiExpected.getName(), yogiObjects[1]);
        Object[] shermanObjects = (Object[]) resultList.get(1);
        assertEquals(shermanExpected, shermanObjects[0]);
        assertEquals(shermanExpected.getName(), shermanObjects[1]);
        if (areDynamicNonLazyAssociationsChecked()) {
            assertTrue(Hibernate.isInitialized(((Student) yogiObjects[0]).getEnrolments()));
            assertEquals(yogiExpected.getEnrolments(), ((Student) yogiObjects[0]).getEnrolments());
            assertTrue(Hibernate.isInitialized(((Student) shermanObjects[0]).getEnrolments()));
            assertEquals(shermanExpected.getEnrolments(), (((Student) shermanObjects[0]).getEnrolments()));
        }
    };
    runTest(hqlSelectNewMapExecutor, criteriaExecutor, checker, false, scope);
}

Example 5 with Join

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

the class AbstractQueryCacheResultTransformerTest method testMultiSelectNewMapUsingAliasesWithFetchJoinList.

@Test
public void testMultiSelectNewMapUsingAliasesWithFetchJoinList(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(Map.class);
            Root<Student> root = criteria.from(Student.class);
            final Selection<Student> studentAlias = root.alias("s");
            final Selection<Object> pcAlias = root.join("preferredCourse", JoinType.LEFT).alias("pc");
            root.fetch("enrolments", JoinType.LEFT);
            criteria.multiselect(studentAlias, pcAlias);
            criteria.orderBy(builder.asc(root.get("studentNumber")));
            return criteria;
        // return s.createCriteria( Student.class, "s" )
        // .createAlias( "s.preferredCourse", "pc", Criteria.LEFT_JOIN  )
        // .setFetchMode( "enrolments", FetchMode.JOIN )
        // .addOrder( Order.asc( "s.studentNumber" ))
        // .setResultTransformer( Transformers.ALIAS_TO_ENTITY_MAP );
        }
    };
    HqlExecutor hqlSelectNewMapExecutor = new HqlExecutor() {

        @Override
        public Query getQuery(Session s) {
            return s.createQuery("select new map(s as s, pc as pc) from Student s left join s.preferredCourse pc left join fetch s.enrolments order by s.studentNumber");
        }
    };
    ResultChecker checker = results -> {
        List resultList = (List) results;
        assertEquals(2, resultList.size());
        Map yogiMap = (Map) resultList.get(0);
        assertEquals(yogiExpected, yogiMap.get("s"));
        assertEquals(yogiExpected.getPreferredCourse(), yogiMap.get("pc"));
        Map shermanMap = (Map) resultList.get(1);
        assertEquals(shermanExpected, shermanMap.get("s"));
        assertNull(shermanMap.get("pc"));
        if (areDynamicNonLazyAssociationsChecked()) {
            assertTrue(Hibernate.isInitialized(((Student) yogiMap.get("s")).getEnrolments()));
            assertEquals(yogiExpected.getEnrolments(), ((Student) yogiMap.get("s")).getEnrolments());
            assertTrue(Hibernate.isInitialized(((Student) shermanMap.get("s")).getEnrolments()));
            assertEquals(shermanExpected.getEnrolments(), (((Student) shermanMap.get("s")).getEnrolments()));
        }
    };
    runTest(hqlSelectNewMapExecutor, criteriaExecutor, checker, false, scope);
}