JPA Buddy
announcement - icon

JPA is huge! It covers nearly every aspect of communication between relational databases and the Java application and is deeply integrated into all major frameworks.

If you're using IntelliJ, JPA Buddy is super helpful. The plugin gently guides you through the subtleties of the most popular JPA implementations, visually reminds you of JPA features, generates code that follows best practices, and integrates intelligent inspections to improve your existing persistence code.

More concretely, it provides powerful tooling to generate Spring Data JPA repositories and methods, Flyway Versioned Migrations, Liquibase Differential Changelogs, DDL and SQL statements, DTO objects, and MapStruct interfaces.

Oh, and it actually generates JPA entities from an existing database and gradually update the data model as the database evolves! Yeah.

>> Become a lot more productive with JPA Buddy

Persistence top

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:

>> CHECK OUT THE COURSE
Authors Top

If you have a few years of experience in the Java ecosystem, and you’d like to share that with the community, have a look at our Contribution Guidelines.

1. Introduction

Inheritance is one of the key concepts in Java. So, it's no surprise that most domain models use it. But unfortunately, this concept doesn’t exist in relational databases, and you need to find a way to map the inheritance hierarchy to a relational table model.

JPA and Hibernate support different strategies, that map the inheritance hierarchy to various table models. Let's take a look at a chapter of my new book Hibernate Tips – More than 70 solutions to common Hibernate problems in which I explain the SingleTable strategy. It maps all classes of the inheritance hierarchy to the same database table.

I explain Hibernate's other inheritance mapping strategies in my Hibernate Tips book. It’s a cookbook with more than 70 ready-to-use recipes for topics like basic and advanced mappings, logging, Java 8 support, caching, and statically and dynamically defined queries.


2. Hibernate Tips – How to Map an Inheritance Hierarchy to One Table

2.1. Problem

My database contains one table, which I want to map to an inheritance hierarchy of entities. How do I define such a mapping?

2.2. Solution

JPA and Hibernate support different inheritance strategies which allow you to map the entities to different table structures. The SingleTable strategy is one of them and maps an inheritance hierarchy of entities to a single database table.

Let's have a look at the entity model before I explain the details of the SingleTable strategy. Authors can write different kinds of Publications, like Books and BlogPosts. The Publication class is the super class of the Book and BlogPost classes.

Inheritance Entity Model

The SingleTable strategy maps the three entities of the inheritance hierarchy to the publication table.

New-Inheritance Single Table

If you want to use this inheritance strategy, you need to annotate the superclass with an @Inheritance annotation and provide the InheritanceType.SINGLE_TABLE as the value of the strategy attribute.

You can also annotate the superclass with a @DiscriminatorColumn annotation to define the name of the discriminator value. Hibernate uses this value to determine the entity to which it has to map a database record. If you don't define a discriminator column, as I do in the following code snippet, Hibernate, and all other JPA implementations use the column DTYPE.

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public abstract class Publication {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id", updatable = false, nullable = false)
    private Long id;

    @Version
    private int version;

    private String title;

    private LocalDate publishingDate;
	
    @ManyToMany
    @JoinTable(
      name="PublicationAuthor",
      joinColumns={@JoinColumn(name="publicationId", referencedColumnName="id")},
      inverseJoinColumns={@JoinColumn(name="authorId", referencedColumnName="id")})
    private Set<Author> authors = new HashSet<Author>();

    ...
}

The subclasses need to extend the superclass, and you need to annotate them with a @Entity annotation.

The JPA specification also recommends to annotate it with a @DiscriminatorValue annotation to define the discriminator value for this entity class. If you don't provide this annotation, your JPA implementation generates a discriminator value.

But the JPA specification doesn't define how to generate the discriminator value, and your application might not be portable to other JPA implementations. Hibernate uses the simple entity name as the discriminator.

@Entity
@DiscriminatorValue("Book")
public class Book extends Publication {

    private int numPages;

    ...
}

The SingleTable strategy doesn't require Hibernate to generate any complex queries if you want to select a specific entity, perform a polymorphic query or traverse a polymorphic association.

Author a = em.find(Author.class, 1L);
List<Publication> publications = a.getPublications();

All entities are stored in the same table, and Hibernate can select them from there without an additional JOIN clause.

15:41:28,379 DEBUG [org.hibernate.SQL] - 
    select
        author0_.id as id1_0_0_,
        author0_.firstName as firstNam2_0_0_,
        author0_.lastName as lastName3_0_0_,
        author0_.version as version4_0_0_ 
    from
        Author author0_ 
    where
        author0_.id=?
15:41:28,384 DEBUG [org.hibernate.SQL] - 
    select
        publicatio0_.authorId as authorId2_2_0_,
        publicatio0_.publicationId as publicat1_2_0_,
        publicatio1_.id as id2_1_1_,
        publicatio1_.publishingDate as publishi3_1_1_,
        publicatio1_.title as title4_1_1_,
        publicatio1_.version as version5_1_1_,
        publicatio1_.numPages as numPages6_1_1_,
        publicatio1_.url as url7_1_1_,
        publicatio1_.DTYPE as DTYPE1_1_1_ 
    from
        PublicationAuthor publicatio0_ 
    inner join
        Publication publicatio1_ 
            on publicatio0_.publicationId=publicatio1_.id 
    where
        publicatio0_.authorId=?

2.3. Source Code

You can find a download link for a project with executable test cases for this Hibernate tip in the book.

2.4. Learn More

You can also map the entities of the inheritance hierarchy to multiple database tables.
I show you how to do that in the chapter How to map an inheritance hierarchy to multiple tables.

 

3. Summary

As you have seen in this Hibernate Tip, JPA and Hibernate provide an easy option to map an inheritance hierarchy to a single database table. You just have to annotate the superclass with @Inheritance(strategy = InheritanceType.SINGLE_TABLE) and you should also annotate the subclasses with @DiscriminatorValue(“Book”).

You can get more recipes like this in my new book Hibernate Tips: More than 70 solutions to common Hibernate problems. It gives you more than 70 ready-to-use recipes for topics like basic and advanced mappings, logging, Java 8 support, caching, and statically and dynamically defined queries. 

Persistence bottom
Get started with Spring Data JPA through the reference Learn Spring Data JPA course: >> CHECK OUT THE COURSE
Persistence footer banner
Comments are closed on this article!