Strategy to persist entity's associated objects with NHibernate

Question

I am working on a rather larger application that tries to follow a layered architecture pattern. On DBAL I use fluently configured NHibernate. Database objects sometimes have associations like these:

public class HeaderDbo
{
    public HeaderDbo()
    {
        Details = new List<DetailDbo>();
    }
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual IList<DetailDbo> Details { get; set; }
}

public class DetailDbo
{
    public virtual int Id { get; set; }
    public virtual string DetailName { get; set; }
    public virtual HeaderDbo Header { get; set; }
    public virtual RelevantObjectDbo RelevantObject { get; set; }
}

public class RelevantObjectDbo
{
    public virtual int Id { get; set; }
    public virtual string RelevantText { get; set; }
}

Mapping is as follows:

public class HeaderDboMap : ClassMap<HeaderDbo>
{
    public HeaderDboMap()
    {
        Table("Header");
        Id(x => x.Id).Column("Id");
        Map(x => x.Name);
        HasMany(x => x.Details)
            .Inverse()
            .Cascade.All();
    }
}

public class DetailDboMap : ClassMap<DetailDbo>
{
    public DetailDboMap()
    {
        Id(x => x.Id).Column("Id");
        Table("Detail");
        Map(x => x.DetailName);
        References(x => x.Header).Column("HeaderId");
        References(x => x.RelevantObject).Column("RelevantObjectId")
            .Cascade.SaveUpdate();  //??
    }
}

public class RelevantObjectDboMap : ClassMap<RelevantObjectDbo>
{
    public RelevantObjectDboMap()
    {
        Id(x => x.Id).Column("Id");
        Table("RelevantObject");
        Map(x => x.RelevantText);
    }
}

Now, there are application domain entities that the DBOs are mapped to which do not necessarily reflect the database structure one-to-one. For example, Header might stay header, but Detail would, say, form itself from DetailDbo and parts of RelevantObjectDbo. Then the application does its thing over the entities - some transformation of Detail happens, which now needs to be persisted.

Suppose I only affected parts of the Detail entity which need to go into Detail table and don't affect RelevantObject table in any way. It might be a wrong way to think about the model but we also need to be practical about how persisting works. So, say, I would like to only have NHibernate update the Detail table without "touching" anything on the RelevantObject table. This is exactly the question, actually: how do I achieve that?

In reality, of course, the DB model is far bigger and more complicated and so is the application logic. There could be a part of BL that does not deal with the RelevantObject part of the data at all, so even though DBOs are loaded from the db fully, not all the data finds its way into the app model. But to persist the data back to the database - it seems that I need to hydrate the DB model fully and it's not always practical. So, how can we instruct NHibernate to "not touch" RelevantObject - in other words, not update dbo.Detail.RelevantObjectId?

I tried applying different Cascade options to DetailDbo.RelevantObject property, but if it stays at null, NHibernate always wants to set RelevantObjectId to NULL - I suppose, rightfully so.

I don't understand how I can write changes to the data that is relevant to my "part" of the BL without having to load and save half of my database through all the associations.

Thank you!

Answer 1

How are you performing these updates? If you are not modifying anything on RelevantObject NHibernate will not send an update for that table. For example:

var header = session.Get<HeaderDbo>(1);
header.Details.First().DetailName = "Whatever";
session.Flush();

Should not cause an update to be issued to the RelevantObject table.