Couple of questions...

The authors don't explain satisfactorily why they use many-to-one on the User end when they have a 1->1 relationship b/w User and Address.

Secondly,

Are you saying that when you have an optional 1->1 relationship you should always use a jointable?

Where's the example that shows nullable foreign keys and why isn't that approach preferable?

JPA annotations are a lot easier to understand as it's @OneToOne on both sides.

Ok now I get it. one-to-one only applys to the shared primary key approach and that when you want to use the foreign key approach you have to use many-to-one. with a unique constraint.

let me just say that that's is quite confusing and that since the relationship is conceptually one-to-one it should be one-to-one regardless of how you choose to physically model it and add attributes to differentiate b/w shared primary key and foreign key approaches.

I should not have to use an identifer that suggests a completely different cardinality to what I'm modelling.

IMHO.

Maybe you should read the section again. Because it's a foreign key relationship, which is a bit different than the shared primary key value of the previous section. Why you should use that? Well, maybe because you have a legacy schema that already has it?



Always? No. But whenever you want to avoid a NULLable column.



Because NULLs are evil. Read up on why ternary logic in SQL is bad, we have plenty of references to more literature in the book.

You are more than welcome to submit a patch that changes the binding in Hibernate XML for this case from many-to-one unique=true to a one-to-one.

Well the rationale for using many-to-one becomes confusing when you consider that it's one-to-one on the target end if you make the relationship bidirectional. So you have a 1-1 relationship yet each end is different.

What is it then that stops <one-to-one on the target end from behaving the same way the shared primary key approach works? Presumably when it sees property-ref if then knows it's the back pointer and not a shared primary key?

Consider how elegant the JPA annotations are.. it's just @OneToOne on either end.

I know this isn't going to change any time soon I'm just surprised because to me it's non-intuitive.

Because the binder for Hibernate XML mapping files doesn't support foreign keys on <one-to-one>. Please submit a patch.