Table Per Class Hierarchy | Inheritance Mapping

Introduction

In Hibernate, inheritance mapping is a method to map a class hierarchy to a database table structure. One of the strategies used for this purpose is the "Table Per Class Hierarchy" strategy. This approach allows us to store all classes in a hierarchy in a single table, which simplifies the schema but can complicate queries and lead to issues with data integrity.

What is Table Per Class Hierarchy?

The "Table Per Class Hierarchy" strategy involves creating a single table that contains all the fields from all classes in the hierarchy. The table will have a discriminator column that indicates the type of each row. This allows Hibernate to differentiate between the various subclasses when querying the data.

For example, if we have a class hierarchy with a superclass called Animal and subclasses Dog and Cat, all fields from these classes would be stored in a single Animal table.

Defining the Classes

To implement this strategy, we must annotate our classes appropriately. Below is an example of how to define the classes using Hibernate annotations.

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "animal_type")
public abstract class Animal {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getters and setters
}

@Entity
@DiscriminatorValue("Dog")
public class Dog extends Animal {
    private String breed;

    // Getters and setters
}

@Entity
@DiscriminatorValue("Cat")
public class Cat extends Animal {
    private String color;

    // Getters and setters
}

In this example, the Animal class is the base class, and the Dog and Cat classes are its subclasses. The @DiscriminatorColumn annotation specifies the column that will hold the type of the animal.

Database Table Structure

The database table created for this structure will look like the following:

+----+------+------------+-------+
| id | name | animal_type| breed | color |
+----+------+------------+-------+
| 1  | Rex  | Dog        | Labrador| NULL  |
| 2  | Whiskers | Cat   | NULL  | Black |
+----+------+------------+-------+

In this table, all properties from both Dog and Cat are stored. The breed column will be NULL for cats, and the color column will be NULL for dogs.

Benefits and Drawbacks

Benefits

- A single table simplifies the schema and can improve performance for certain types of queries.
- It is easier to manage a single table rather than multiple tables for each subclass.

Drawbacks

- The table can become very wide if there are many subclasses with a lot of properties, leading to wasted space.
- It can complicate queries, especially if you need to filter based on subclass-specific properties.

Conclusion

The "Table Per Class Hierarchy" strategy is a useful approach when modeling inheritance in Hibernate. While it has its benefits, such as simplicity and performance in certain contexts, it also has drawbacks that developers should consider. It is essential to evaluate your specific use case to determine whether this inheritance mapping strategy is appropriate for your application.

Table Per Class Hierarchy in Hibernate