NHibernate: Mapping Application Domain

Mapping Class Inheritance

There are three different approaches to represent a class inheritance hierarchy.

1) Table per concrete class

This approach uses one table for each (non-abstract) class. All class properties, including inherited properties, can be mapped to columns in the table.

In NHibernate, use a <class> declaration for each concrete class, specifying a different table attribute for each.

Problems with this approach:

• Limited support for polymorphic associations (where subclasses are inherited from a base class).
• Polymorphic queries are also problematic. A query against the base class must be executed as several SQL select statements, one for each concrete subclass.
• A change to a column in the base class would result in a column change in multiple tables.

2) Table per class hierarchy

An entire class hierarchy is mapped to a single table. The table includes columns for all properties of all classes in the hierarchy.

This strategy is both simple and good for performance.

The concrete subclass represented by a particular row must be identified by a unique value (a type discriminator column).

In NHibernate, use the <subclass> element to define this class hierarchy mapping for each subclass and map the base class using a <subclass> element. Specify, the unique row identifier column using the <discriminator> element in the base class mapping and discriminator attribute in the subclass mapping.

Problems with this approach:

• Database columns for properties declared by subclasses must be declared to be NOT NULL and this can cause a problem from the point of view of data integrity.

3) Table per subclass

Every subclass that declares persistent properties (including abstract classes and even interfaces) has its own table.

The table here contains columns only for each non-inherited property (each property declared by the subclass) along with a primary key that is also a foreign key of the base class table. The two rows are linked together by their shared primary key value.

In NHibernate, you use the <joined-subclass> element to indicate a table per subclass mapping. NHibernate will then use an outer join when querying the database.

Advantages of this approach:

• Relational model remains normalised.
• Schema changes are straightforward.

Mapping Class Associations

Associations refer to relationships between entities, and are mainly unidirectional.

One-to-many associations are the most important and popular type.

Many-to-many associations can be represented as two many-to-one associations. To represent a many-to-one relationship, need to definite two associations. One association mapping the many-to-one side of the relationship, and the other mapping representing the one-to-many side of the relationship.

One-to-one association

There are two different ways to represent one-to-one associations:

• Use a <many-to-one> mapping with a unique constraint on the foreign key. To make this association truly one-to-one, you add unique="true" to the <many-to-one> element. Map the other end of the association, using a <one-to-one> association. An example of use would be when mapping a user instance from a User table to two instances of an address in an Address table.
• Both ends of the association are mapped using <one-to-one> associations. Use constrained="true" property on one association to indicate a foreign key constraint that refers to the primary key of the other association. Use the <generator class="foreign"> mapping declaration to ensure instances of both associations are assigned the same identifier value. The <param> named property of the foreign generator allows you to name a one-to-one association.

Many-to-many association

Use an intermediate association class to represent a many-to-many relationship.

For unidirectional many-to-many relationships:

• Use the <many-to-many> association to map the intermediate table, or
• Use the idbag collection interface, or
• Use the list or map collections

For bidirectional many-to-many associations:

• Each row of the intermediate table is represented by two collections, one at each end of the association.
• Must declare one end of the association using inverse="true" to define which side's state is used to update the intermediate table.
• Can use a set, idbag, list or map collection for the non-inverse end of the bidirectional association.
• For the inverse end, use the set collection. Indexed collections such as lists and maps can't be used, because HNibernate won't initialize or maintain the index column if inverse="true".

One-to-many association

Used to map a typical parent/child relationship between two entity persistent classes using a <one-to-many> and a <many-to-one> mapping.

Use a <set> collection mappings for typical parent/child relationships.

Mapping Class Collections

You can use four different approaches to represent a collection.

Using a Set

• Uses the ISet interface container that is available in the IESI Collections library.
• Use the set declaration in the XML mapping declaration.
• The set container does not allow duplicate elements.

Using a Bag

• An unordered collection that permits duplicate elements is called a bag.
• NHibernate lets you use an IList in .NET to simulate bag behaviour. The IBag interface is not currently supported by .NET.
• Use the idbag declaration in the XML mapping declaration.

Using a List

• Use the list declaration in the XML mapping declaration.
• Requires an additional index column on the database table, which defines the position of the element in the collection.
• NHibernate can then preserve the ordering of the collection elements when retrieving the collection from the database.

Using a Map

• Use the map declaration in the XML mapping declaration.
• Permits duplicate elements.
• By setting the sorted=true attribute, NHibernate will sort the collection according to the CompareTo() method of the collection type. To use a different sort order, specify the name of the class that implements System Collections IComparer class.
• NHibernate sorted maps use System Collections SortedList in their implementation.

Mapping Fetching Strategy

NHibernate lets you specify a default fetching strategy in the XML mapping file, with the ability to then override it at runtime in code.

NHibernate provides four different fetching strategies for any assocation: Immediate, Lazy, Eager or Batch.

Immediate Fetching

• The associated object is fetched immediately, either through a sequential database read or a cache lookup.
• Only an efficient fetching strategy when the associated objects are cached already.

Lazy Fetching

• The associated object or collection is fetched "lazily" when the object is first accessed.
• This results in a new request to the database, unless the associated object is cached.
• This is the default fetching strategy configured for NHibernate 2.1.

Eager Fetching

• The associated object or collection is fetched together with the owning object, using a SQL outer join, and no further database request is required.
• NHibernate is limited to one eagerly fetched collection per mapped persistent class.

Batch Fetching

• Used to improve the performance of lazy fetching by retrieving a batch of objects or collections when a lazy association is accessed.

The fetching strategy can be overwritten for a particular association using the outer-join attribute for an association, as follows:

For single point associations

For collections

The correct fetching strategy minimizes the number of SQL statements that have to be executed by lazily, eagerly, or batch-fetching objects.