Table-Per-Class Hierarchy Mapping in hibernate

In our first mapping example, we’ll create a mapping document for the three classes that stores objects
of the hierarchy in a single table structure. The mapping is shown in Listing 5.20.
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping package="example.products">
<classname="CD"
table="cd"
discriminator-value="cd">
<id name="id"
type="integer"
unsaved-value="0">
<generator class="hilo"/>
</id>
<discriminator column="cd_type"
type= "string"/>
<property name="title"/>
<property name="artist"/>
<property name="purchasedate" type="date"/>
<property name="cost" type="double"/>
<subclass name="SpecialEditionCD"
discriminator-value="SpecialEditionCD">
<property name="newfeatures" type="string"/>
</subclass>
<subclass name="InternationalCD"
discriminator-value="InternationalCD">
<property name="languages"/>
<property name="region"/>
</subclass>
</class>
</hibernate-mapping>
Listing 5.20
The mapping in Listing 5.20 is more complex than the mappings you’ve seen so far. The first addition in
the mapping is the <discriminator> element. To understand how the mapping works, consider what
Hibernate will attempt to accomplish with the hierarchy objects: When the user instantiates and saves a
CD object, it’s saved to a table called CD with the appropriate attributes from the CD class mapped to the
database columns. When the user instantiates and saves a SpecialEditionCD object, it’s saved to the
same CD table as the CD object. The difference is that additional attributes are mapped from the
SpecialEditionCD. Those additional attributes are set to null for the CD object. To differentiate
between the three classes in the hierarchy, we add a discriminator column to the table and enter a spe-cific
value in the column for each object type.
The <discriminator> element includes two attributes in our example. The first attribute, column,
relates to the column in the database to be used for the discriminator value. The second attribute, type,
determines the column type.
In the <class> element, an element called <discriminator-value> relates to the value to be
placed in the discriminator column for an object instantiated from the CD class. Figure 5.1 shows all of
the rows in the cd table.
Figure 5.1
The database schema for this mapping is:
create table cd(
id int,
title text,
artist text,
purchasedate datetime,
cost double,
newfeatures text,
languages text,
region int,
cd_type text
);
Notice that the database schema consists of a single table and columns for all the possible attributes in
the base CD class as well as the child SpecialEditionCD and InternationalCD classes. By using the
table-per-class method, we need only one table for all object types in the mapped hierarchy.
Hibernate can do this by using the discriminator column, defined as cd_type in the schema, to hold a
string value indicating the class of object held in a particular row.
Here’s the code for an example use of the CD hierarchy. We used this code to produce the database rows
illustrated earlier:
import java.io.*;
import java.util.*;
import net. sf.hibernate.*;
import net. sf.hibernate.cfg.*;
import example.products.CD;
import example.products.SpecialEditionCD;
import example.products.InternationalCD;
public class CDTest {
public static void main(String [] args) {
try {
Session session = HibernateSession.currentSession();
CD cd = new CD("Grace Under Pressure", "Rush", new Date(), 9.99);
SpecialEditionCD secd = new SpecialEditionCD
("Grace Under Pressure", "Rush", new Date(), 9.99, "Widescreen");
InternationalCD icd = new InternationalCD
("Grace Under Pressure", "Rush", new Date(), 9.99, "Spanish", 4);
session.save(cd);
session.save(secd);
session.save(icd);
session.flush();
session.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
We create three different objects, one for each class type, and persist them to permanent storage.
Hibernate puts the appropriate column values in the rows, depending on the class type.