Why @OneToOne is allowing duplicate associations?

Question

I have User and Address classes as follows:

class User
{
   ...
   ...
   @OneToOne( cascade=CascadeType.ALL)
   @JoinColumn(name="addr_id")
   private Address address;
}

class Address
{
   ...
   ...
   @OneToOne(mappedBy="address")
   private User user;
}

Here my assumption is with this domain model I can associate one address to only one user(user.addr_id should be unique).

But with this domain model, I am able to create multiple users and associate them to the same address.

User u1 = new User();
//set data
Address addr1 = new Address();
//set data
u1.setAddress(addr1);
...
session.save(u1); 

--> this is creating one address record with addr_id=1 and inserting one user record in user table with addr_id=1. Fine.

Again,

User u2 = new User();
//set data
Address addr1 = (Address) session.load(Address.class, 1);
//set data
u2.setAddress(addr1);
...
session.save(u2);

--> This is creating second user record and associating to existing address with addr_id=1, which is not desired.

I can use @OneToOne(..)@JoinColumn(name="addr_id", unique=true) to prevent this. But what will be the difference of using @OneToOne rather than @ManyToOne(.., unique=true).

@OneToOne itself should impose "unique=true" condition..right?

-Siva

Answer 1

@OneToOne is annotating the Java to express the idea of the relationship between the two classes. If this was a @OneToMany then we'd have a collection instead. So reading the annotations we understand the realtionships, and the JPA runtime also understands those.

The actual policing of the one-to-one is performed in the database - we need the schema to have the uniqueness constraints. The @JoinColumn expresses how that relationship is manifest in the DatabaseSchema.This can be useful if we are generating the schema.

However in many cases we use bottom-up tools to generate the Java from the schema. In this case there's no actual need for the Java annotations to reflect the database constraints, from a Java perspective we just see the relationship.

An intelligent compiler might warn us if the semantics of our @JoinColumn doesn't match the @oneToOne, but I'm not sure whether current implementations do that.

Answer 2

OneToOne is an annotation describing the object model. It says what the cardinality of the association is. unique="true" is an indication to the "model-to-ddl" tool that there should be a unique cosntraint on this column. You can use such a tool, but you're also free to create and maintain the database schema yourself.

Whatever you choose to do, the JPA engine doesn't make a query each time the OneToOne association is modified to check that the cardinality is respected. All it does is assuming that the code is correct, and the unique constraint in the database will make sure that the cardinality is respected.