You can define a composite primary key through several syntaxes:

As you can see the last case is far from obvious. It has been inherited from the dark ages of EJB 2 for backward compatibilities and we recommend you not to use it (for simplicity sake).

Let's explore all three cases using examples.

@Entity

class User {

   @EmbeddedId

   @AttributeOverride(name="firstName", column=@Column(name="fld_firstname")

   UserId id;


   Integer age;

}


@Embeddable

class UserId implements Serializable {

   String firstName;

   String lastName;

}

@Entity

class Customer {

   @EmbeddedId CustomerId id;

   boolean preferredCustomer;


   @MapsId("userId")

   @JoinColumns({

      @JoinColumn(name="userfirstname_fk", referencedColumnName="firstName"),

      @JoinColumn(name="userlastname_fk", referencedColumnName="lastName")

   })

   @OneToOne User user;

}


@Embeddable

class CustomerId implements Serializable {

   UserId userId;

   String customerNumber;


   //implements equals and hashCode

}


@Entity 

class User {

   @EmbeddedId UserId id;

   Integer age;

}


@Embeddable

class UserId implements Serializable {

   String firstName;

   String lastName;


   //implements equals and hashCode

}

@Entity

class Customer {

   @EmbeddedId CustomerId id;

   boolean preferredCustomer;

}


@Embeddable

class CustomerId implements Serializable {

   @OneToOne

   @JoinColumns({

      @JoinColumn(name="userfirstname_fk", referencedColumnName="firstName"),

      @JoinColumn(name="userlastname_fk", referencedColumnName="lastName")

   }) 

   User user;

   String customerNumber;


   //implements equals and hashCode

}


@Entity 

class User {

   @EmbeddedId UserId id;

   Integer age;

}


@Embeddable

class UserId implements Serializable {

   String firstName;

   String lastName;



   //implements equals and hashCode

}

<composite-id

        name="propertyName"

        class="ClassName"

        mapped="true|false"

        access="field|property|ClassName"

        node="element-name|.">



        <key-property name="propertyName" type="typename" column="column_name"/>

        <key-many-to-one name="propertyName" class="ClassName" column="column_name"/>

        ......

</composite-id>

<class name="User">

   <composite-id name="id" class="UserId">

      <key-property name="firstName" column="fld_firstname"/>

      <key-property name="lastName"/>

   </composite-id>

</class>

<class name="Customer">

   <composite-id name="id" class="CustomerId">

      <key-property name="firstName" column="userfirstname_fk"/>

      <key-property name="lastName" column="userfirstname_fk"/>

      <key-property name="customerNumber"/>

   </composite-id>



   <property name="preferredCustomer"/>



   <many-to-one name="user">

      <column name="userfirstname_fk" updatable="false" insertable="false"/>

      <column name="userlastname_fk" updatable="false" insertable="false"/>

   </many-to-one>

</class>



<class name="User">

   <composite-id name="id" class="UserId">

      <key-property name="firstName"/>

      <key-property name="lastName"/>

   </composite-id>



   <property name="age"/>

</class>

<class name="Customer">

   <composite-id name="id" class="CustomerId">

      <key-many-to-one name="user">

         <column name="userfirstname_fk"/>

         <column name="userlastname_fk"/>

      </key-many-to-one>

      <key-property name="customerNumber"/>

   </composite-id>



   <property name="preferredCustomer"/>

</class>



<class name="User">

   <composite-id name="id" class="UserId">

      <key-property name="firstName"/>

      <key-property name="lastName"/>

   </composite-id>



   <property name="age"/>

</class>

@Entity

class Customer implements Serializable {

   @Id @OneToOne

   @JoinColumns({

      @JoinColumn(name="userfirstname_fk", referencedColumnName="firstName"),

      @JoinColumn(name="userlastname_fk", referencedColumnName="lastName")

   })

   User user;

  

   @Id String customerNumber;


   boolean preferredCustomer;


   //implements equals and hashCode

}


@Entity 

class User {

