Imagine having a tool that can automatically detect if you are using JPA and Hibernate properly. Hypersistence Optimizer is that tool!
While answering questions on the Hibernate forum, I stumbled on the following question about using the @ManyToOne annotation when the Foreign Key column on the client side references a non-Primary Key column on the parent side.
In this article, you are going to see how to use the @JoinColumn annotation in order to accommodate non-Primary Key many-to-one associations.
Assuming we have the following tables in our database:
The isbn column on the publication and book tables are linked via a Foreign Key constraint which is the base of our @ManyToOne assocation:
The Book represents the parent side of the association, and it’s mapped as follows:
@Entity(name = "Book")
@Table(name = "book")
public class Book
implements Serializable {
@Id
@GeneratedValue
private Long id;
private String title;
private String author;
@NaturalId
private String isbn;
//Getters and setters omitted for brevity
}
The isbn column is mapped as a @NaturalId since it can be used as a business key as well.
For more details about the
@NaturalIdannotation, check out this article.
The Publication represents the child of the association, so it’s going to be mapped like this:
@Entity(name = "Publication")
@Table(name = "publication")
public class Publication {
@Id
@GeneratedValue
private Long id;
private String publisher;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(
name = "isbn",
referencedColumnName = "isbn"
)
private Book book;
@Column(
name = "price_in_cents",
nullable = false
)
private Integer priceCents;
private String currency;
//Getters and setters omitted for brevity
}
By default, the @ManyToOne association assumes that the parent-side entity identifier is to be used to join with the client-side entity Foreign Key column.
However, when using a non-Primary Key association, the referencedColumnName should be used to instruct Hibernate which column should be used on the parent side to establish the many-to-one database relationship.
Assuming we have the following entities in our database:
Book book = new Book(); book.setTitle( "High-Performance Java Persistence" ); book.setAuthor( "Vlad Mihalcea" ); book.setIsbn( "978-9730228236" ); entityManager.persist(book); Publication amazonUs = new Publication(); amazonUs.setPublisher( "amazon.com" ); amazonUs.setBook( book ); amazonUs.setPriceCents( 4599 ); amazonUs.setCurrency( "$" ); entityManager.persist( amazonUs ); Publication amazonUk = new Publication(); amazonUk.setPublisher( "amazon.co.uk" ); amazonUk.setBook( book ); amazonUk.setPriceCents( 3545 ); amazonUk.setCurrency( "&" ); entityManager.persist( amazonUk );
Upon fetching the Publication along with its associated Book, we can see that the @ManyToOne association works as expected:
Publication publication = entityManager.createQuery(
"select p " +
"from Publication p " +
"join fetch p.book b " +
"where " +
" b.isbn = :isbn and " +
" p.currency = :currency", Publication.class)
.setParameter( "isbn", "978-9730228236" )
.setParameter( "currency", "&" )
.getSingleResult();
assertEquals(
"amazon.co.uk",
publication.getPublisher()
);
assertEquals(
"High-Performance Java Persistence",
publication.getBook().getTitle()
);
When executing the JPQL query above, Hibernate generates the following SQL statement:
SELECT
p.id AS id1_1_0_, b.id AS id1_0_1_,
p.isbn AS isbn5_1_0_, p.currency AS currency2_1_0_,
p.price_in_cents AS price_in3_1_0_,
p.publisher AS publishe4_1_0_,
b.author AS author2_0_1_, b.isbn AS isbn3_0_1_,
b.title AS title4_0_1_
FROM publication p
INNER JOIN
book b ON p.isbn = b.isbn
WHERE b.isbn = '978-9730228236'
AND p.currency = '&'
As you can see, the referencedColumnName allows you to customize the JOIN ON clause so that the isbn column is used instead of the default entity identifier.
If you enjoyed this article, I bet you are going to love my Book and Video Courses as well.
If you want to represent a non-Primary Key @ManyToOne association, you should use the referencedColumnName attribute of the @JoinColumn annotation.
For more complex situations, like when you need to use a custom SQL function in the JOIN ON clause, you can use the Hibernate specific @JoinFormula annotation.
FREE EBOOK
Why does Book Entity need Serializable implementation?
WIthout Serialization, it occurs an error..
It’s just a Hibernate limitation in this case. There’s a cast when hydrating the entity and that’s castes to Serializable.
Hi Vlad! Thanks for the article, I am facing a similar issue can you please guide what am I missing here.
I am using a non primary key as a foreign key and in @ManyToOne it fetches the parent entity even though I didn’t query it this is severely impacting my app performance.
I’ll explain with an example. Let’s assume I have an entity Property with the following design
public class Property extends AbstractEntity implements Serializable {
private static final long serialVersionUID = 8412320472079820864L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = “id”)
Long id;
@Column(name = “property_id”)
public Long propertyId;
@NotNull(message = “Name can’t be null”)
@Size(max = 100)
@Column(name = “name”)
@Translate
public String name;
}
Now i have rooms in my property which is represented by Room entity:
public class Room extends AbstractEntity implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = “id”)
Long id;
@Column(name = “name”)
private String name;
@ManyToOne(targetEntity = Property.class, fetch = FetchType.LAZY)
@JoinColumn(name = “property_id”, referencedColumnName = “property_id”, nullable = false)
private Property property;
}
Now when I fetch any room hibernate hits database for fetching Property entity too, even though I didn’t query it and fetched nothing from Property entity.
Thanks in advance
I don’t answer questions like that on blig comments. You should use the Hibernate forum or StackOverflow instead. However, I won’t have time for answering any question until I launch the Hypersistence Optimizer.