NHibernate Mappings

In this post, I will talk about NHibernate mappings. Let's start from the data model:

What we can see here are 4 types of relationships:

1. A one-to-one, from table A to table E;
2. A many-to-one, from table B to table C;
3. A one-to-many, from table C to table D;
4. A many-to-one, from table D to table C.

Also, note this:

1. All tables, except A, D and E, have composite primary keys; this is the most generic case;
2. All tables, except B_C, have a Text column;
3. Primary keys are always named <tablename><number>, for example, A1, A2, etc;
4. Foreign keys have the same name as the referring primary key.

Now, let's see the classes that map these tables and relationships:

And the source code is:

using System;

using System.Collections.Generic;

public class A

public virtual Int32 Id  { get; set; }

public virtual String Text { get; set; }

A other = obj as A;

using System.Collections.Generic;

public class B

public class BKey

public virtual Int32 B1 { get; set; }

public virtual Int32 B2 { get; set; }

BKey other = obj as BKey;

public virtual BKey Id { get; set; }

public virtual ISet<C> C { get; set; }

B other = obj as B;

using System;

using System.Collections.Generic;

public class C

public class CKey

public virtual Int32 C1 { get; set; }

public virtual Int32 C2 { get; set; }

CKey other = obj as CKey;

public virtual CKey Id { get; set; }

public virtual ISet<B> B { get; set; }

public virtual ISet<D> D { get; set; }

C other = obj as C;

using System;

using System.Collections.Generic;

public class D

public virtual Int32 Id { get; set; }

public virtual C C { get; set; }

using System;

using System.Collections.Generic;

public class E

public virtual A A { get; set; }

As you can see:

1. There is no class to map table B_C, this is because this is pure mapping table, it contains no additional attributes other than the foreign keys;
2. The id for class E is a property of type A;
3. No base class;
4. Methods Equals and GetHashCode are always implemented;
5. Collections are ISet<T>, which means they cannot hold equal objects;
6. Properties are auto properties and always have public setters;
7. Id classes for mapping composite keys are implemented as internal.

Now, here are the mappings:

For class A:

        <id name="Id" column="`A1`">

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

        </id> 

        <one-to-one name="E" class="E" />

</hibernate-mapping>

For class B:

    <class name="B" table="`B`">

            <key-property column="`B1`" name="B1"/>

        <property name="Text" column="`TEXT`"/>

            <key>

                <column name="`B2`"/>

            <many-to-many class="C" fetch="join" outer-join="true">

                <column name="`C2`"/>

        </set>

</hibernate-mapping>

For class C:

    <class name="C" table="`C`">

            <key-property column="`C1`" name="C1"/>

        </composite-id>

        <set name="B" table="`B_C`" fetch="join" cascade="save-update" outer-join="true">

                <column name="`C1`"/>

            </key>

                <column name="`B2`"/>

        </set>

            <key>

                <column name="`C2`"/>

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

    </class>

For class D:

    <class name="D" table="`D`">

            <generator class="assigned"/>

        <property name="Text" column="`TEXT`"/>

            <column name="`C1`"/>

        </many-to-one>

</hibernate-mapping>

And finally, for class E:

    <class name="E" table="`E`">

            <column name="`A1`"/>

        </id>

        <property name="Text" column="`TEXT`"/>

</hibernate-mapping>

The notes for the mappings are:

1. Table and column names are enclosed in `;
2. Collections are sets, not lists, idbags or bags; 
3. Primary keys are manually assigned;
4. Properties are directly used to access values;
5. Collections always use outer-join.

Hope this is useful to somebody!