Hibernate Inheritance Mapping Strategies

Java supports class inheritance, but relational tables don't have a native concept of "subclass." Hibernate offers three strategies for mapping a Java inheritance hierarchy onto tables, each with a different trade-off between query simplicity, storage normalization, and performance.

Table Per Hierarchy (Single Table)

The default strategy: one table holds every class in the hierarchy, with a discriminator column recording which subclass each row represents. It is the fastest option — reading or querying across the whole hierarchy never requires a join — but columns unique to a particular subclass must be nullable, since a row for one subclass leaves the other subclasses' columns empty.

Table Per Concrete Class

Each concrete subclass gets its own table containing all of its fields, including ones inherited from the parent — nothing is shared or joined. This avoids nullable columns entirely, but querying across the whole hierarchy (e.g. "all Payments regardless of subtype") requires a UNION across every subclass table, and there is no shared table to hold a truly common identity.

Table Per Subclass (Joined)

Each class — including the abstract parent — gets its own table holding only its own fields, linked to the parent's table by a shared primary key (a foreign key that is also the primary key). This is the most normalized option and avoids nullable columns, but reading a full subclass object requires a join across as many tables as there are levels in the hierarchy, which can be slower for deep hierarchies or wide queries across the whole tree.

Example

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "payment_type")
public abstract class Payment {
    @Id @GeneratedValue private long id;
    private double amount;
}

@Entity
@DiscriminatorValue("CREDIT_CARD")
public class CreditCardPayment extends Payment {
    private String cardNumber;
}

@Entity
@DiscriminatorValue("UPI")
public class UpiPayment extends Payment {
    private String upiId;
}

// Table Per Subclass instead, just change the strategy:
// @Inheritance(strategy = InheritanceType.JOINED)

// Table Per Concrete Class instead:
// @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)

Hibernate: create table payment (payment_type varchar(31) not null, id bigint not null, amount double, card_number varchar(255), upi_id varchar(255), primary key (id))

Exercise

Using the lesson's Table Per Hierarchy with a discriminator column example, create a small implementation or design sketch that demonstrates Table Per Hierarchy (SINGLE_TABLE): one table, fastest reads, nullable subclass-specific columns.. Add a test case or scenario that would catch Choosing Table Per Hierarchy for a hierarchy with many subclass-specific, mutually exclusive fields, resulting in a very wide table full of nulls., and describe the expected result.

Quick quiz

Interview questions