   @EmbeddedId UserId id;

   Integer age;

}


@Embeddable

class UserId implements Serializable {

   String firstName;

   String lastName;


   //implements equals and hashCode

}

<class name="Customer">

   <composite-id>

      <key-many-to-one name="user">

         <column name="userfirstname_fk"/>

         <column name="userlastname_fk"/>

      </key-many-to-one>

      <key-property name="customerNumber"/>

   </composite-id>



   <property name="preferredCustomer"/>

</class>



<class name="User">

   <composite-id name="id" class="UserId">

      <key-property name="firstName"/>

      <key-property name="lastName"/>

   </composite-id>



   <property name="age"/>

</class>

@Entity

@IdClass(CustomerId.class)

class Customer implements Serializable {

   @Id @OneToOne

   @JoinColumns({

      @JoinColumn(name="userfirstname_fk", referencedColumnName="firstName"),

      @JoinColumn(name="userlastname_fk", referencedColumnName="lastName")

   }) 

   User user;

  

   @Id String customerNumber;


   boolean preferredCustomer;

}


class CustomerId implements Serializable {

   UserId user;

   String customerNumber;


   //implements equals and hashCode

}


@Entity 

class User {

   @EmbeddedId UserId id;

   Integer age;


   //implements equals and hashCode

}


@Embeddable

class UserId implements Serializable {

   String firstName;

   String lastName;


   //implements equals and hashCode

}

@Entity

@IdClass(CustomerId.class)

class Customer implements Serializable {

   @Id @OneToOne

   @JoinColumns({

      @JoinColumn(name="userfirstname_fk", referencedColumnName="firstName"),

      @JoinColumn(name="userlastname_fk", referencedColumnName="lastName")

   }) 

   User user;

  

   @Id String customerNumber;


   boolean preferredCustomer;

}


class CustomerId implements Serializable {

   @OneToOne User user;

   String customerNumber;


   //implements equals and hashCode

}


@Entity 

class User {

   @EmbeddedId UserId id;

   Integer age;


   //implements equals and hashCode

}


@Embeddable

class UserId implements Serializable {

  String firstName;

  String lastName;

}

<class name="Customer">

   <composite-id class="CustomerId" mapped="true">

      <key-many-to-one name="user">

         <column name="userfirstname_fk"/>

         <column name="userlastname_fk"/>

      </key-many-to-one>

      <key-property name="customerNumber"/>

   </composite-id>



   <property name="preferredCustomer"/>

</class>



<class name="User">

   <composite-id name="id" class="UserId">

      <key-property name="firstName"/>

      <key-property name="lastName"/>

   </composite-id>



   <property name="age"/>

</class>

Hibernate can generate and populate identifier values for you automatically. This is the recommended approach over "business" or "natural" id (especially composite ids).

Hibernate offers various generation strategies, let's explore the most common ones first that happens to be standardized by JPA:

To mark an id property as generated, use the @GeneratedValue annotation. You can specify the strategy used (default to AUTO) by setting strategy.

@Entity

public class Customer {

   @Id @GeneratedValue

   Integer getId() { ... };

}


@Entity 

public class Invoice {

   @Id @GeneratedValue(strategy=GenerationType.IDENTITY)

   Integer getId() { ... };

}

SEQUENCE and TABLE require additional configurations that you can set using @SequenceGenerator and @TableGenerator:

In addition, the TABLE strategy also let you customize:

To link a table or sequence generator definition with an actual generated property, use the same name in both the definition name and the generator value generator as shown below.

@Id 

@GeneratedValue(

    strategy=GenerationType.SEQUENCE, 

    generator="SEQ_GEN")

@javax.persistence.SequenceGenerator(

    name="SEQ_GEN",

    sequenceName="my_sequence",

    allocationSize=20

)

public Integer getId() { ... }        

The scope of a generator definition can be the application or the class. Class-defined generators are not visible outside the class and can override application level generators. Application level generators are defined in JPA's XML deployment descriptors (see XXXXXX ???):

<table-generator name="EMP_GEN"

