NHibernate: playing with mapping by code

NHibernate: playing with mapping by code

NHibernate 3.2.0GA is going to be released and, around the NET, there are various questions about how use its “sexy-mapping”… “sexy-mapping” is not a serious definition? well… I’m bored by zero-one definitions.

I think that the “problem” is that I have explicitly avoided to call something “best practice” writing my examples (as I done with ConfORM) and the new mapping-by-code is very flexible and you have various ways to achieve your target.
In this example I’ll try to resume the answers to various questions.

This time nobody sent me a domain so the case is not real… it is a domain just for the exercise.

The domain

public class Entity
{
public virtual int Id { get; set; }
}
public class Customer : Entity
{
public virtual string CommercialName { get; set; }
public virtual string TaxId { get; set; }
public virtual IEnumerable<Order> Orders { get; set; }
}
public class Order : Entity
{
public virtual Customer Customer { get; set; }
public virtual DateTime EmissionDay { get; set; }
public virtual IEnumerable<OrderItem> Items { get; set; }
}
public class OrderItem : Entity
{
public virtual Order Order { get; set; }
public virtual string Product { get; set; }
public virtual decimal Price { get; set; }
}

The incomplete class-by-class mapping

In our mapping-process we can start from various points depending on our knowledge of NHibernate, our knowledge of the domain, how much we known our conventions, how much we really known the relations between classes and so on. For this exercise I’ll start from a very incomplete class-by-class mapping as the follow:

public class EntityMapping<T> : ClassMapping<T> where T : Entity
{
public EntityMapping()
{
Id(x => x.Id);
}
}
public class CustomerMapping : EntityMapping<Customer>
{
public CustomerMapping()
{
Property(x => x.CommercialName);
NaturalId(map => map.Property(x => x.TaxId));
Bag(x => x.Orders, map => map.Key(km => km.Column("CustomerId")));
}
}
public class OrderMapping : EntityMapping<Order>
{
public OrderMapping()
{
ManyToOne(x => x.Customer, map => map.Column("CustomerId"));
Property(x => x.EmissionDay, map => map.Type(NHibernateUtil.Date));
Bag(x => x.Items, map => map.Key(km => km.Column("OrderId")));
}
}
public class OrderItemMapping : EntityMapping<OrderItem>
{
public OrderItemMapping()
{
ManyToOne(x => x.Order, map => map.Column("OrderId"));
Property(x => x.Product);
Property(x => x.Price);
}
}

If you have studied the mapping-by-code you know that you can define everything using class-by-class mapping but I want show you how little is the step between explicit-mapping and conventions/defaults-mapping.

The ModelMapper

In this exercise I’ll use the ModelMapper. The ModelMapper delegates some responsibilities to others classes. You can see all classes involved analyzing all ModelMapper constructors overloads. If you have a look at the most simple constructor you will find that the ModelMapper uses, by default, the class ExplicitlyDeclaredModel. The ExplicitlyDeclaredModel does not apply any special behavior other than what was explicitly declared or NHibernate’s convetions about table/columns names and types. Using class-by-class mapping the basic usage of the ModelMapper can look as:

var mapper = new ModelMapper();
mapper.AddMappings(Assembly.GetExecutingAssembly().GetExportedTypes());
HbmMapping domainMapping = mapper.CompileMappingForAllExplicitlyAddedEntities();

yes!, that is all… then you have to add the domainMapping to the NHibernate’s configuration instance before BuildSessionFactory.

Applying tables-naming conventions over ModelMapper

The first convention required is : “All table names are lowercase”
Any kind of convention, customization have to be declared before get all mappings so we can do something like this:

var mapper = new ModelMapper();
mapper.AddMappings(Assembly.GetExecutingAssembly().GetExportedTypes());

mapper.BeforeMapClass += (mi, t, map) => map.Table(t.Name.ToLowerInvariant());
mapper.BeforeMapJoinedSubclass += (mi, t, map) => map.Table(t.Name.ToLowerInvariant());
mapper.BeforeMapUnionSubclass += (mi, t, map) => map.Table(t.Name.ToLowerInvariant());

HbmMapping domainMapping = mapper.CompileMappingForAllExplicitlyAddedEntities();

As you can see you can add all conventions even after add all mappings to the ModelMapper.

Applying property-types “conventions” over ModelMapper

“All properties defined as decimal have to be mapped as currency”

mapper.BeforeMapProperty += (mi, propertyPath, map) =>
{
if (typeof(decimal).Equals(propertyPath.LocalMember.GetPropertyOrFieldType()))
{
map.Type(NHibernateUtil.Currency);
}
};

Applying collections “conventions” over ModelMapper

“All Bags are bidirectional-one-to-many and the batch size is 10”

mapper.BeforeMapBag += (mi, propPath, map) =>
{
map.Cascade(Cascade.All.Include(Cascade.DeleteOrphans));
map.BatchSize(10);
};

Is that enough to accomplish the target ? No, is not. We have defined only some attributes of the collections declared as Bag but we haven’t defined which is the relation between the collection ReflectedType and the collection-item-type. We can’t define the one-to-many relation using the ModelMapper because the responsibility to define/discover all relation is delegated to the IModelInspector injected to the ModelMapper instance (note that I wrote instance). Out-of-the-box you can find some implementations of IModelInspector but if you want continue maintaining most of things under your control and you want learn the new mapping-by-code step-by-step you can simply use a class inherited from the “”default”” ExplicitlyDeclaredModel. In this case the implementation can be simply:

