I'm using 3.5.1. Two persistent entities, parent and child, are in a one to one relationship:

In Parent, the reference to Child:


And in Child, the reference to Parent:


When I load a Parent entity via HQL, I see three SQL queries:
-one that corresponds to my HQL query
-one that loads Child
-one that loads Parent from the Child's perspective

I'm watching it in JProfiler and it's hurting our app performance significantly because Child contains LOBs that are rarely needed.

Anyone got an idea?

Thanks,

Jeff

I'll answer my own question:

For the example shown above, the 'child' or 'owned' class needs to be annotated with @Proxy(lazy=true) to get lazy loading. Other than that the example is correct.

If the OneToOne is optional there is no way to get lazy loading with Hibernate. It just can't be done, at least from what I've found. The relationship will always be eagerly loaded.

There's a good reason for this - if they proxied the child object and ran the lazy load on any method call everything would be find except if you ever did:
if (child == null)
you would get the wrong answer; it is never null because of the proxy.

This seems like a significant flaw in JPA (not really Hibernate; I assume other JPA implementations have the same problem, though I have to admit I'm not sure of this). It causes approx 10x slowdown in my app because there are lots of optional @ManyToOne and a few optional @OneToOne relationships.

For me there are still two important questions left:
If I select N parent entities...

1) High number of additional queries:
Why does Hibernate select the associated entities via N single additional select queries? The high number of additional query is the real performance problem for me, not the fetching itself. Why can't Hibernate select all N associated entities with a single additional query? (Or why is Hibernate unable to extend the primary query automatically by the join fetches necessary to load the associated entities within the first query?)

2) Lazy fetching using Byte Code Enhancement is not working either:
I'm using entities with property based access and annotations for lazy loading. To allow Hibernate to instrument my getters, I apply the build-time Hibernate byte code enhancement (org.hibernate.tool.instrument.javassist.InstrumentTask) on all of my entity classes. But also the classes get modified by the enhancement step, it does not change Hibernate's behavior on runtime. Hibernate still fetches all associated entities via N single select queries as before. Why does the Hibernate byte code enhancement not allow for lazy fetching of my 1to1 associations? Is this an additional limitation of the JPA interface? Am I using the wrong Hibernate byte code enhancement method? Is lazy loading of 1to1 associations using build-time enhanced entities working at all?