            table="GENERATOR_TABLE"

            pk-column-name="key"

            value-column-name="hi"

            pk-column-value="EMP"

            allocation-size="20"/>


//and the annotation equivalent


@javax.persistence.TableGenerator(

    name="EMP_GEN",

    table="GENERATOR_TABLE",

    pkColumnName = "key",

    valueColumnName = "hi"

    pkColumnValue="EMP",

    allocationSize=20

)


<sequence-generator name="SEQ_GEN" 

    sequence-name="my_sequence"

    allocation-size="20"/>


//and the annotation equivalent


@javax.persistence.SequenceGenerator(

    name="SEQ_GEN",

    sequenceName="my_sequence",

    allocationSize=20

)

         

If a JPA XML descriptor (like META-INF/orm.xml) is used to define the generators, EMP_GEN and SEQ_GEN are application level generators.

These are the four standard JPA generators. Hibernate goes beyond that and provide additional generators or additional options as we will see below. You can also write your own custom identifier generator by implementing org.hibernate.id.IdentifierGenerator.

To define a custom generator, use the @GenericGenerator annotation (and its plural counter part @GenericGenerators) that describes the class of the identifier generator or its short cut name (as described below) and a list of key/value parameters. When using @GenericGenerator and assigning it via @GeneratedValue.generator, the @GeneratedValue.strategy is ignored: leave it blank.

@Id @GeneratedValue(generator="system-uuid")

@GenericGenerator(name="system-uuid", strategy = "uuid")

public String getId() {


@Id @GeneratedValue(generator="trigger-generated")

@GenericGenerator(

    name="trigger-generated", 

    strategy = "select",

    parameters = @Parameter(name="key", value = "socialSecurityNumber")

)

public String getId() {

The hbm.xml approach uses the optional <generator> child element inside <id>. If any parameters are required to configure or initialize the generator instance, they are passed using the <param> element.

<id name="id" type="long" column="cat_id">

        <generator class="org.hibernate.id.TableHiLoGenerator">

                <param name="table">uid_table</param>

                <param name="column">next_hi_value_column</param>

        </generator>

</id>

<id name="id" type="long" column="cat_id">

        <generator class="hilo">

                <param name="table">hi_value</param>

                <param name="column">next_value</param>

                <param name="max_lo">100</param>

        </generator>

</id>

<id name="id" type="long" column="cat_id">

        <generator class="seqhilo">

                <param name="sequence">hi_value</param>

                <param name="max_lo">100</param>

        </generator>

</id>

<id name="id" type="long" column="person_id">

        <generator class="sequence">

                <param name="sequence">person_id_sequence</param>

        </generator>

</id>

<id name="id" type="long" column="person_id" unsaved-value="0">

        <generator class="identity"/>

</id>

<id name="id" type="long" column="person_id">

        <generator class="select">

                <param name="key">socialSecurityNumber</param>

        </generator>

</id>

@Entity

class MedicalHistory implements Serializable {

  @Id @OneToOne

  @JoinColumn(name = "person_id")

  Person patient;

}


@Entity

public class Person implements Serializable {

  @Id @GeneratedValue Integer id;

}

@Entity

class MedicalHistory implements Serializable {

  @Id Integer id;


  @MapsId @OneToOne

  @JoinColumn(name = "patient_id")

  Person patient;

}


@Entity

class Person {

  @Id @GeneratedValue Integer id;

}

<class name="MedicalHistory">

   <id name="id">

      <generator class="foreign">

         <param name="property">patient</param>

      </generator>

   </id>

   <one-to-one name="patient" class="Person" constrained="true"/>

</class>

Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization Optimization means that you do not have to query the database for every request for a new identifier value. These two new generators are intended to take the place of some of the named generators described above, starting in 3.3.x. However, they are included in the current releases and can be referenced by FQN.

The first of these new generators is org.hibernate.id.enhanced.SequenceStyleGenerator which is intended, firstly, as a replacement for the sequence generator and, secondly, as a better portability generator than native. This is because native generally chooses between identity and sequence which have largely different semantics that can cause subtle issues in applications eyeing portability. org.hibernate.id.enhanced.SequenceStyleGenerator, however, achieves portability in a different manner. It chooses between a table or a sequence in the database to store its incrementing values, depending on the capabilities of the dialect being used. The difference between this and native is that table-based and sequence-based storage have the same exact semantic. In fact, sequences are exactly what Hibernate tries to emulate with its table-based generators. This generator has a number of configuration parameters:

The second of these new generators is org.hibernate.id.enhanced.TableGenerator, which is intended, firstly, as a replacement for the table generator, even though it actually functions much more like org.hibernate.id.MultipleHiLoPerTableGenerator, and secondly, as a re-implementation of org.hibernate.id.MultipleHiLoPerTableGenerator that utilizes the notion of pluggable optimizers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters:

Hibernate supports the automatic generation of some of the identifier properties. Simply use the @GeneratedValue annotation on one or several id properties.

@Entity

public class CustomerInventory implements Serializable {

  @Id

  @TableGenerator(name = "inventory",

    table = "U_SEQUENCES",

    pkColumnName = "S_ID",

    valueColumnName = "S_NEXTNUM",

    pkColumnValue = "inventory",

    allocationSize = 1000)

  @GeneratedValue(strategy = GenerationType.TABLE, generator = "inventory")

  Integer id;



  @Id @ManyToOne(cascade = CascadeType.MERGE)

  Customer customer;

}


@Entity

public class Customer implements Serializable {

   @Id

   private int id;

}

You can also generate properties inside an @EmbeddedId class.

You can add optimistic locking capability to an entity using the @Version annotation:

@Entity

public class Flight implements Serializable {

...

    @Version

    @Column(name="OPTLOCK")

    public Integer getVersion() { ... }

}           

The version property will be mapped to the OPTLOCK column, and the entity manager will use it to detect conflicting updates (preventing lost updates you might otherwise see with the last-commit-wins strategy).

The version column may be a numeric. Hibernate supports any kind of type provided that you define and implement the appropriate UserVersionType.

The application must not alter the version number set up by Hibernate in any way. To artificially increase the version number, check in Hibernate Entity Manager's reference documentation LockModeType.OPTIMISTIC_FORCE_INCREMENT or LockModeType.PESSIMISTIC_FORCE_INCREMENT.

If the version number is generated by the database (via a trigger for example), make sure to use @org.hibernate.annotations.Generated(GenerationTime.ALWAYS).

To declare a version property in hbm.xml, use:

<version
        column="version_column"
        name="propertyName"
        type="typename"
        access="field|property|ClassName"
        unsaved-value="null|negative|undefined"
        generated="never|always"
        insert="true|false"
        node="element-name|@attribute-name|element/@attribute|."
/>

Alternatively, you can use a timestamp. Timestamps are a less safe implementation of optimistic locking. However, sometimes an application might use the timestamps in other ways as well.

Simply mark a property of type Date or Calendar as @Version.

@Entity

public class Flight implements Serializable {

...

    @Version

    public Date getLastUpdate() { ... }

}           

When using timestamp versioning you can tell Hibernate where to retrieve the timestamp value from - database or JVM - by optionally adding the @org.hibernate.annotations.Source annotation to the property. Possible values for the value attribute of the annotation are org.hibernate.annotations.SourceType.VM and org.hibernate.annotations.SourceType.DB. The default is SourceType.DB which is also used in case there is no @Source annotation at all.

Like in the case of version numbers, the timestamp can also be generated by the database instead of Hibernate. To do that, use @org.hibernate.annotations.Generated(GenerationTime.ALWAYS).

In hbm.xml, use the <timestamp> element:

<timestamp
        column="timestamp_column"
        name="propertyName"
        access="field|property|ClassName"
        unsaved-value="null|undefined"
        source="vm|db"
        generated="never|always"
        node="element-name|@attribute-name|element/@attribute|."
/>

In the annotations world, every non static non transient property (field or method depending on the access type) of an entity is considered persistent, unless you annotate it as @Transient. Not having an annotation for your property is equivalent to the appropriate @Basic annotation.

The @Basic annotation allows you to declare the fetching strategy for a property. If set to LAZY, specifies that this property should be fetched lazily when the instance variable is first accessed. It requires build-time bytecode instrumentation, if your classes are not instrumented, property level lazy loading is silently ignored. The default is EAGER. You can also mark a property as not optional thanks to the @Basic.optional attribute. This will ensure that the underlying column are not nullable (if possible). Note that a better approach is to use the @NotNull annotation of the Bean Validation specification.

Let's look at a few examples:

public transient int counter; //transient property


private String firstname; //persistent property


@Transient

String getLengthInMeter() { ... } //transient property


String getName() {... } // persistent property


@Basic

int getLength() { ... } // persistent property


@Basic(fetch = FetchType.LAZY)

String getDetailedComment() { ... } // persistent property


@Temporal(TemporalType.TIME)

java.util.Date getDepartureTime() { ... } // persistent property           


@Enumerated(EnumType.STRING)

Starred getNote() { ... } //enum persisted as String in database

counter, a transient field, and lengthInMeter, a method annotated as @Transient, and will be ignored by the Hibernate. name, length, and firstname properties are mapped persistent and eagerly fetched (the default for simple properties). The detailedComment property value will be lazily fetched from the database once a lazy property of the entity is accessed for the first time. Usually you don't need to lazy simple properties (not to be confused with lazy association fetching). The recommended alternative is to use the projection capability of JP-QL (Java Persistence Query Language) or Criteria queries.

JPA support property mapping of all basic types supported by Hibernate (all basic Java types , their respective wrappers and serializable classes). Hibernate Annotations supports out of the box enum type mapping either into a ordinal column (saving the enum ordinal) or a string based column (saving the enum string representation): the persistence representation, defaulted to ordinal, can be overridden through the @Enumerated annotation as shown in the note property example.

In plain Java APIs, the temporal precision of time is not defined. When dealing with temporal data you might want to describe the expected precision in database. Temporal data can have DATE, TIME, or TIMESTAMP precision (ie the actual date, only the time, or both). Use the @Temporal annotation to fine tune that.

@Lob indicates that the property should be persisted in a Blob or a Clob depending on the property type: java.sql.Clob, Character[], char[] and java.lang.String will be persisted in a Clob. java.sql.Blob, Byte[], byte[] and Serializable type will be persisted in a Blob.

@Lob

public String getFullText() {

    return fullText;

}


@Lob

public byte[] getFullCode() {

    return fullCode;

}

If the property type implements java.io.Serializable and is not a basic type, and if the property is not annotated with @Lob, then the Hibernate serializable type is used.

@TypeDef(

   name = "phoneNumber",

   defaultForType = PhoneNumber.class,

   typeClass = PhoneNumberType.class

)


@Entity

public class ContactDetails {

   [...]

   private PhoneNumber localPhoneNumber;

   @Type(type="phoneNumber")

   private OverseasPhoneNumber overseasPhoneNumber;

   [...]

}

//in org/hibernate/test/annotations/entity/package-info.java

@TypeDefs(

    {

    @TypeDef(

        name="caster",

        typeClass = CasterStringType.class,

        parameters = {

            @Parameter(name="cast", value="lower")

        }

    )

    }

)

package org.hibernate.test.annotations.entity;


//in org/hibernate/test/annotations/entity/Forest.java

public class Forest {

    @Type(type="caster")

    public String getSmallText() {

    ...

}      

@Type(type="org.hibernate.test.annotations.entity.MonetaryAmountUserType")

@Columns(columns = {

    @Column(name="r_amount"),

    @Column(name="r_currency")

})

public MonetaryAmount getAmount() {

    return amount;

}



public class MonetaryAmount implements Serializable {

    private BigDecimal amount;

    private Currency currency;

    ...

}

@Entity

public class Order {

   @Id private Long id;

   public Long getId() { return id; }

   public void setId(Long id) { this.id = id; }


   @Embedded private Address address;

   public Address getAddress() { return address; }

   public void setAddress() { this.address = address; }

}


@Entity

public class User {

   private Long id;

   @Id public Long getId() { return id; }

   public void setId(Long id) { this.id = id; }


   private Address address;

   @Embedded public Address getAddress() { return address; }

   public void setAddress() { this.address = address; }

}


@Embeddable

@Access(AcessType.PROPERTY)

public class Address {

   private String street1;

   public String getStreet1() { return street1; }

   public void setStreet1() { this.street1 = street1; }


   private hashCode; //not persistent

}

@Entity

public class Order {

   @Id private Long id;

   public Long getId() { return id; }

   public void setId(Long id) { this.id = id; }

   @Transient private String userId;

   @Transient private String orderId;


   @Access(AccessType.PROPERTY)

   public String getOrderNumber() { return userId + ":" + orderId; }

   public void setOrderNumber() { this.userId = ...; this.orderId = ...; }

}

@Entity

public class Flight implements Serializable {

...

@Column(updatable = false, name = "flight_name", nullable = false, length=50)

public String getName() { ... }

            

@Column(
    name="columnName";
    boolean unique() default false;
    boolean nullable() default true;
    boolean insertable() default true;
    boolean updatable() default true;
    String columnDefinition() default "";
    String table() default "";
    int length() default 255;
    int precision() default 0; // decimal precision
    int scale() default 0; // decimal scale

@Formula("obj_length * obj_height * obj_width")

public long getObjectVolume()

<property> 要素は、クラスの永続的な JavaBean スタイルのプロパティを定義します。

<property
        name="propertyName"
        column="column_name"
        type="typename"
        update="true|false"
        insert="true|false"
        formula="arbitrary SQL expression"
        access="field|property|ClassName"
        lazy="true|false"
        unique="true|false"
        not-null="true|false"
        optimistic-lock="true|false"
        generated="never|insert|always"
        node="element-name|@attribute-name|element/@attribute|."
        index="index_name"
        unique_key="unique_key_id"
        length="L"
        precision="P"
        scale="S"
/>

typename には以下の値が可能です：

型を指定しなければ、 Hibernate は正しい Hibernate の型を推測するために、指定されたプロパティに対してリフレクションを使います。 Hibernate はルール2, 3, 4をその順序に使い、 getter プロパティの返り値のクラスの名前を解釈しようとします。しかしこれで常に十分であるとは限りません。場合によっては、 type 属性が必要な場合があります。 （例えば Hibernate.DATE と Hibernate.TIMESTAMP を区別するため、またはカスタム型を指定するためなどです。）

access 属性で、実行時に Hibernate がどのようにプロパティにアクセスするかを制御できます。デフォルトでは Hibernate はプロパティの get/set のペアをコールします。 access="field" と指定すれば、 Hibernate はリフレクションを使い get/set のペアを介さずに、直接フィールドにアクセスします。インターフェース org.hibernate.property.PropertyAccessor を実装するクラスを指定することで、プロパティへのアクセスに独自の戦略を指定することができます。

特に強力な特徴は生成プロパティです。これらのプロパティは当然読み取り専用であり、プロパティの値はロード時に計算されます。計算を SQL 式として宣言すると、このプロパティはインスタンスをロードする SQL クエリの SELECT 句のサブクエリに変換されます:

<property name="totalPrice"

    formula="( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p

                WHERE li.productId = p.productId

                AND li.customerId = customerId

                AND li.orderNumber = orderNumber )"/>

特定のカラム(例では customerId がそれにあたります)のエイリアスを宣言することなく、エンティティ自身のテーブルを参照できることに注意してください。もし属性を使用したくなければ、ネストした <formula> マッピング要素を使えることにも注意してください。

With this approach the properties of all the subclasses in a given mapped class hierarchy are stored in a single table.

Each subclass declares its own persistent properties and subclasses. Version and id properties are assumed to be inherited from the root class. Each subclass in a hierarchy must define a unique discriminator value. If this is not specified, the fully qualified Java class name is used.

@Entity

@Inheritance(strategy=InheritanceType.SINGLE_TABLE)

@DiscriminatorColumn(

    name="planetype",

    discriminatorType=DiscriminatorType.STRING

)

@DiscriminatorValue("Plane")

public class Plane { ... }


@Entity

@DiscriminatorValue("A320")

public class A320 extends Plane { ... }          

In hbm.xml, for the table-per-class-hierarchy mapping strategy, the <subclass> declaration is used. For example:

<subclass
        name="ClassName"
        discriminator-value="discriminator_value"
        proxy="ProxyInterface"
        lazy="true|false"
        dynamic-update="true|false"
        dynamic-insert="true|false"
        entity-name="EntityName"
        node="element-name"
        extends="SuperclassName">

        <property .... />
        .....
</subclass>

For information about inheritance mappings see 10章継承マッピング.

@Entity

@Inheritance(strategy=InheritanceType.SINGLE_TABLE)

@DiscriminatorColumn(

    name="planetype",

    discriminatorType=DiscriminatorType.STRING

)

@DiscriminatorValue("Plane")

public class Plane { ... }


@Entity

@DiscriminatorValue("A320")

public class A320 extends Plane { ... }          

<discriminator
        column="discriminator_column"
        type="discriminator_type"
        force="true|false"
        insert="true|false"
        formula="arbitrary sql expression"
/>

<discriminator

    formula="case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end"

    type="integer"/>

Each subclass can also be mapped to its own table. This is called the table-per-subclass mapping strategy. An inherited state is retrieved by joining with the table of the superclass. A discriminator column is not required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier. The primary key of this table is also a foreign key to the superclass table and described by the @PrimaryKeyJoinColumns or the <key> element.

@Entity @Table(name="CATS")

@Inheritance(strategy=InheritanceType.JOINED)

public class Cat implements Serializable { 

    @Id @GeneratedValue(generator="cat-uuid") 

    @GenericGenerator(name="cat-uuid", strategy="uuid")

    String getId() { return id; }


    ...

}


@Entity @Table(name="DOMESTIC_CATS")

@PrimaryKeyJoinColumn(name="CAT")

public class DomesticCat extends Cat { 

    public String getName() { return name; }

}            

In hbm.xml, use the <joined-subclass> element. For example:

<joined-subclass
        name="ClassName"
        table="tablename"
        proxy="ProxyInterface"
        lazy="true|false"
        dynamic-update="true|false"
        dynamic-insert="true|false"
        schema="schema"
        catalog="catalog"
        extends="SuperclassName"
        persister="ClassName"
        subselect="SQL expression"
        entity-name="EntityName"
        node="element-name">

        <key .... >

        <property .... />
        .....
</joined-subclass>

Use the <key> element to declare the primary key / foreign key column. The mapping at the start of the chapter would then be re-written as:

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

        "-//Hibernate/Hibernate Mapping DTD//EN"

        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">



<hibernate-mapping package="eg">



        <class name="Cat" table="CATS">

                <id name="id" column="uid" type="long">

                        <generator class="hilo"/>

                </id>

                <property name="birthdate" type="date"/>

                <property name="color" not-null="true"/>

                <property name="sex" not-null="true"/>

                <property name="weight"/>

                <many-to-one name="mate"/>

                <set name="kittens">

                        <key column="MOTHER"/>

                        <one-to-many class="Cat"/>

                </set>

                <joined-subclass name="DomesticCat" table="DOMESTIC_CATS">

                    <key column="CAT"/>

                    <property name="name" type="string"/>

                </joined-subclass>

        </class>



        <class name="eg.Dog">

                <!-- mapping for Dog could go here -->

        </class>



</hibernate-mapping>