Is it possible to have a OneToOne relation to a class hierarchy persisted using JoinedBase?

Question

I'd like one of my entities to have a one-to-one relationship with a class hierarchy. Think of it like a Strategy pattern, where each strategy needs different parameters to be persisted. I tried using a combination of OneToOne and JoinedBase/JoinedKey, but I've come across a problem.

With this combination, the primary key of the main entity also appears as the primary key of the table representing the root class in the hierarchy, and as the primary key of the subclass:

        Order    --------------- TaxCalculator
([PrimaryKey]Id = 1234)        ([PrimaryKey(PrimaryKeyType.Foreign)]OrderId = 1234) 
                                      ^
                                      |
                                      |
                             UkTaxCalculator
                      ([JoinedKey]UkTaxCalculatorId = 1234)

I can persist this fine, but then I can't change which subclass of TaxCalculator I have. When I do something like:

order.TaxCalculator = new OverseasTaxCalculator(order);

then try to flush, then ActiveRecord/NHibernate (understandably) gets unhappy that there are now two TaxCalculators with Id = 1234.

I can get around this by replacing the OneToOne with a HasMany/BelongsTo, and hiding the multiplicity from users of the Order object, but I'm interested to know if it's possible to do this with OneToOne.

There's a full code example on github. This code throws an exception when the second SessionScope is disposed. If you clone the project, it should run out-of-the-box.

Answer 1

Hi Alex, first of all i am sorry, but i did not tried my solution. It is to late and i really need my sleep ;-). I think the only way the one-to-one could work would be a 'table-per-hierarchy'-approach using a discriminator column instead of table-per-subclass. Maybe this will enable you to morph the existing object to another subclass. An other way, something like a polymorphic delete-orphan unfortunately is not supported as you stated. So i'll guess this would be your (very) last option.

But if this fails why don't you map it as a one-to-many instead of many-to-one with a foreign key in the order table, reusing the TaxCalculators? I would imagine them as quite static.

Interesting idea though: polymorphic delete-orphan.

Answer 2

Hi Alex,

We do something very similar to what you are trying to do. I think it's your combination of one-to-one and the joined key that's causing the problem. Try this:

[ActiveRecord, JoinedBase]
public class TaxCalculator
{
 protected int TaxCalculatorId;

 [PrimaryKey]
 public virtual int Id
 {
  get { return TaxCalculatorId; }
  set { TaxCalculatorId = value; }
 }

 // common tax calculation fields, methods etc...
}

[ActiveRecord]
public class OverseasTaxCalculator : TaxCalculator
{
 [JoinedKey]
 public override int Id
 {
  get { return TaxCalculatorId; }
  set { TaxCalculatorId = value; }
 }

 // overseas tax calculation specific methods, properties etc...
}