public class MySimpleModelInspector: ExplicitlyDeclaredModel
{
public override bool IsOneToMany(MemberInfo member)
{
if(IsBag(member))
{
return true;
}
return base.IsOneToMany(member);
}
}

and its usage is:

var modelInspector = new MySimpleModelInspector();
var mapper = new ModelMapper(modelInspector);

Applying POID strategy “conventions” over ModelMapper

At this point of the mapping-process we have a working an ready-to-work mapping for our above model but, where not defined, the default POID strategy is “assigned”. In this exercise I want use the HighLow strategy (aka HiLo) but not the simple version; I want use the per-entity-High-Low strategy.
Knowing how we are giving the name of the table (we wrote it just few lines above) the mapping of the convention is:

mapper.BeforeMapClass += (mi, type, map) =>
map.Id(idmap => idmap.Generator(Generators.HighLow,
gmap => gmap.Params(new
{
table = "NextHighVaues",
column = "NextHigh",
max_lo = 100,
where = string.Format("EntityName = '{0}'", type.Name.ToLowerInvariant())
})));

Is it enough ? Yes! It is… mmm… perhaps it is enough but not for me. By default NHibernate will generates a table for HighLow but will not insert all records needed by per-entity-High-Low. What we need is a smartIAuxiliaryDatabaseObject… something simple as:

private static IAuxiliaryDatabaseObject CreateHighLowScript(IModelInspector inspector, IEnumerable<Type> entities)
{
var script = new StringBuilder(3072);
script.AppendLine("DELETE FROM NextHighVaues;");
script.AppendLine("ALTER TABLE NextHighVaues ADD EntityName VARCHAR(128) NOT NULL;");
script.AppendLine("CREATE NONCLUSTERED INDEX IdxNextHighVauesEntity ON NextHighVaues (EntityName ASC);");
script.AppendLine("GO");
foreach (var entity in entities.Where(x => inspector.IsRootEntity(x)))
{
script.AppendLine(string.Format("INSERT INTO [NextHighVaues] (EntityName, NextHigh) VALUES ('{0}',1);", entity.Name.ToLowerInvariant()));
}
return new SimpleAuxiliaryDatabaseObject(script.ToString(), null, new HashedSet<string> { typeof(MsSql2005Dialect).FullName, typeof(MsSql2008Dialect).FullName });
}

Conclusions

Even if we started from a bored declarative (and incomplete) class-by-class-mapping we have changed its behavior without touch the initial mapping. The last step of the exercise is the integration with NHibernate3.2.0 and it is:

var configuration = new Configuration();
configuration.DataBaseIntegration(c =>
{
c.Dialect<MsSql2008Dialect>();
c.ConnectionString = @"Data Source=localhost\SQLEXPRESS;Initial Catalog=IntroNH;Integrated Security=True;Pooling=False";
c.KeywordsAutoImport = Hbm2DDLKeyWords.AutoQuote;
c.SchemaAction = SchemaAutoAction.Create;
});
configuration.AddMapping(domainMapping);
configuration.AddAuxiliaryDatabaseObject(CreateHighLowScript(modelInspector, Assembly.GetExecutingAssembly().GetExportedTypes()));

var factory = configuration.BuildSessionFactory();
// we are now ready to work with NHibernate

After build the session-factory in our db we will have:



For Tommaso guys (non crede finché non tocca)

<?xml version="1.0" encoding="utf-8"?>
<hibernate-mapping xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
namespace="PlayWithMappingByCode"
assembly="PlayWithMappingByCode"
xmlns="urn:nhibernate-mapping-2.2">
<class name="Customer" table="customer">
<id name="Id" type="Int32">
<generator class="hilo">
<param name="table">NextHighVaues</param>
<param name="column">NextHigh</param>
<param name="max_lo">100</param>
<param name="where">EntityName = 'customer'</param>
</generator>
</id>
<natural-id>
<property name="TaxId" />
</natural-id>
<property name="CommercialName" />
<bag name="Orders" cascade="all,delete-orphan" batch-size="10">
<key column="CustomerId" />
<one-to-many class="Order" />
</bag>
</class>
<class name="Order" table="order">
<id name="Id" type="Int32">
<generator class="hilo">
<param name="table">NextHighVaues</param>
<param name="column">NextHigh</param>
<param name="max_lo">100</param>
<param name="where">EntityName = 'order'</param>
</generator>
</id>
<many-to-one name="Customer" column="CustomerId" />
<property name="EmissionDay" type="Date" />
<bag name="Items" cascade="all,delete-orphan" batch-size="10">
<key column="OrderId" />
<one-to-many class="OrderItem" />
</bag>
</class>
<class name="OrderItem" table="orderitem">
<id name="Id" type="Int32">
<generator class="hilo">
<param name="table">NextHighVaues</param>
<param name="column">NextHigh</param>
<param name="max_lo">100</param>
<param name="where">EntityName = 'orderitem'</param>
</generator>
</id>
<many-to-one name="Order" column="OrderId" />
<property name="Product" />
<property name="Price" type="Currency" />
</class>
</hibernate-mapping>