The Hibernate doc make the following statement regarding join fetch in HQL queries:

Note that, in the current implementation, only one collection role may be fetched in a query (everything else would be non-performant).

Is this limitation still in Hibernate 3?

yes, still valid in H3

Are there any plans to solve that issue? Would it be difficult to do?

We probably will do it eventually.
As a workaround use the batch-size attribute.

or execute two queries, one per collection
(only usefull for two collections from the same root entity B*--A--*C)

Well, what I'll do in mean time is to iterate through the collections before returning them to the web layer. Needless to say that it will not perform.

If I would have a look at solving this, can you give me a hint of where to look?

Don't iterate. Take anthony's advice as that will be the most performant:

Just incase you don't follow. The above solution is preloading the session cache with the first query which is being access to (further) fillout the objects in the second query. I have used similar approaches for lookups etc when appropriate. Kinda neat really.

My situation is that I have A - C1 - C2, i.e. when loading A I want to load the corresponding entries in C1 and C2.

So are both C1 and C2 collection properties on A?

Thats called "in series", where A has a collection named Bs whose elements are of type B which then has a collection named Cs with elements of type C. Hibernate can handle fetching all this at once.

The other situation is called "in parallel", where A has two collections itself. This is where you'd need to perform the stuff suggested in these responses.

So which situation is it you have?

The exact situation is like this:

C1
|
B - A - C - C2
|
C3

B and C are properties of A. C1, C2 and C3 are propterties of C. B, C1 and C2 are collections, C3 is a single relation.

When I load A I want all the others to be loaded as well. So as I understand it, I should do like this:


s.createQuery("from A as a left join fetch a.b as b where a.id = :id").list();
s.createQuery("from A as a left join fetch a.c as c left join fetch c.c1 as c1 where a.id = :id").list();
List result = s.createQuery("from A as a left join fetch a.c as c left join fetch c.c2 as c2 left join fetch c.c3 as c3 where a.id = :id").list();

I fetch c2 and c3 in the same query since c3 is not a collection. Would this work?

I've tried two variants:

session.createQuery("select category from Category as category " +
"left join fetch category.parent as parent " +
"left join fetch category.sub " +
"where category.id = :categoryId")
.setLong("categoryId", id.longValue() ).list();

session.createQuery("select category from Category as category " +
"left join fetch category.content as content " +
"left join fetch content.filesets " +
"left join fetch content.price " +
"where category.id = :categoryId")
.setLong("categoryId", id.longValue()).list();

List result = session.createQuery("select category from Category as category " +
"left join fetch category.content as content " +
"left join fetch content.properties " +
"where category.id = :categoryId")
.setLong("categoryId", id.longValue() );

List result = query.list();
Category c = (Category) result.get(0);

category.parent and content.price are single relations, the rest are collections.

Then I tried a simpler variant where I only tried to fetch category.parent, category.sub and category.content.

session.createQuery("select category from Category as category " +
"left join fetch category.parent as parent " +
"left join fetch category.sub " +
"where category.id = :categoryId")
.setLong("categoryId", id.longValue() ).list();

List result = session.createQuery("select category from Category as category " +
"left join fetch category.content as content " +
"where category.id = :categoryId")
.setLong("categoryId", id.longValue()).list();

The result was the same in both cases, only category.parent and category.sub are fetched, category.content is not.

I see that formatting is not correct, I try again:

C1 --+
C2 - C - A - B
C3 --+

The relation multiciply is like this:

A - B 1-*
A - C *-*
C - C1 *-1
C - C2 1-*
C - C3 1-*

Headace generating...