Hi.

We're trying to do something similar to the following:
Support you have a forum with: topic 1-* posts.

Is it possible to query for topic, and return only a few posts? (for example: everything after yesterday) ?

In HQL you'd do something like:
select t, p from topic as t join t.posts as p where p.date < :date

Now, this works ok. You basically get a collection of tuples. To make it easier to work with, you could create a Map<Topic, List<Post>> by iterating over the tuples.

However, we'd like to work with your domain model.
So instead of the previous query, I'd like to do something like:
select t from topic as t fetch filtered t.posts as p where p.date < :date
or
select t, p as t.posts from topic as t join fetch t.posts as p where p.date < :date

So that I get a list of topics with only a few posts.

The only problem I see here, is that a Topic with id 1, would give back a different set of posts depending on which way it was queried. (all posts vs posts after yesterday), which can be confusing.

I read about virtualization, but iic it only allows class-level filtering, enabled by the session (not a query specific thing).

So:
* What is the 'best' solution for this kind of problem / how would you solve this?
* Is something like this possible in hibernate3?
* What other disadvantages would there be?

Thanks

look at (dynamic) filter in the reference guide

The part about filters (section 18) is not what we want, because it narrows all queries executed by the session. How are modifications handled to collections when using filters?


I also found the following (section16.4)


This basically does the same as we already did.. (create a map.)

kick

Modifications to collections are always handled the same regardless of whether a filter is enabled/used or not. Not considering orphan deletes, such modifications come in two flavors:
1) a collection is "dereferenced" :

This causes Hibernate to "recreate" the collection (i.e. the original elements are deleted and any elements in the new collection reference are added).


2) elements are added or removed from a collection. Hibernate's Collection and Map impls keep track of the elements added and the elements removed, such that it can handle those individually at flush time.


Virtualization (aka filters) can be applied at either a class-level or collection-level.


BTW, the following HQ does essentially the same thing:

The where clause "filters" out the joined result set rows representing posts not meeting that criteria. Note, however, that this approach is questionable if you use second-level caching (then definitely use filters instead).