Query JPA Repository With Single Table Inheritance Subtypes

1. Overview

JPA is a useful tool when developing Java-based applications. We know about inheritance in Java, but when we have inheritance in JPA entities, JPA provides multiple strategies for handling inheritance. We can store the data either in a single table, in a join table, or in a table for each subclass entity.

In this tutorial, we’ll look at storing data of subtypes in a single table.

2. Single Table Inheritance SubTypes

In JPA, single table inheritance can be configured using the annotation @Inheritance(strategy = InheritanceType.SINGLE_TABLE). This means that a single table stores all entities in the inheritance hierarchy. The table has a discriminator column to distinguish between different entity types (subtypes). We can query specific subtypes using the JPA repository.

Let’s consider an inheritance hierarchy with Employee as a base class:

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

    // ...more fields, getter and setters
}

Next, let’s create subclasses PermanentEmployee and ContractEmployee that extend the Employee class:

@Entity
@DiscriminatorValue("PERM")
public class PermanentEmployee extends Employee {
    private int employeeId;
    
    // ...more fields, getter and setters
}

@Entity
@DiscriminatorValue("CNTR")
public class ContractEmployee extends Employee {
    private int contractPeriod;

    // ...more fields, getter and setters
}

The annotation @Inheritance defines inheritance in the base class Employee. The strategy attribute for the annotation is assigned to InheritanceType.SINGLE_TABLE. This assignment instructs Hibernate to store records for both PermanentEmployee and ContractEmployee subclasses in a single table.

Also, the annotation @DiscriminatorColumn defines a discriminator column for subclasses. The discriminator column is an identifier for the rows belonging to two different subclasses. The annotation @DiscriminatorColumn has an attribute name to set the discriminator column name.

In this example, we’ve set the discriminator column name to ‘type‘. As we use a single table to store records from multiple entity subclasses, this annotation helps us to identify to what subtype of main entity the record belongs.

In the given example, class Employee has a discriminator column named type.

The annotation @DiscrimnatorValue in subclasses or sub-types PermanentEmployee and ContractEmployee defines the value for the discriminator column for that particular subclass.

In the example, all records of the PermanentEmployee have value ‘PERM’ for the discriminator column type. For the ContractEmpoyee class, the value is ‘CNTR’.

3. Querying With JPA Respoistory

3.1. Repository Classes

Now, let’s create repository classes for the base class and the subclasses in the inheritance hierarchy. These classes enable us to query using the JPA Repository feature of Spring Data.

We simply need to extend the JpaRepository interface:

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
}

Extending the JpaRepository interface gives us basic queries like save, findAll, findById, delete, and many more.

Similarly, let’s create repository interfaces for the subclasses PermanentEmployee and ContractEmployee:

public interface PermanentEmployeeRepository extends JpaRepository<PermanentEmployee, Long> {
}

public interface ContractEmployeeRepository extends JpaRepository<ContractEmployee, Long> {
}

3.2. Persistence Configuration

Now, we need to declare the EnityManagerFactory bean in the configuration class PersistenceConfig and add a JPA vendor adapter for the Hibernate library:

@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
    LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
    em.setDataSource(dataSource());
    em.setPackagesToScan("com.baeldung.jpa.subtypes.entity");

    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    em.setJpaVendorAdapter(vendorAdapter);
    em.setJpaProperties(additionalProperties());
}

The LocalContainerEntityManagerFactoryBean is a Spring class that provides the FactoryBean for JPA’s EntityManagerFactory. It allows us to configure JPA provider, datasources, entity packages, and more.

3.3. Querying with JPA Repositories

To query data for the base class and subclasses, we autowire repository classes in the service class:

@Autowired
EmployeeRepository empRepository;

@Autowired
PermanentEmployeeRepository permEmpRepository;

@Autowired
ContractEmployeeRepository contrEmpRepository;

Let’s add some sample data to the subtypes:

PermanentEmployee perm1 = new PermanentEmployee(10, "John", 48);
permEmpRepository.save(perm1);

ContractEmployee contr1 = new ContractEmployee(180, "Mitchell", 23);
contrEmpRepository.save(contr1);

Now, based on single table configuration, PermanentEmployeeRepository, and ContractEmployeeRepository, insert the records in a single table Employee. Let’s see some sample data for the table Employee:

As we can see from the sample data from our database, the record for PermanentEmployee type does not have a value for the attribute that is specific to ContractEmployee and vice versa. The discriminator column TYPE identifies the subclass type for the record.

All records in the employee table can be retrieved using EmployeeRepository:

List<Employee> empList = empRepository.findAll()

We use permEmpRepository to get only PermanentEmployee from the employee table:

List<PermanentEmployee> perEmpList = permEmpRepository.findAll();

Similarly, contrEmpRepository to get only ContractEmployee from the employee table:

List<ContractEmployee> contrList = contrEmpRepository.findAll();

3.4. Using Custom Queries

We can query subclass data using custom JPA queries. Creating a filter query based on the discriminator column gives us data for the respective subclass:

@Query("SELECT e FROM Employee e WHERE type(e) = 'PERM' AND e.employeeId < :idlimit " 
  + "AND e.name LIKE :prefix% ")
List<PermanentEmployee> filterPermanent(@Param("idlimit") int idlimit, @Param("prefix") String prefix);

@Query("SELECT e FROM Employee e WHERE type(e) = 'CNTR' AND e.contractPeriod < :period " 
  + "AND e.name LIKE :prefix%  ")
List<ContractEmployee> filterContract(@Param("period") int period, @Param("prefix") String prefix);

In our example, the base class Employee is configured with discriminating column type. The same column is used to query data for specific subclasses.

Here, in the method filterPermanent(), using a custom query, we filter PermanentEmployee records having column type values ‘PERM ‘, employeeId less than the parameter idlimit, and name starting with the parameter prefix.

Similarly, in the method filterContract(), we filter ContractEmployee records based on columns type, contractPeriod, and name.

The custom query used in the base repository, EmployeeRepository, enables us to work with a single repository, handling records of all subtypes in a single table.

4. Conclusion

In this article, we learned about handling inheritance in JPA using a single table configuration for subtypes and querying the data using Spring Data JPA repositories. A single table stores the records of all subclasses in the inheritance, and the discriminator column differentiates the records for the subclasses.