One-to-one mapping and Lazy loading

Often we have the following situation: An entity has some attributes that are important and often accessed and then it has some other attributes that are either rarely used or their content is large in size (e.g. a photo or a document). In such situations it is common to split the entity into two tables. One table containing the important attributes and the other the remaining ones. A typical example is table 'Person' and table 'PersonDetails'. These tables are relatet by a 1 to 0..1 relation. That is a person can have person details but doesn't need to. On the other hand 'person details' always belong to a 'person'.

Question: How can we instruct NHibernate and/or ActiveRecord to give us such a relation. We want to have the possibility to load a list of persons WITHOUT loading also their corresponding details. The details should ONLY be loaded when we really access them. That is called 'Lazy Loading'.

Just using a one-to-one relation doesn't work! We have to use a 'trick' and use a combination of a many-to-one and a one-to-one relation. This solves our problem.

NHibernate

Let us look at the code:

namespace NHibernateTest
{
    public class Person
    {
        private int _personID;
        private string _lastName;
        private string _firstName;
        private PersonPhoto _photo;

        public virtual int PersonID
        {
            get { return _personID; }
            set { _personID = value; }
        }

        public virtual PersonPhoto Photo
        {
            get { return _photo; }
            set { _photo = value; }
        }

        public virtual string LastName
        {
            get { return _lastName; }
            set { _lastName = value; }
        }

        public virtual string FirstName
        {
            get { return _firstName; }
            set { _firstName = value; }
        }
    }

    public class PersonPhoto
    {
        private int _personID;
        private byte[] _photo;
        private Person _owner;

        public virtual int PersonID
        {
            get { return _personID; }
            set { _personID = value; }
        }

        public virtual Person Owner
        {
            get { return _owner; }
            set { _owner = value; }
        }

        public virtual byte[] Photo
        {
            get { return _photo; }
            set { _photo = value; }
        }
    }
}

and now at the NHibernate mapping file(s)

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="NHibernateTest" namespace="NHibernateTest">
  <class name="Person" >
    <id name="PersonID" type="Int32">
      <generator class="identity" />
    </id>
    <property name="LastName" type="String" length="50" />
    <property name="FirstName" type="String" length="50" />
    <many-to-one name="Photo" class="PersonPhoto" />
  </class>

  <class name="PersonPhoto">
    <id name="PersonID" type="Int32">
      <generator class="foreign">
        <param name="property">Owner</param>
      </generator>
    </id>
    <property name="Photo" type="BinaryBlob" />
    <one-to-one name="Owner" class="Person" constrained="true" />
  </class>
</hibernate-mapping>

Note:

• on the "parent" side (Person) we have the many-to-one relation which points to PersonPhoto.
• on the "child" side (PersonPhoto) the primary key (PersonID) is the same as on the "parent" side. Thus the value must be "inherited" from the parent. This is the reason to use "foreign" as generator class. The <param> tag just points to the Property from which NHibernate can get this PK value, in our case the property is called Owner (which is the Person who owns this photo).
• on the "child" side we have the one-to-one relation which points to Person.
• the one-to-one relation sets constrained=true since the person details belongs to a person (a person MUST exists).

ActiveRecord

We can define the same behaviour in ActiveRecord. Here I choose a similar sample as above, a one-to-one relation between a Car and its CarPhoto. Code explains better than many words, thus:

[ActiveRecord("Car", Lazy = true)]
public class Car : ActiveRecordBase<Car>
{
    private Guid _CarID;
    private CarPhoto _photo;
    private string _make;

    [PrimaryKey(PrimaryKeyType.Guid, "CarID", ColumnType = "Guid")]
    public virtual Guid CarID
    {
        get { return _CarID; }
        set { _CarID = value; }
    }

    [BelongsTo(Column = "CarID", Unique = true)]
    public virtual CarPhoto Photo
    {
        get { return _photo; }
        set { _photo = value; }
    }

    [Property(ColumnType = "String", Length = 50)]
    public virtual string Make
    {
        get { return _make; }
        set { _make = value; }
    }
}

[ActiveRecord("CarPhoto", Lazy = true)]
public class CarPhoto : ActiveRecordBase<CarPhoto>
{
    private Guid _CarID;
    private Car _owner;
    private byte[] _photo;

    [PrimaryKey(PrimaryKeyType.Foreign, "CarID", ColumnType = "Guid")]
    public virtual Guid CarID
    {
        get { return _CarID; }
        set { _CarID = value; }
    }

    [OneToOne(Constrained = true)]
    public virtual Car Owner
    {
        get { return _owner; }
        set { _owner = value; }
    }

    [Property(ColumnType = "BinaryBlob", SqlType = "VARBINARY(MAX)")]
    public virtual byte[] Photo
    {
        get { return _photo; }
        set { _photo = value; }
    }
}

Now I can happily load a list of cars and the photos are not loaded by default but only when I really access them...