MultipleBagFetchException: Complete Guide to Fix

The MultipleBagFetchException in Hibernate occurs when you attempt to fetch multiple @OneToMany or @ManyToMany collections simultaneously using FetchType.EAGER. The root cause is that Hibernate would generate a Cartesian Product in the SQL query, and since bags (Lists) don’t have inherent ordering, Hibernate cannot properly map which elements belong to which collection, leading to potential data corruption and severe performance issues.

Contents

• Understanding the Core Problem
• Why Cartesian Products Are Problematic
• Technical Implementation Details
• Common Scenarios That Trigger the Exception
• Prevention and Solutions

Understanding the Core Problem

The MultipleBagFetchException is thrown by Hibernate when you try to fetch multiple List collections at once on an entity. According to Baeldung, “Fetching two or more Bags at the same time on an Entity could form a Cartesian Product”. Since a Bag doesn’t have an order, Hibernate would not be able to map the right columns to the right entities.

In Hibernate, a “bag” refers to any collection that doesn’t define a unique constraint or ordering, which includes java.util.List and java.util.Collection. When you have multiple such associations on the same entity, Hibernate encounters a fundamental problem in how to associate the fetched data with the correct parent entity.

The Spring Cloud documentation explains that “By trying to fetch multiple one-to-many or many-to-many associations at once, a Cartesian Product is generated, and, even if Hibernate didn’t throw the MultipleBagFetchException, we would still want to avoid getting a Cartesian Product in our query result set.”

---

Why Cartesian Products Are Problematic

A Cartesian Product occurs when every record from one collection is combined with every record from another collection. This creates an exponential explosion of data that can severely impact performance.

As Vlad Mihalcea explains, “the MultipleBagFetchException tells you that a Cartesian Product might be generated, and, most of the time, that’s undesirable when fetching entities as it can lead to terrible data access performance issues.”

The performance impact is significant because:

• The number of rows returned grows exponentially with each additional collection
• Memory usage increases dramatically
• Network transfer becomes inefficient
• Database processing time increases substantially

For example, if you have a parent entity with two child collections containing 100 and 50 items respectively, a Cartesian Product would generate 100 × 50 = 5,000 rows instead of the expected 150 rows.

---

Technical Implementation Details

The SQL Generation Problem

When Hibernate processes query results, there’s no simple way to tell which child element belongs to which collection when you have multiple bags. As noted in a Stack Overflow discussion, “the root cause of the problem is that when Hibernate fetches SQL query results there is no simple way to tell which child element belongs to which collection”.

Hibernate’s Internal Processing

From the hibernate-tunings documentation, we understand that:

The JPA specification ensures that within each EntityManager/PersistenceContext, there is only 1 entity object that represents a specific record in the database. You can use that to resolve foreign key references efficiently or to let Hibernate…

When Hibernate tries to process multiple bags, it cannot reliably determine which child records belong to which parent entity because:

1. Bags lack ordering information
2. There’s no natural key to associate the data
3. The result set doesn’t contain sufficient metadata for proper mapping

The Role of DISTINCT

As mentioned in Stack Overflow, “That’s why we set the PASS_DISTINCT_THROUGH JPA query hint to false. DISTINCT has two meanings in JPQL, and here, we need it to deduplicate the Java object references returned by getResultList on the Java side, not the SQL side.”

This shows that Hibernate has sophisticated mechanisms to handle distinctness, but they break down when dealing with multiple bags.

---

Common Scenarios That Trigger the Exception

Multiple EAGER Associations

The most common scenario occurs when you have multiple @OneToMany or @ManyToMany associations with FetchType.EAGER on the same entity. As noted in Stack Overflow, “The problem is the Hibernate specification: he doesn’t allow more than one list noted with EAGER”.

EntityGraph Usage

When using EntityGraph to fetch multiple collections, you can encounter this issue. As mentioned in Stack Overflow, you can split your “UserWithItems” @NamedEntityGraph into two @NamedEntityGraphs, resulting in two queries.

