One of Java’s most widely used features is associating one class with another through composition or
some other means. For example, you might have an employee object that contains a social security
object. You need to be able to map these relationships in the database. In this section, we aren’t talking
about situations where you have a vector of another class as an attribute.
Hibernate’s mapping document uses two relationship elements: <many-to-one> and <one-to-one>. In
this section, we’ll describe the mappings;
<many-to-one> Element
In the course of object mapping, in some situations many objects associate to a single object. This is a
many-to-one relationship; you use the <many-to-one> element for the mapping. The format of the ele-ment
is as follows:
<many-to-one
name="string"
column="string"
class="string"
cascade=- [all] [none] [save-update] [delete]"
outer-join="[true] [false] [auto]"
update=" [true] [false]"
insert="[true] [false]"
property-ref="associated class" [optional]
access=" [field] [property] [component class name]"
/>
This element has the following attributes:
❑name: Specifies the name of the Java attribute associated with the relationship.
❑column: Specifies the name of the database column for the mapping. This is an optional
attribute; the default is the name attribute value.
❑class: Specifies the name of the class that is part of the relationship. Hibernate uses reflection if
this attribute isn’t included.
❑cascade: See the description in our discussion of the <hibernate-mapping> element.
❑outer-join: Determines whether an outer join should be used when pulling this object from the
database row. This attribute is optional; the default is auto. The possible values include auto,
true, and false. If the value is auto, an outer join is used if the related class isn’t using
a proxy.
❑update: Determines whether this specific attribute should be used in an UPDATE SQL query.
This is an optional attribute; the default is true.
❑insert: Determines whether this specific attribute should be used in an INSERT SQL query. This
is an optional attribute; the default is true. Note that if both the update and insert attributes
are false, then you must assume this attribute will be filled by another attribute or possibly by
a database trigger.
❑property-ref: In most relationships, the related class’s primary key is stored in this mapped col-umn.
In some databases, the relationship from the primary class to the related class isn’t based
on the primary key but on some other column. Since Hibernate attempts to use the identifier of
the related class, you need to specify the exact column to use. The property-ref attribute
specifies the exact column. (You’ll see an example in Chapter 5.)
❑access: See the description in our discussion of the <id> element.
<one-to-one> Element
In the course of object mapping, in some situations one object is associated with a single object. This is a
one-to-one relationship; you use the <one-to-one> element for the mapping. The format of the ele-ment
is as follows:
<one-to-one
name="name"
class="class"
cascade=" [all] [none] [save-update] [delete]"
[optional - default none] constrained=" [true] [false]"
outer-join=" [true] [false] [auto]"
property-ref="property other than primary key of mapped table"
[optional] access=" [field] [property] [component class name]"
/>
This element has the following attributes:
❑name: Specifies the name of the Java attribute associated with the relationship.
❑class: Specifies the name of the class that is part of the relationship. Hibernate uses reflection if
this attribute isn’t included.
❑cascade: See the description in our discussion of the <hibernate-mapping> element.
❑outer-join: Determines whether an outer join should be used when pulling this object from the
database row. This attribute is optional; the default is auto. The possible values include auto,
true, and false. If the value is auto, an outer join is used if the related class isn’t using a
proxy.
❑constrained: Determines that a foreign key constraint exists with the primary key of the
mapped table.
❑property-ref: In most relationships, the related class’s primary key is stored in this mapped col-umn.
In some databases, the relationship from the primary class to the related class isn’t based
on the primary key but on some other column. Since Hibernate attempts to use the identifier of
the related class, you need to specify the exact column to use. The property-ref attribute
specifies the exact column. (You’ll see an example in Chapter 5.)
❑access: See the description in our discussion of the <id> element.
<component> Element
The <component> element is designed to allow a property to be saved in the current object’s mapping
from another class. The format of the element is:
<component
name="name"
class="class"
update="true | false" [optional - defaults to true]
insert="true | false" [optional - defaults to true]
access="field | property | class" [optional - defaults to property]
<property/>
<many-to-one/>
/>
This element has the following attributes:
❑name: Specifies the name of the property to map.
❑class: Specifies the child class where the named property appears.
❑update: Determines whether this specific attribute should be used in an UPDATE SQL query.
This is an optional attribute; the default is true.
❑insert: Determines whether this specific attribute should be used in an INSERT SQL query. This
is an optional attribute; the default is true. Note that if both the update and insert attributes are
false, then you must assume this attribute is filled by another attribute or possibly by a
database trigger.
❑access: See the description in our discussion of the <id> element.
For all the properties in the child class that need to be mapped, you need to include <property> ele-ments.
You can also add appropriate relationships to the <component> element.
<subclass> Element
When an inheritance relationship is defined for your Java classes, the hierarchy needs to be defined.
Since Hibernate recommends the table-per-class-hierarchy mapping, you should define all subclasses
with the <subclass> element. Subclass definitions include attributes as well as the properties that have
been added to this specific subclass.
The format of the element is as follows:
<subclass
name=”name”
discriminator-value="value" [optional - defaults to name value]
proxy="interface" [optional]
lazy="true ( false" [optional]
dynamic-update="true | false"[optional - defaults to false]
dynamic-insert="true | false" [optional - defaults to false]
<property/>
/>
This element has the following attributes:
❑name: Specifies the name of the Java class this mapping document is designed to represent.
Hibernate expects a fully qualified class name in this attribute if you don’t have the package
attribute in the <hibernate-mapping> element.
❑discriminator-value: Specifies the value used to distinguish between different classes in an
inheritance hierarchy. The default is the class name.
❑proxy: Tells Hibernate whether to use lazy initialization for objects of this mapping type. Lazy
initialization allows Hibernate to basically stub out the data in an object. If you’re using lazy ini-tialization,
you create objects and load them just as in the example application in Chapter 3, but
Hibernate won’t populate or make a call to the database for data until the object is used. The
proxy attribute requires you to provide a class that is used for the lazy initialization; this should
normally be the class name used in the name attribute.
❑dynamic-update: If true, then when Hibernate updates a row in the database for a class
attribute that has changed, it generates an UPDATE SQL statement at runtime during the
update() method call on the session and only include the columns of the table that have been
updated. This is an optional attribute; the default is false.
❑dynamic-insert: The same as dynamic-update in principle; but Hibernate dynamically creates
an INSERT SQL statement with only those columns that aren’t null values. This is an optional
attribute; the default is false.
Once the attributes have been defined for the subclass, you need to define all the new attributes that
should be persisted. Use the <property> element to define each attribute.
<joined-subclass> Element
If you don’t want to use the recommended inheritance mapping, you can choose the table-per-subclass
mapping. Each subclass must have its own <joined-subclass> element. You include all
the usual elements like <property>, <key>, and so on for this subclass.
The format of the element is as follows:
<joined-subclass
name="name"
proxy="interface" [optional]
lazy="true | false" [optional]
dynamic-update="true | false" [optional - defaults to false]
dynamic-insert="true | false" [optional - defaults to false]
some other means. For example, you might have an employee object that contains a social security
object. You need to be able to map these relationships in the database. In this section, we aren’t talking
about situations where you have a vector of another class as an attribute.
Hibernate’s mapping document uses two relationship elements: <many-to-one> and <one-to-one>. In
this section, we’ll describe the mappings;
<many-to-one> Element
In the course of object mapping, in some situations many objects associate to a single object. This is a
many-to-one relationship; you use the <many-to-one> element for the mapping. The format of the ele-ment
is as follows:
<many-to-one
name="string"
column="string"
class="string"
cascade=- [all] [none] [save-update] [delete]"
outer-join="[true] [false] [auto]"
update=" [true] [false]"
insert="[true] [false]"
property-ref="associated class" [optional]
access=" [field] [property] [component class name]"
/>
This element has the following attributes:
❑name: Specifies the name of the Java attribute associated with the relationship.
❑column: Specifies the name of the database column for the mapping. This is an optional
attribute; the default is the name attribute value.
❑class: Specifies the name of the class that is part of the relationship. Hibernate uses reflection if
this attribute isn’t included.
❑cascade: See the description in our discussion of the <hibernate-mapping> element.
❑outer-join: Determines whether an outer join should be used when pulling this object from the
database row. This attribute is optional; the default is auto. The possible values include auto,
true, and false. If the value is auto, an outer join is used if the related class isn’t using
a proxy.
❑update: Determines whether this specific attribute should be used in an UPDATE SQL query.
This is an optional attribute; the default is true.
❑insert: Determines whether this specific attribute should be used in an INSERT SQL query. This
is an optional attribute; the default is true. Note that if both the update and insert attributes
are false, then you must assume this attribute will be filled by another attribute or possibly by
a database trigger.
❑property-ref: In most relationships, the related class’s primary key is stored in this mapped col-umn.
In some databases, the relationship from the primary class to the related class isn’t based
on the primary key but on some other column. Since Hibernate attempts to use the identifier of
the related class, you need to specify the exact column to use. The property-ref attribute
specifies the exact column. (You’ll see an example in Chapter 5.)
❑access: See the description in our discussion of the <id> element.
<one-to-one> Element
In the course of object mapping, in some situations one object is associated with a single object. This is a
one-to-one relationship; you use the <one-to-one> element for the mapping. The format of the ele-ment
is as follows:
<one-to-one
name="name"
class="class"
cascade=" [all] [none] [save-update] [delete]"
[optional - default none] constrained=" [true] [false]"
outer-join=" [true] [false] [auto]"
property-ref="property other than primary key of mapped table"
[optional] access=" [field] [property] [component class name]"
/>
This element has the following attributes:
❑name: Specifies the name of the Java attribute associated with the relationship.
❑class: Specifies the name of the class that is part of the relationship. Hibernate uses reflection if
this attribute isn’t included.
❑cascade: See the description in our discussion of the <hibernate-mapping> element.
❑outer-join: Determines whether an outer join should be used when pulling this object from the
database row. This attribute is optional; the default is auto. The possible values include auto,
true, and false. If the value is auto, an outer join is used if the related class isn’t using a
proxy.
❑constrained: Determines that a foreign key constraint exists with the primary key of the
mapped table.
❑property-ref: In most relationships, the related class’s primary key is stored in this mapped col-umn.
In some databases, the relationship from the primary class to the related class isn’t based
on the primary key but on some other column. Since Hibernate attempts to use the identifier of
the related class, you need to specify the exact column to use. The property-ref attribute
specifies the exact column. (You’ll see an example in Chapter 5.)
❑access: See the description in our discussion of the <id> element.
<component> Element
The <component> element is designed to allow a property to be saved in the current object’s mapping
from another class. The format of the element is:
<component
name="name"
class="class"
update="true | false" [optional - defaults to true]
insert="true | false" [optional - defaults to true]
access="field | property | class" [optional - defaults to property]
<property/>
<many-to-one/>
/>
This element has the following attributes:
❑name: Specifies the name of the property to map.
❑class: Specifies the child class where the named property appears.
❑update: Determines whether this specific attribute should be used in an UPDATE SQL query.
This is an optional attribute; the default is true.
❑insert: Determines whether this specific attribute should be used in an INSERT SQL query. This
is an optional attribute; the default is true. Note that if both the update and insert attributes are
false, then you must assume this attribute is filled by another attribute or possibly by a
database trigger.
❑access: See the description in our discussion of the <id> element.
For all the properties in the child class that need to be mapped, you need to include <property> ele-ments.
You can also add appropriate relationships to the <component> element.
<subclass> Element
When an inheritance relationship is defined for your Java classes, the hierarchy needs to be defined.
Since Hibernate recommends the table-per-class-hierarchy mapping, you should define all subclasses
with the <subclass> element. Subclass definitions include attributes as well as the properties that have
been added to this specific subclass.
The format of the element is as follows:
<subclass
name=”name”
discriminator-value="value" [optional - defaults to name value]
proxy="interface" [optional]
lazy="true ( false" [optional]
dynamic-update="true | false"[optional - defaults to false]
dynamic-insert="true | false" [optional - defaults to false]
<property/>
/>
This element has the following attributes:
❑name: Specifies the name of the Java class this mapping document is designed to represent.
Hibernate expects a fully qualified class name in this attribute if you don’t have the package
attribute in the <hibernate-mapping> element.
❑discriminator-value: Specifies the value used to distinguish between different classes in an
inheritance hierarchy. The default is the class name.
❑proxy: Tells Hibernate whether to use lazy initialization for objects of this mapping type. Lazy
initialization allows Hibernate to basically stub out the data in an object. If you’re using lazy ini-tialization,
you create objects and load them just as in the example application in Chapter 3, but
Hibernate won’t populate or make a call to the database for data until the object is used. The
proxy attribute requires you to provide a class that is used for the lazy initialization; this should
normally be the class name used in the name attribute.
❑dynamic-update: If true, then when Hibernate updates a row in the database for a class
attribute that has changed, it generates an UPDATE SQL statement at runtime during the
update() method call on the session and only include the columns of the table that have been
updated. This is an optional attribute; the default is false.
❑dynamic-insert: The same as dynamic-update in principle; but Hibernate dynamically creates
an INSERT SQL statement with only those columns that aren’t null values. This is an optional
attribute; the default is false.
Once the attributes have been defined for the subclass, you need to define all the new attributes that
should be persisted. Use the <property> element to define each attribute.
<joined-subclass> Element
If you don’t want to use the recommended inheritance mapping, you can choose the table-per-subclass
mapping. Each subclass must have its own <joined-subclass> element. You include all
the usual elements like <property>, <key>, and so on for this subclass.
The format of the element is as follows:
<joined-subclass
name="name"
proxy="interface" [optional]
lazy="true | false" [optional]
dynamic-update="true | false" [optional - defaults to false]
dynamic-insert="true | false" [optional - defaults to false]
No comments:
Post a Comment
Note: Only a member of this blog may post a comment.