How to join two unrelated entities using JPA and Hibernate

Question

I have two tables - one containing Address and another containing Photographs. The only common field between them is the PersonID. These were mapped to two POJO Classes Add

Answer 1

Joining two unrelated entities are possible in Hibernate 5.1.

Eg :

select objA from ObjectA objA   
JOIN ObjectB objB on objB.variable = objA.variable    
where objA.id = 1

Answer 2

You can easily write HQL query that will return result as two objects using Theta Join (as Adrian noted). Here is an example:

String queryText = "select address, photo from Address address, Photo photo " 
                 + " where address.personID=photo.personId";
List<Object[]> rows = session.createQuery(queryText).list();

for (Object[] row: rows) {
    System.out.println(" ------- ");
    System.out.println("Address object: " + row[0]);
    System.out.println("Photo object: " + row[1]);
}

As you can see query returns list of Object[] arrays that represents each fetched row. First element of this array will contain one obejct and second element - another.

EDIT:

In case of left join I think you need to use native SQL query (not HQL query). Here how you can do this:

String queryText = "select address.*, photo.* from ADDRESS address 
                    left join PHOTO photo on (address.person_id=photo.person_id)";

List<Object[]> rows = sess.createSQLQuery(queryText)
                          .addEntity("address", Address.class)
                          .addEntity("photo", Photo.class)
                          .list();

This should work for your case.

Answer 3

It's best to have a class containing those classes you want to join to have them all together.

But if you are joining these tables just for some occasional purposes, you can use criteria and manually load data from each table and put them together. (and yes, you can have these tables' data separately if for Address and Photo there are two separate classes and tables)

Answer 4

As I explained in this article, you have two options:

1. Since Hibernate 5.1, you can use ad-hoc joins for unrelated entities.

   Tuple postViewCount = entityManager.createQuery(
       "select p as post, count(pv) as page_views " +
       "from Post p " +
       "left join PageView pv on p.slug = pv.slug " +
       "where p.title = :title " +
       "group by p", Tuple.class)
   .setParameter("title", "High-Performance Java Persistence")
   .getSingleResult();
   

2. Prior to Hibernate 5.1, you could only use theta-style joins. However, a theta-style join is equivalent to an equijoin, hence you can only emulate INNER JOINs not OUTER JOINs.

   List<Tuple> postViewCount = entityManager.createQuery(
       "select p as post, count(pv) as page_views " +
       "from Post p, PageView pv " +
       "where p.title = :title and " +
       "      ( p.slug = pv.slug ) " +
       "group by p", Tuple.class)
   .setParameter("title", "Presentations")
   .getResultList();
   

For more details, check out this article.

Answer 5

What you are looking for is

1. HQL
2. Join on fields that you haven't modeled as relationships
3. Left Join

(During the time the question was first asked and this answer was given) Hibernate supports Theta Join which allows you to do 1 & 2. However, only inner join is available for theta join style.

Personally I would recommend you to model proper relationships, so you just need 1 & 3 which is well-supported in HQL.

(Another answer actually provided an update on new Hibernate feature that provides such feature, that you may simply refer to)

Answer 6

Finally after 12 years the Hibernate team has implemented such a feature

From Hibernate docs:

The FROM clause can also contain explicit relationship joins using the join keyword. These joins can be either inner or left outer style joins.

List<Person> persons = entityManager.createQuery(
    "select distinct pr " +
    "from Person pr " +
    "join pr.phones ph " +
    "where ph.type = :phoneType", Person.class )
.setParameter( "phoneType", PhoneType.MOBILE )
.getResultList();


List<Person> persons = entityManager.createQuery(
    "select distinct pr " +
    "from Person pr " +
    "left join pr.phones ph " +
    "where ph is null " +
    "   or ph.type = :phoneType", Person.class )
.setParameter( "phoneType", PhoneType.LAND_LINE )
.getResultList();

Or you can use WITH and ON keywords. A remark on those

The important distinction is that in the generated SQL the conditions of the WITH/ON clause are made part of the ON clause in the generated SQL, as opposed to the other queries in this section where the HQL/JPQL conditions are made part of the WHERE clause in the generated SQL.

Example

List<Object[]> personsAndPhones = session.createQuery(
    "select pr.name, ph.number " +
    "from Person pr " +
    "left join pr.phones ph with ph.type = :phoneType " )
.setParameter( "phoneType", PhoneType.LAND_LINE )
.list();

I am currently eager to try the new feature.