How to use multiple JOIN FETCH in one JPQL query
Here is a working example of complex join and multiple consition:
String query_findByProductDepartmentHospital = "select location from ProductInstallLocation location " + " join location.product prod " + " join location.department dep " + " join location.department.hospital hos " + " where prod.name = :product " + " and dep.name.name = :department " + " and hos.name = :hospital "; @Query(query_findByProductDepartmentHospital) ProductInstallLocation findByProductDepartmentHospital(@Param("product") String productName,@Param("department") String departName, @Param("hospital") String hospitalName);
Considering we have the following entities:
And, you want to fetch some parent
Post entities along with all the associated
If you are using more than one
JOIN FETCH directives:
List<Post> posts = entityManager.createQuery(""" select p from Post p left join fetch p.comments left join fetch p.tags where p.id between :minId and :maxId """, Post.class) .setParameter("minId", 1L) .setParameter("maxId", 50L) .getResultList();
Hibernate will throw the
org.hibernate.loader.MultipleBagFetchException: cannot simultaneously fetch multiple bags [ com.vladmihalcea.book.hpjp.hibernate.fetching.Post.comments, com.vladmihalcea.book.hpjp.hibernate.fetching.Post.tags ]
The reason why Hibernate throws this exception is that it does not allow fetching more than one bag because that would generate a Cartesian product.
The worst "solution" others might try to sell you
Now, you will find lots of answers, blog posts, videos, or other resources telling you to use a
Set instead of a
List for your collections.
That's terrible advice. Don't do that!
Sets instead of
Lists will make the
MultipleBagFetchException go away, but the Cartesian Product will still be there, which is actually even worse, as you'll find out the performance issue long after you applied this "fix".
The proper solution
You can do the following trick:
List<Post> posts = entityManager.createQuery(""" select distinct p from Post p left join fetch p.comments where p.id between :minId and :maxId """, Post.class) .setParameter("minId", 1L) .setParameter("maxId", 50L) .setHint(QueryHints.PASS_DISTINCT_THROUGH, false) .getResultList(); posts = entityManager.createQuery(""" select distinct p from Post p left join fetch p.tags t where p in :posts """, Post.class) .setParameter("posts", posts) .setHint(QueryHints.PASS_DISTINCT_THROUGH, false) .getResultList();
In the first JPQL query,
distinctDOES NOT go to the SQL statement. That's why we set the
PASS_DISTINCT_THROUGHJPA query hint to
DISTINCT has two meanings in JPQL, and here, we need it to deduplicate the Java object references returned by
getResultListon the Java side, not the SQL side.
As long as you fetch at most one collection using
JOIN FETCH, you will be fine.
By using multiple queries, you will avoid the Cartesian Product since any other collection but the first one is fetched using a secondary query.
Always avoid the
If you're using the
FetchType.EAGER strategy at mapping time for
@ManyToMany associations, then you could easily end up with a
You are better off switching from
Fetchype.LAZY since eager fetching is a terrible idea that can lead to critical application performance issues.
FetchType.EAGER and don't switch from
Set just because doing so will make Hibernate hide the
MultipleBagFetchException under the carpet. Fetch just one collection at a time, and you'll be fine.
As long as you do it with the same number of queries as you have collections to initialize, you are fine. Just don't initialize the collections in a loop, as that will trigger
N+1 query issues, which are also bad for performance.