Hi,
I use Hibernate 3.3.1.GA as JPA implementation and EJB3's EntityManager with extended persistence context.

Let's say I have entity A and entity B. Entity A has inside collection (OneToMany) of B entities.

And then, in one transaction I execute two HQL queries that return same entity A and this query makes inner join fetch to initialize collections of entities B.

This two HQL queries are different in WHERE clause:
in first I have WHERE B.property1 = 1
in second I have WHERE B.property2 = 1

The results should be the same entity A but the collections of entities B should be different (because of the WHERE clause).

But after the first HQL gets executed, entity A and collection are putted into PersistenceContext and the second HQL query returns same enitity A with same collection of entities B.

Is this correct behaviour? I understand that in the same transaction data should the same, but in this situations HQL queries are different so I expect that Hibernate will recognize this.

Could you please help me with the solutions (I know I can detach the entity but it's quite ugly).

Thanks in advanced
Rob

How dou you declare the OneToMany relation exactly?
Are you declaring EAGER fetch there?

No, it's declared as LAZY.

Then I cannot understand why your query implicitely makes inner join fetch to initialize collections of entities B.

Can you please post your code where you define and exectute both HQL queries.

Maybe I could explain it a little bit more on the simplified code. I would like not to put exact code here because it is company's code, so I changed the names a little bit.

Both queries as declared as namedQuery and entities are like this (assume that entity A means ServiceGroup and entity B means ServiceType):



Both queries are called from code like this which implements particular use case:




where em is of course EntityManager.
The parameterValue is the same for both queries (the same id of ServiceGroup entity). The difference in these both queries is condition: t.isStandard = 1 in first query and t.isExtended = 1 in second one.

The LAZY fetch type is set because in some other use cases there is no need to retrieve serviceTypeCollection.

I hope this helps. If I cut the code too much and more details are needed, let me know. Thanks

Hi usil,

The FETCH keyword in the FROM clause tells Hibernate that the relation collection should be eagerly fetched.
When executed, it returns a list of instances, with their collections full initialized.
The second query does not affect (reload) the collection anymore, because it is already marked initialized.

Solution:
Actually you are apparently more interested on the serviceTypes than the serviceGroup,
so I suggest to use following queries:



This will return you 2 distinct and correct result-sets of ServiceType's all belonging to the same serviceGroupId with id = :id