Understanding JOINED Inheritance in Hibernate: How Base Entities Fetch Sub Entities

Explore how Hibernate's `JOINED` inheritance strategy allows querying base entities to return properties from sub entities like `CreditCard`.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: How is it possible that querying base entity in joined inheritance strategy also fetches sub entities?

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding JOINED Inheritance in Hibernate: How Base Entities Fetch Sub Entities

In enterprise applications that leverage object-relational mapping frameworks like Hibernate, inheritance mapping is a common pattern for organizing data models. One often-encountered scenario is the usage of JOINED inheritance strategy. This might lead to some confusion, especially when querying base entities and expecting to only retrieve base properties. So, how is it possible that querying a base entity in a joined inheritance strategy can also fetch sub entities? Let’s break it down step by step.

The Problem Scenario

Let's look at a simplified version of a data model that illustrates this point. Imagine you have:

An abstract base class called BillingDetails that contains common billing properties.

A subclass called CreditCard that extends BillingDetails with additional properties specific to credit cards.

Here’s the code structure for your classes:

[[See Video to Reveal this Text or Code Snippet]]

When you execute a query against the base entity like so:

[[See Video to Reveal this Text or Code Snippet]]

You observe the output that includes properties from the subclass CreditCard, even though your query is against the BillingDetails type, which only declares Id and Owner. This naturally leads to the question: How is this possible?

The Solution: Understanding Polymorphism

The key concept here is polymorphism. In Java and object-oriented programming in general, polymorphism allows objects to be accessed through references of their parent class, while still retaining the specific behaviors of the subclasses.

How Hibernate Implements Polymorphism

Querying the Base Class: When you query BillingDetails, Hibernate fetches details from both the base table (for BillingDetails) and the subclass table (for CreditCard). It performs a join between the tables behind the scenes.

Creating Subclass Instances: Even though the list you work with is typed as BillingDetails, Hibernate creates instances of the subclass (CreditCard in this case) based on the data retrieved from the database. Thus, you can access all properties, including those defined in the subclass.

Casting Back to Subclass: If you wish to work with subclass-specific properties, you can do so by explicitly casting the object:

[[See Video to Reveal this Text or Code Snippet]]

This will successfully print the properties unique to the CreditCard, proving that the object is indeed of type CreditCard.

Additional Verification

To further investigate, you could run the following code snippets:

[[See Video to Reveal this Text or Code Snippet]]

This will confirm that Hibernate is polymorphically treating the instances in your list as specific subclasses, such as CreditCard.

Conclusion

Understanding how Hibernate handles JOINED inheritance and polymorphism elucidates why querying a base entity can return properties of subclass entities. This behavior allows developers to take advantage of inheritance and encapsulation, leading to cleaner code and better data management strategies.

Now you can leverage this understanding in your projects, ensuring that your use of Hibernate’s inheritance strategies aligns with your data retrieval objectives!