Version 2.6.1

I can't figure out a way to use inner joins for my many-to-one mappings. Hibernate keeps generating outer joins. How can I make it do an inner join when using the session.load.

dino

Outer join is correct in this situation.
What are you trying to achieve?

It maybe correct but is inefficient since I KNOW my many-to-one always exists. A more efficient way is to use an inner join. Actually, if any of my many-to-one relationship is not null, one should always use an inner join for efficiency.

Dino

Nobody really understands what you are trying to do, please read the rules of this forum and fill out the question form.

See http://forum.hibernate.org/viewtopic.ph ... +manytoone

There is an example but no adequate response from the hibernate team.

Let me rephase the question: why can't I specify in the mapping file to use an inner join rather than an outer join?

Dino

[blockquote]When outer-join is set to true:
load(IncoiceItem.class,pk); produces 1 SQL Select with outer joins.

When outer-join is set to false:
load(IncoiceItem.class,pk); produces 3 SQL Selects

Thats the behaviour described in "Hibernate in action" Chapter 4 Page 14[/blockquote]

And if you set the associated entity to lazy="true" a single select statement will be executed. Those are perfectly valid options and I don't see what an inner join could improve.

Assuming that inner joins are universally more performent than an outer join when the appropriate relationship constraints and not null attributes are set then this could be a special optimisation. Four years completing a PhD leads me to always look for the proof-of-fact to support the assertion. It may turn out to be correct but I would think that the difference would be minimal thus not worth the added complexity in the sql generation phase. I might be wrong as a study might show its reasonably significant. Do you have a link to such a study or compelling discussion?

I don't have any links or documents or phd theories. I never use outer joins when it should be expressed as an inner join. However, they are different and I'm sure outer joins cannot be optimized as inner joins can be. But I don't time to find links/research to validate that so I have to be satisfied with your response. At least you recognise that you don't do it because it makes your life harder in the sql generation.

I lead a team of 12 developers and is one of the common questions that gets asked because no one writes outer joins when you don't need to.

Thanks for your responses.

Dino

Actually, it is straightforward to write



or even just




It doesn't make much sense to specify an inner join at the mapping file level, because it is possible that the mapping file fetch strategy could be used recursively, so you could get an inner join following an outer join (which is always wrong).

But, if you are following the best practices (make all associations lazy in the mapping file, and override in the query), then it is easy to get an inner join as above.


I think that fully answers your problem/question ;)

This is what I am doing in the end. I was hoping to avoid this since we were initially trying to avoid HSQL.


Dino

I think that your suggestion is not available in all situations. Imagine following mappings:

<class name="Card">
...
</class>

<class name="CardApplication">
...
<many-to-one name="card"/>
</class>

<class name="Device">
...
</class>

<class name="Transaction">
...
<many-to-one name="device"/>
<many-to-one name="cardApplication"/>
</class>

And I want to select from Transaction. I can write query:

from Transaction as t inner joinn fetch t.device inner join fetch t.cardApplication as ca inner join fetch ca.card

But when I have e.g. 10000 transactions and only 500 cardApplications, therefore it is not as efficient as could be, because there is huge redundancy in the retrieved data.

When I write query:

from Transaction as t inner joinn fetch t.device

The card transactions are retrieved with separate selects and the card is retrieved with outer join and I can't affect it to be used inner join, that is more efficent (nearly 5x in DB2 environment), because the query is automatically generated by Hibernate.

So how to solve this problem??

Thanks