Hibernate throws MultipleBagFetchException - cannot simultaneously fetch multiple bags

java

hibernate-exception

fetch-strategy

lazy-loading

byNikita Barsukov·Sep 14, 2024

To **avoid** a MultipleBagFetchException, **switch from multiple EAGER `List` fetches to `Set`:**

// Change List to Set for EAGER fetching
@OneToMany(fetch = FetchType.EAGER)
private Set<Item> items = new HashSet<>();

Alternatively, fetch **just one `List` eagerly** and leave others to LAZY or batch fetch:

// Eagerly fetch only one collection
@OneToMany(fetch = FetchType.EAGER)
private List<Item> items = new ArrayList<>();

// Lazy fetch secondary collection, wisely avoid the exception
@OneToMany(fetch = FetchType.LAZY)
private List<AnotherItem> anotherItems = new ArrayList<>();

Use `@BatchSize` or initialize lazily fetched collections when needed:

// You want fries with that? Batch fetch collections!
@OneToMany
@BatchSize(size = 10)
private List<AnotherItem> anotherItems = new ArrayList<>();

// Initialize lazily fetched collection only when hungry enough to chew it
Hibernate.initialize(parent.getAnotherItems());

Unwrapping the Exception

Hibernate's MultipleBagFetchException is an unwelcome party crasher when you attempt simultaneous List fetches in a EAGER fashion. Hibernate interprets List instances as 'bags'. Like a real-life bag, these can contain duplicate items and maintain no specific order, much like my laundry bag!

Alternatives and Tactics

Embrace `Set` instead of `List`

// Use a Set to define collections, like a real champ
@OneToMany
private Set<AnotherItem> anotherItems = new HashSet<>();

A Set flips off MultipleBagFetchException. Still this is not a silver bullet. It bypasses the exception, but the potential performance hit remains lazily in the shadows.

Seek `@LazyCollection`'s help

By opting for @LazyCollection(LazyCollectionOption.FALSE), you can better orchestrate the fetch sequence, giving you a more elegant dance move than the basic FetchType.EAGER & FetchType.LAZY shuffle.

// Using LazyCollection, fetch all records when called, like a good dog
@OneToMany
@LazyCollection(LazyCollectionOption.FALSE)
private List<AnotherItem> anotherItems = new ArrayList<>();

Play the `@FetchMode.SUBSELECT` card

// Be James Bond and fetch in a subselect mode
@OneToMany
@Fetch(FetchMode.SUBSELECT)
private List<AnotherItem> anotherItems = new ArrayList<>();

This agent uses secondary selects - a blessing when FetchType.EAGER is your heart's secret desire.

Employ `distinct` power in JPQL

// Use distinct in JPQL to banish duplicate spectres
SELECT DISTINCT parent FROM Parent parent JOIN FETCH parent.items item

The power of distinct compels duplication to leave your JPQL, trimming redundant data and starving your Cartesian Products.

Beware: Possible Traps and Considerations

Not a fan of Cartesian Product

Avoid creating Cartesian Products! Selecting multiple collections with JOIN FETCH can spawn these monstrosities, bloating your data transfer and processing.

Outdated Hibernate version? Upgrade!

If you're still using last decade's Hibernate, maybe it's time for an upgrade. Latest versions offer better JPA 2.0 support like your favorite phone OS update, which could potentially solve your MultipleBagFetchException woes.

N+1 Query Issue Alert!

Watch out for sneaky N+1 queries. Fetching LAZY? Make sure their stealth maneuver doesn’t trigger superfluous queries when traversing collections in a loop.

Performance Testing Call

Don't be lazy! Conduct rigorous performance testing. FetchType.EAGER has a rapacious appetite for collections which can weigh heavily on your app's performance and end-user experience.

Boost your fetch strategy

Analysing the solver-board

Regularly monitor the SQL queries Hibernate generates to understand if N+1 query problem arises or if batching proves beneficial.

Interfaces are your friends

Design against interfaces, not implementations. It lets you swap the inner collection type without disrupting your public API, much like changing your socks!

// Code against the interface, not the implementation. Stylish, right?
@OneToMany
private Collection<AnotherItem> anotherItems;

Context Matters!

Remember, there is no one-size-fits-all solution. Your fetching strategy should align with your specific case and data access patterns. Understanding the context will lead to optimized decisions.

explain-codes / Java / Hibernate throws MultipleBagFetchException - cannot simultaneously fetch multiple bags

Linked

Default fetch type for one-to-one, many-to-one and one-to-many in Hibernate



Difference between FetchType LAZY and EAGER in Java Persistence API?



Why is a ConcurrentModificationException thrown and how to debug it



How do we count rows using older versions of Hibernate (~2009)?



Simple way to find if two different lists contain exactly the same elements?