Repository Methods Without @Transactional

As noted in the initial Stack Overflow response, “You should always have @Transactional on the service methods calling a Spring Data Jpa Repository. Not doing so is a terrible mistake.” This is important because without proper transaction management, Hibernate may attempt to fetch collections in ways that trigger the exception.

---

Prevention and Solutions

1. Use java.util.Set Instead of java.util.List

The easiest approach to fix the MultipleBagFetchException is to change the type of the attributes that map your to-many associations to a java.util.Set. As Thorben Janssen explains, “This is just a small change in your mapping, and you don’t need to change your business code.”

Sets have natural ordering constraints that allow Hibernate to properly map the data.

2. Use FetchType.LAZY

As suggested in Reddit, “This only happens if you’re eager loading child collections which Hibernate documentation explicitly says not to do. Just make the collections lazy and it will do 2 queries instead of 1, not a big deal.”

3. Use @Fetch with FetchMode.SUBSELECT

For associations that must be eagerly loaded, you can use the Hibernate-specific @Fetch(value = FetchMode.SUBSELECT) annotation. As mentioned in the initial Stack Overflow response, “@OneToMany(mappedBy=“parent”, fetch=FetchType.EAGER) @Fetch(value = FetchMode.SUBSELECT) private List childs; This should fix the issue, related to Hibernate bug HHH-1718”

4. Use @IndexColumn for Lists

If you must use Lists, you can add @IndexColumn to provide ordering semantics. As noted in Blog.eyallupu, “The usage of @IndexColumn helps solving the problem since now Hibernate has a List semantic for the association and when fetching the parent it also fetches the index of each element on the list.”

5. Split Queries

As suggested by W3Docs, “To fix this error, you will need to split the query into multiple queries, one for each collection. You can use the join fetch clause to fetch the collections in separate queries.”

Conclusion

The MultipleBagFetchException in Hibernate is a fundamental limitation that prevents potential data corruption and performance issues. Key takeaways include:

1. Root Cause: The exception occurs when Hibernate cannot properly map multiple bag collections due to the lack of inherent ordering, leading to potential Cartesian Product generation.

2. Performance Impact: Multiple eager loading of collections can cause exponential growth in result set size, severely impacting application performance.

3. Best Practices: Use java.util.Set instead of java.util.List for collections, prefer FetchType.LAZY for associations, and use Hibernate-specific annotations like @Fetch(FetchMode.SUBSELECT) when eager loading is necessary.

4. Transactional Management: Always use @Transactional annotations on service methods that call Spring Data JPA repositories to ensure proper Hibernate session management.

5. Alternative Approaches: Consider using EntityGraphs with separate graphs or splitting queries when you need to load multiple collections efficiently.

By understanding these principles, you can design your JPA entity mappings to avoid this common pitfall while maintaining optimal performance in your Spring Boot applications.

Sources

1. A Guide to MultipleBagFetchException in Hibernate | Baeldung
2. Hibernate throws MultipleBagFetchException - cannot simultaneously fetch multiple bags - Stack Overflow
3. Spring Data Jpa Multiplebagfetchexception - Spring Cloud
4. Spring Data JPA MultipleBagFetchException - Vlad Mihalcea
5. Your 2 best options to fix Hibernate’s MultipleBagFetchException - Thorben Janssen
6. The best way to fix the Hibernate MultipleBagFetchException - Vlad Mihalcea
7. Hibernate Tips: How to avoid Hibernate’s MultipleBagFetchException - Thorben Janssen
8. The best way to fix the infamous MultipleBagFetchException with Spring Data JPA - Reddit
9. Handling MultipleBagFetchException in Hibernate while using FetchType.EAGER - Medium
10. hibernate-tunings/docs/FixingMultipleBagFetchException.md at master · jlmc/hibernate-tunings