DateTime values are one of the most feared type of data to store in database. Suppose you have an entity with a datetime Property, and you want to do a standard report finding the count of each entity for each day in a date range, if you groupBy the DateTime property, surely you will get wrong results, because you will end with a lot of entries with count = 1, because it is really difficult that two entities will have the very same datetime value. What you want is to group by only with the date part of the datetime property.

Since NHibernate does not come with a predefined date function, you need to create a custom dialect to solve the problem, first of all I have a custom dialect for my SqlLite unit tests.

   1: public class SqlLiteDialect : NHibernate.Dialect.SQLiteDialect

   2: {

   3:     public SqlLiteDialect()

   4:     {

   5:         RegisterFunction("date", new SQLFunctionTemplate(NHibernateUtil.Date, "date(?1)"));

   6:     }

   7: }

Since SqlLite already have a date function that extract the date part of a date, I simply need to instruct NHibernate dialect that such function exists registering the function “date” with a SqlFunctionTemplate, this means that whenever the HQL parser will find a call to date() function it will substitute the date(?1) string, where ?1 will be substituted with the real parameter of the function.

In production, the code will run against a sql server 2008, and we have already defined a function called dbo.trunc that will truncate the time part of the date in our databases, so I create a similar dialect for sql server.

   1: public class MySqlDialect : NHibernate.Dialect.MsSql2008Dialect

   2: {

   3:     public MySqlDialect ()

   4:     {

   5:         RegisterFunction("date", new SQLFunctionTemplate(NHibernateUtil.Date, "dbo.trunc(?1)"));

   6:  

   7:     }

   8: }

The great advantage of the dialect approach, is that you are able to write a hql query like this:

   1: Select date(A.ActionDate), count(*) 

   2: from Action A 

   3: where A.ActionDate >= :startdate and A.ActionDate <= :enddate

   4: group by date(A.ActionDate)

Where I’m able to use date() function, but at the same time it gets translated in different way respect the dialect I use. If in the future I will need to use Oracle, I’ll simply create another dialect, without the need to modify any HQL query.

alk.

NHprofiler de facto is “THE TOOL” to work with NHibernate,

If you work with NHibernate you must have NHProf, if you use it for 1 minute you can never work without it in the future, period.

I started today to use NHProf even for unit testing, since I want to be able to look at generated sql during tests of entities. I have a base test infrastructure to work with helper, so I have this snippet of code in fixture setup.

   1: if (inited == false)

   2: {

   3:     inited = true;

   4:     HibernatingRhinos.Profiler.Appender.NHibernate.NHibernateProfiler.Initialize();

   5: }

When I run the unit test I see that session initialization data will shown in nhibernate profiler ui, but the test then throws a

log4net:ERROR [NHibernateProfilerAppender] Attempted to append to closed appender named [NHibernate.Profiler]

This happens because NhProfiler uses log4net to intercept nhibernate calls, and it seems that someone closes the appender before nhprof has finished collecting data. This error happens because you need to configure log4net before the call to

   1: HibernatingRhinos.Profiler.Appender.NHibernate.NHibernateProfiler.Initialize();

If you like me use the Castle Log4Net faciliy, you simply need to be sure that the facility configures log4net before starting nhprofiler

   1: if (inited == false)

   2: {

   3:     ILogger logger = IoC.Resolve<ILogger>();

   4:     inited = true;

   5:     HibernatingRhinos.Profiler.Appender.NHibernate.NHibernateProfiler.Initialize();

   6: }

In my situation the act of resolving an ILogger makes me sure that log4net is completely configured before I started nhprofiler appender and everything works well.

alk.

Suppose you have an entity like this

your NickName class has two bags, one containing a list of DomainRegistrations, and the other containing a series of Attachments. Now suppose you map both of these with fetch=”join”, this can cause a really really really big problem.

As you can read in this bug in NHibernate jira, you should know that fetch join is not supported when there is more than one bag in the entity, because bag allows for duplicate items . When you do your unit testing of the basic mapping functionality (you should always unit test mappings") when you save a NickName with 2 domains and 2 attachments and reload it, the ISession will give you a nasty object with 4 Domains and 4 Attachments . If you think that NH should support this scenario think that bag allows duplicate, and this makes impossible for NH to understand from the resultset with fetch join, if the original object has 1 2 3 or 4 attachments.

The obvious solution is to change the fetch mode from join to select, but if you really want to be able to do a fetch=”join” you can consider if you really want to allow duplicates in your DomainRegistrations and Attachments properties. Mapping association from one to many with a bag is simple, because you can use an IList<T> interface in your domain classes. If you do not want to allow duplicates, and map the collection as a <set> instead of a <bag> you cannot use anymore the IList<T> interface. This is due to the fact that NHibernate rehydrate entities using a specific class that supports “set” semantic, not allowing a duplicate and it does not implement IList<T>.

In my situation, I can change those two properties from IList<T> to ICollection<T> and initialize them with HashSet<T> framework class. Now I’m able to map them with <set>, setting fetch mode to “join” avoiding the aforementioned duplicate problem. In the end I would prefer nhibernate to give me an error during mapping compile phase, something telling me “you cannot use fetch mode join on a bag when more than a bag is present in an entity”, instead of having strange behavior at runtime

alk.

Tags: NHibernate

I have this piece of domain model.

The LinkResult class has a property called Link that point to a AnalyzedLink class that in turn has a collection of AnalyzedLinkExtClass called ExtData. All the relation are unidirectional, this means that there is nothing that bring me from AnalyzedLink to a linkResult and nothing that bring me from AnalyzedLinkExtData to the AnalyzedLink. This is the typical situation where doing complex query can be tricky

Now I had to find all the LinkResult objects that have Status = LinkResultStatus.Ok and the associated AnalyzedLink must not contain an AnalyzedLinkExtData with the property Source equal to a certain value.

The query in HQL is

   1: @"select L 

   2: from LinkResult L 

   3: join L.Link AL 

   4: where L.Status = :status and 

   5: not exists (from AL.ExtData ED where ED.Source = :source) 

   6: order by L.AnalysisDate desc"

This is really powerful, I can simply start the query from the LinkResult object, then join to the L.Link and set a condition on L.Status property.

Now I add a not exists with the condition (from AL.ExtData ED where ED.Source = :source) as you can see I do not need to specify any join, but I can select directly from the ExtData Collection Property of the AnalyzedLink result. The SQL generated is

   1: select

   2:        linkresult0_.Id as Id175_,

   3:        .....

   4:    from

   5:         LinkResult linkresult0_ 

   6:     inner join

   7:         AnalyzedLink analyzedli1_ 

   8:     on linkresult0_.link_id=analyzedli1_.link_id 

   9:     where

  10:         linkresult0_.status=@p0 

  11:         and  not (exists (select

  12:             extdata2_.aled_id 

  13:         from

  14:             AnalyzedLinksExtData extdata2_ 

  15:         where

  16:             analyzedli1_.link_id=extdata2_.aled_link_id 

  17:             and extdata2_.aled_source=@p1)) 

  18:     order by

  19:         linkresult0_.analysisDate desc;

The real magic is done in the subquery, because you can verify that the condition on subquery contains two condition, the first is the link with the outer query, and the second one is the one we put on HQL. But you can surely appreciate the fact that in HQL the query is really clearer and shorter

alk.

Tags: NHibernate

Working with open source software is fun, but sometimes can be difficult. Take as example castle and Nhibernate, since castle references nh with the NHIntegration facility, and at the same time NH references castle for Dynamic Proxy.

A good way to survive this chaos, is working with the trunk, as I usually do, but compiling everything can be quite complex, but we are lucky because we have a project called Horn that does everything for you.

First of all you need to install nsysgit first of all you need to grab the latest source of horn with the comand “git clone git://github.com/dagda1/horn_src.git”. Once you get the source, you need to modify a source file called /src/horn.console/program.cs, in this file there is a function called GetRootFolderPath that ends with a line like

   1: var ret = new DirectoryInfo(rootFolder);

This line needs to be modified with the following line

   1: var ret = new DirectoryInfo(@"d:\osdevelop\horn_src\" + PackageTree.RootPackageTreeName);

clearly the D:\osdevelop\horn_src is my physical path where git extracted horn source code. Now you can go project root and run the HornBuild.bat. If the compilation is successful the horn library was compiled correctly, so you can go to /src/build/net-3.5/debug and you should find a program called horn.exe. Go to this location with a command line and type

   1: horn -install:castle.facilities.nhibernateintegration

with this command horn try to build everything needed for castle facilities nhibernate integration, so horn contacts all various repositories of all the needed libraries, it downloads the latest source and compiles everything. IF everything is gone good, you can simply go to the directory .horn\result and find all the dll’s without worrying about order of compilation, source repositories etc etc.

Alk.

Tags: NHibernate

Tags: Castle

When you use NHibernate and asp.net one of the most interesting stuff is looking at sql generated for each page call. While NHProf is the best tool to accomplish this task, it is interesting to trace issued sql queries using asp.net trace engine.

To accomplish this task is really straightforward thanks to log4net, first of all configure a suitable appender in log4net config file.

<appender name="AspNetTraceAppender" type="log4net.Appender.AspNetTraceAppender" >
    <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
    </layout>
</appender>

This appender sends all messages to asp.net trace engine, then enable tracing in the web.config.

 <trace enabled="true" pageOutput="true" requestLimit="100" localOnly="true" />

Now you need to configure log4net to issue all nhibernate logs to the previous appender.

<logger name="NHibernate" additivity="false">
    <level value="INFO" />
    <appender-ref ref="AspNetTraceAppender" />
</logger>

<logger name="NHibernate.SQL" additivity="false">
    <level value="DEBUG" />
    <appender-ref ref="AspNetTraceAppender" />
</logger>

I keep the standard level of NHIbernate to INFO, but the NHibernate.SQL to DEBUG. The result is the following.

Et voila, you get all the query that were issued to the database in the trace of your page, without the need to attach debugger or trace or whatever else. This is especially interesting if you use continuous integration and all testers usually work with latest site version running on test server. With such a facility everyone can look at what is really happening to the database.

alk.

Tags: NHibernate

I have a project where I need to access tables with millions of rows, the project was born without nhibernate so the database was not designed with ORM in mind. I decided to improve performances with an Indexed view that materialized a join between five tables, wrapped with another view that does a left outer joins with other 3 tables. Then I created an entity called XXXDto, and mapped with nhibernate, with update=”false” to prevent updating and pointed it to this view.

Everything runs fine, but now I have a little new feature to implement; that entity needs another property called Bookmark, and the value is specific of each user. In the software the user can search the aforementioned entity with some criteria, then he bookmarks the ones he likes most, and the software must signal bookmarked ones with a different image in the web ui. The problem is that bookmark table was already present in the database and has this schema.

This table works this way, if a user put a bookmark on an entity, a record with username and link_id (the foreign key to other table) is inserted, if the bookmark is removed the record is removed. Now I want to avoid the N+1 select, so I decided not to issue another query for each one of the original links, moreover I used ICriteria to recover entities, since the user can set complex filter through the UI and ICriteria makes really simple to compose the query.

Thanks to nhibernate I can use a formula in the mapping, but I need to put a condition on that formula, here is how I solved the problem.

<property
name="Bookmark"
formula="(select count(*) from Bookmark B where B.bookmark_link_id = Id and B.bookmark_user = :UserContext.UserName)" />
  

The formula is based on the fact that Bookmark is a boolean field, so if I issue a select count(*) everything is ok because if the bookmark is present the value is 1 if it is not present the value is 0, suitable for a boolean field. The condition is that bookmark_link_id = Id where id is the id column of the entity, and the user condition is B.Bookmark_User = :UserContext.UserName. This instruction uses a filter, a global parameter supported by nhibernate, that permits me to put parameters in mappings. Now I need to define this filter in a mapping.

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
    <filter-def name='UserContext'>
        <filter-param name='UserName' type='System.String'/>
    </filter-def>
</hibernate-mapping>

Now that the filter is defined I need to set the appropriate value in code before issuing the query. Since I wrapped the query in a Query object specific of that project I have a similar code that translate my Query object to a ICriteria + Session in nhibernate

foreach (Query.Filter filter in myQuery.Filters)
{
    IFilter nhibFilter = _session.EnableFilter(filter.Name);
    foreach (KeyValuePair<string, object> parameter in filter.Parameters)
    {
        nhibFilter.SetParameter(parameter.Key, parameter.Value);
    }
}

To create a filter you can simply call EnableFilter() method on a session, then you set specific filter on the IFilter object returned from the EnableFilter(). Here is the query generated by this mapping.

select top 20 this_.Id as Id31_0_,
this_.Name, ....,
(select count(*) from Bookmark B where B.bookmark_link_id = this_.Id and B.bookmark_user = @p0) as formula1_0_ FRom ..... 

The only drawback is that in formula mapping you must use the sql name of the column involved (in that example I need to use bookmark_link_id = Id where id is the real column name that contains id), but the query is correct and everything works perfectly.

alk.

Tags: NHibernate Formula

NHibernate HQL language is really powerful, and work in many scenario. Suppose you have those two classes.

Action is an object capable of executing something, while ActionLog stores the result of the execution of an action. There is no direct relation between the two, so in ActionLog we have not a reference to Action, but a simple field called ActionId that stores the id of the action. The reason for this choice is that Action objects can be deleted (and there is a special form of action called SpawnedAction that gets created, executed, and finally phisically deleted from the table); ActionLog must be retained even for deleted action, so we prefer not to store a direct relation.

Everything works fine, but today I need to create a dto that transfer for each failed ActionLog both the ActionLog class and the Action class to access field from action. A first solution is to retrieve all ActionLog, then for each ActionLog load the appropriate Action using ActionId, but this will cause N+1 select.

Thanks to HQL we can use theta joins, here is my HQL

Select L, A from ActionLog L, Action A  where L.ActionId = A.id and L.IsSuccess = 0 order by L.StartDate desc

As you can see i select L and A from ActionLog and Action, then in where condition I’ll insert the join condition L.ActionId with A.id, where id is a special property name in HQL that gets translated to the name of the property used as identifier for the Action class.

The result of this query is an arraylist, where each element is an array of objects, an instance of ActionLog and the corresponding instance of Action. Then I proceed creating this object

the ActionErrorLog is a Dto that returns to the caller a couple consisting of a Log and corresponding action. Retrieving a list of ActionErrorLog is really simple.

IList logs = uow.Session.CreateQuery("Select L, A from ActionLog L, Action A  where L.ActionId = A.id and L.IsSuccess = 0 order by L.StartDate desc")
    .SetFirstResult(pageNum * pageSize)
    .SetMaxResults(pageSize)
    .List();
return logs
    .Cast<Object[]>()
    .Select(ae => new ActionErrorLog((ActionLog)ae[0], (Action)ae[1]))
    .ToList();

With the HQL query I recover all the couple Log-Action, then with a simple LINQ to object expression I can create all the object I need.

The only important stuff you need to remember, is that theta join are Inner join, so with the above query you do not find ActionLog where the corresponding action is deleted. I have no problem because I really need to show only result of actions that are still in the table.

alk.

Tags: NHibernate

One of the most basic validation rule for Entities that are stored in databases, is to be sure that String Properties are not too long for the corresponding field in database. There are a lot of validation framework over there, most of them using attributes to specify constraints on properties or fields, but what happens if someone changes a mapping setting a different length for a field?

I’m a great fan of database generation with NHibernate, so here is a typical mapping of mine.

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
                         assembly="DotNetMarche.Validator.Tests"
                         namespace="DotNetMarche.Validator.Tests.Extras.NHibernate">

    <class name="EntityBase" table="EntityBase" lazy="false">
        <id name="Id" column="id" type="System.Int32" unsaved-value="0">
            <generator class="native" />
        </id>

        <property name="MyName" column="code" type="System.String" length="50"/>
        <property name="AnotherProperty" column="name" type="System.String"/>
    </class>

</hibernate-mapping>

This is a class for unit testing a specific routine, it has a property called MyName that have length specified in the mapping, now I want to create a Validator that is able to automatically create rules from the mapping. The goal is automatically find maximum string length from mapping, thus avoiding the extra work to create attributes for each property, and moreover if you change the mapping, the rule changes accordingly. Here is a routing that does this .

public static Core.Validator GetValidatorFromSession(ISessionFactory sessionFactory)
{
    var allDefindedClasses = sessionFactory.GetAllClassMetadata();
    Core.Validator validator = new Core.Validator();
    foreach (KeyValuePair<string, IClassMetadata> pair in allDefindedClasses)
    {
        IClassMetadata metadata = pair.Value;
        foreach (string propertyName in metadata.PropertyNames)
        {
            IType propertyType = metadata.GetPropertyType(propertyName);
            StringType st = propertyType as StringType;
            if (st != null)
            {
                if (st.SqlType.Length > 0)
                {
                    validator.AddRule(Rule.For(metadata.GetMappedClass(EntityMode.Poco))
                        .OnMember(propertyName)
                          .MaxLength(st.SqlType.Length)
                          .Message(String.Format(
                                "Property {0} have a maximum length of {1}",
                                    propertyName,
                                      st.SqlType.Length)));
                }
            }
        }
    }
    return validator;
}

Thanks to IClassMetadata class exposed from Nhibernate, we can inspect the content of mapping browsing nhibernate object model in memory. In this situation I iterate for each mapped class, then for each property I check if it is a String property and look for maximum length. If it is different from zero it means that there is some maximum length specified in the mapping, so I create a corresponding rule. This simple code makes this test pass.

Core.Validator validator = ValidatorFromMetadata.GetValidatorFromSession(Factory);
EntityBase eb = new EntityBase() {MyName = new string('X', 51)};
ValidationResult res = validator.ValidateObject(eb);
Assert.That(res.Success, Is.False);
Assert.That(res.ErrorMessages[0], Is.EqualTo("Property MyName have a maximum length of 50"));

This verifies that the validator reflects rules contained in nhibernate mappings.

alk.

Tags: NHibernate Validation

In a project I’m working with Guardian, we are using NHibernate behind a Repository Pattern. Despite the question if is good or not good to shield the session behind a Repository,we encountered a classic problem.

The software is structured as service, we use Castle Nhibernate Facility and Wcf Integration Facility plus a simple interceptor that manages the concept of “Single session per service call”. Now we are developing some interface in WPF, and this program can dialogate directly with database, without the need to access the db through wcf service. Since we are using MVVM, we makes heavy use of binding, and we like to use lazy load, to keep the logic simple. Instead of returning Dto, a special service class is used to directly return NHibernate persistent object, and if the user want to browse some internal collection of this object we can simply bind the view to entity collection property, and the collection will be fetched when needed with lazy load. Since we have a tree structure this solution is really simple and works really well.

The problem arise because the repository use a single session per call, so when the ViewModel ask for an object, the service return a disconnected object.

This happens because the repository does not have control over the lifetime of the session, it simply open the session, does whatever he need to does with the session, and then Dispose it. Nhibernate Castle integration helps a lot because it keeps track of session reference counting, so if you open a session, and in the same CallContext you open another session, you get a sort of a “weak reference” to the original session. This means that the session gets disposed only when the first created session is disposed.

To use Lazy load in the ViewModel we could simply call ISessionManager.OpenSession() in the constructor of the ViewModel and dispose resulting session in ViewModel Dispose() function. This is not good because it violates repository encapsulation, because you must know how repository is implemented internally.

Moreover it is really ugly to see a nhibernate ISession created in the ViewModel, only to keep session alive, because it vanished all benefit of shielding the ISession behind a repository. A better solution is to create a class like this one.

public class RepositoryScope : IDisposable
{
    private ISessionManager SessionManager { get; set; }
    private ISession Session { get; set; }

    protected RepositoryScope(ISessionManager manager)
    {
        SessionManager = manager;
    }

    #region IDisposable Members

    public void Dispose()
    {
        ///close the most external scope
        Session.Dispose();
    }

    #endregion

    public static RepositoryScope BeginScope()
    {
        RepositoryScope scope = new RepositoryScope(
            IoC.Resolve<ISessionManager>());
        scope.Session = scope.SessionManager.OpenSession(
            ConfigurationRegistry.MainDatabaseConnectionName);
        return scope;
    }
}

This simple class does internally a simple task, it creates a session and dispose in Dispose() method. In this way if you call RepositoryScope.BeginScope() you are actually creating a ISEssion that will be disposed when you will call Dispose() on the RepositoryScope object.

With this simple class the repository remains unchanged, and the caller can manage the lifecycle of repository context, without the need to know his internal implementation.

Alk.

Tags: Castle Nhibernate

When you work with nhibernate you usually write a lot of tests that interact with your database, mainly to test your mapping but also when you do not want to shield the session behind a IRepository. To avoid Slow Test you should use some In Memory database like Sqlite, but it can be problematic when you use features of your real database (like Sql Server) that are not supported by the Sqlite engine.

One of the most frustrating one is the lack of schema support. When you have hundreds of entities, it is of fundamental importance that you use schema, avoiding to pollute the dbo with all the table, but this makes difficult to use Sqlite for testing purpose. Suppose you map an entity to the table myschema.RawMetabaseData, when you create the schema with schemaexport you will obtain this error

Error: Error during fixture setup NHibernate.HibernateException: SQLite error
unknown database myschema ---> System.Data.SQLite.SQLiteException: SQLite error
unknown database myschema

SQlite does not know the concept of schema, so it believes that myschema is a database name and not  a schema. There are some solution to this problem, but the most simple one is to change the mapping directly in memory.

cfg.AddAssembly("myassembly");
foreach (PersistentClass pc in cfg.ClassMappings)
{
    if (pc.Table.Name.Contains("."))
    {
        //this is a table with schema
        pc.Table.Name = pc.Table.Name.Replace(".", "_");
    }
}
ISessionFactory sf = cfg.BuildSessionFactory();

After you have called the AddAssembly() method, but before you create the SessionFactory with BuildSessionFactory(), mappings are compiled in memory, so you can browse the object model created from the xml mapping files, looking for table that contains dot character, and change the dot into an underscore, so the table can be used by Sqlite. This code is executed only for tests that uses SqlLite so my standard test that use Sql Server are not affected by the modification, but I can still use Sqlite to do fast in memory test even with tables in custom schema.

alk.

Tags: NHibernate Sqlite Unit Testing

In a old post I explained how to save an object in XML format in database with a UserType. Since this technique worked well I decided to use it in another situation. Now I have an object that have a property of type Object, and I want to be able to save xml serialiation of it into database.

First of all I decided that it is better to use two columns, one will store the xml serialization, while the other will contain type name of the object, so I build a simple ICompositeUserType

public class XmlSerializedObject : ICompositeUserType
{
    #region Equals member

    bool ICompositeUserType.Equals(object x, object y)
    {
        return (x == y) || ((x != null) && x.Equals(y));
    }

    #endregion

    #region ICompositeUserType Members

    public object Assemble(object cached, NHibernate.Engine.ISessionImplementor session, object owner)
    {
        return cached;
    }

    public object DeepCopy(object value)
    {
        if (value == null) return null;
        if (value is ICloneable) return ((ICloneable) value).Clone();
        throw new NotSupportedException(
            String.Format(
                "You can use XmlSerializedObject only to serialize ICloneable objects. Type {0} does not support ICloneable",
                value.GetType()));
    }

    public object Disassemble(object value, NHibernate.Engine.ISessionImplementor session)
    {
        return value;
    }

    public int GetHashCode(object x)
    {
        return x.GetHashCode();
    }

    public object GetPropertyValue(object component, int property)
    {
        //0 is the object and 1 is the type.
        if (property == 0) return component;
        return component.GetType().FullName;
    }

    public bool IsMutable
    {
        get { return true; }
    }

    public object NullSafeGet(System.Data.IDataReader dr, string[] names, NHibernate.Engine.ISessionImplementor session, object owner)
    {
        if (dr == null) return null;
        if (dr.IsDBNull(dr.GetOrdinal(names[0]))) return null;

        String serializedData = (String) dr[names[0]];
        Type serializedType = Type.GetType((String)dr[names[1]]);
        return XmlHelper.FromXml(serializedData, serializedType);
    }

    public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index, NHibernate.Engine.ISessionImplementor session)
    {
        if (value == null || value == DBNull.Value)
        {
            NHibernateUtil.String.NullSafeSet(cmd, null, index, session);
            NHibernateUtil.String.NullSafeSet(cmd, null, index + 1, session);
        }
        else
        {

            String typeName = TypeUtils.GetTypeNameAssemblyQualified(value);
            NHibernateUtil.String.NullSafeSet(cmd, XmlHelper.ToXml(value), index, session);
            NHibernateUtil.String.NullSafeSet(cmd, typeName, index + 1, session);
        }
    }

    public string[] PropertyNames
    {
        get { return new []{"XmlData", "Type"}; }
    }

    public NHibernate.Type.IType[] PropertyTypes
    {
        get { return new [] {NHibernateUtil.String, NHibernateUtil.String}; }
    }

    public object Replace(object original, object target, NHibernate.Engine.ISessionImplementor session, object owner)
    {
        return original;
    }

    public Type ReturnedClass
    {
        get { return typeof (Object); }
    }

    public void SetPropertyValue(object component, int property, object value)
    {

    }

    #endregion
}

It works quite well, but it has some drawbacks. First of all since this property is mutable, the object must implement ICLoneable to create a copy of it. This fact has another implication, when the session flushes, NHibernate calls Equals to verify if actual instance is changed from the time it was loaded, now since the copy used to keep the original value is created with Clone, if the object does not implement equals, it would be always considered different from the copy in the cache, and it will be saved at each flush. To avoid this, all objects used in this property must implement equals.

The rest of the code is quite simple. This userType gives me great flexibility, moreover, since the database have mixed access stored+nhibernate, I used a Xml column in sql server, so I’m able to do XPath query in my stored.

Alk.

Tags: NHibernate

I have a project that uses both nhibernate and StoredProcedures, based on a legacy project written without nhibernate. Today I need to load a lot of data from five tables. The problem is that all these tables are managed with nhibernate, but I have no relation between them. Moreover these tables have a lot of objects, and I need to retrieve only 10 objects at a time with pagination, but I cannot express pagination in nhibernate, because I have condition that must be satisfied on tables that are not mapped.

I decided to create a new class that stores some basic data taken from two of these five tables, then add three properties to create relation with other three. The real objects that manage those three tables are not related because there is not foreign key in tables, but there are some business rules, expressed with stored procedure, that relates them all.

Thanks to SQlQuery I created a stored that accepts three parameters, it paginates record server-side with temp tables, and it is superfast. Then I begin to think how to map it into nhibernate. Moreover in client code I do not access directly the ISession, because the NHibernate layer was based on a previous query model… (that sooner or later will be dropped to permits direct access to ISession=, but for now all legacy nhibernate layer uses this custom query model, so I have no way to remove it.

Moreover, since I need to join tables, if I ask for 10 records, actually the stored returns higher number of records, because it returns 10 records from the base table, but after joins with other tables the number of returned records is greater than 10. I made the stored so it returns rows from all five tables, and I create all foreign key directly in the stored, now I’m able to write code like.

DirectSqlQuery query = DirectSqlQuery.Create("fictiousEntity", "root")
    .SetInt32("clieid", customerId)
    .SetInt32("startindex", startIndex)
    .SetInt32("maxresult", maxResults)
    .AddJoin("fetchTargets", "root.Targets")
    .AddJoin("fetchAnalyzedLink", "root.AnalyzedLink")
    .AddJoin("fetchExtData", "fetchAnalyzedLink.ExtData")
    .SetResultTransformer(new DistinctResultTransformer(0));
var result = UnitOfWorkBaseDbDao<fictiousEntity>.GetByCriteria(query);

entity called fictiousEntity is used only to join data from two base tables and contains relations with other three tables, then I tell to ISQlQuery that in resultset there are all the columns to rebuild other related entities with AddJoin. Finally I use a DistinctResultTransformer to take only the first element of the tuple. When you use AddJoin(), NHibernate does not return an object for each row in the resultset, but instead returns one object for each join. (see this figure)

This is a snapshot of the TransformTuple of my DistinctResultTransformer object, that simply takes the object whose index was specified in constructor. So when I wrote SetResultTransformer(new DistinctResultTransformer(0)) I’m asking to return only the first element, that was my fictiousEntity used to aggregate the result.

Since I specified to NH that all data is included in the original recordset, entities are fully hydrated without N+1 Select problem. With this simple trick I’m able to retrieve data from a stored in a really high efficient way, while maintaining full power of NHibernate, because except the fictiousEntity that is mutable=”false”, and is used only for aggregation, all related classes can be used as usual with full persistence power.

alk.

Tags: NHibernate

Xml fields in sql server are really useful, you can use xpath or xQuery to filter and impose condition on part of the xml fragment. Today we decided to store some data in an XML field of a table, and since this table was accessed both by nhibernate and both from T-Sql code, I begin to think on how to map this situation on NHibernate.

I immediately think to a usertype that is able to store data using XMLSerialization, here is the class, It took to me 10 minutes to create it,

public class XmlFieldUserType<T> : IUserType where T : ICloneable
{
    #region Equals member

    bool IUserType.Equals(object x, object y)
    {
        return (x == y) || ((x != null) && x.Equals(y));
    }

    #endregion

    #region IUserType Members

    public object Assemble(object cached, object owner)
    {
        return cached;
    }

    public object DeepCopy(object value)
    {
        if (value == null) return null;

        return ((T)value).Clone();
    }

    public object Disassemble(object value)
    {
        return value;
    }

    public int GetHashCode(object x)
    {
        return x.GetHashCode();
    }

    public bool IsMutable
    {
        get { return true; }
    }

    public object NullSafeGet(System.Data.IDataReader rs, string[] names, object owner)
    {
        Int32 index = rs.GetOrdinal(names[0]);
        if (rs.IsDBNull(index))
        {
            return null;
        }

        return XmlHelper.FromXml<T>((String)rs[index]);
    }

    public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index)
    {
        if (value == null || value == DBNull.Value)
        {
            NHibernateUtil.String.NullSafeSet(cmd, null, index);
        }
        else
        {

            NHibernateUtil.String.Set(cmd, XmlHelper.ToXml(value), index);
        }

    }

    public object Replace(object original, object target, object owner)
    {
        return original;
    }

    public Type ReturnedType
    {
        get { return typeof(Uri); }
    }

    public NHibernate.SqlTypes.SqlType[] SqlTypes
    {
        get { return new SqlType[] { NHibernateUtil.String.SqlType }; }
    }

    #endregion
}

I use a simple XmlHelper class that serialize to and from XML string, and thanks to this class writing the usertype is a breeze, since Xml serialization needs to know the type of the class you operate with, this user type is generic, here is a typical use.

<property name="DetailData"
          type="NHibernateExt.XmlFieldUserType`1[[MyProject.DetailData, MyProject]], NHibernateExt"
           column="link_detail" />

This is the standard way to specify a class with generics. Now when I save the class here is the SQL generated.

INSERT INTO MyTable (link_url, link_sha256, link_target_id, link_details) VALUES (@p0, @p1, @p2, @p3); select SCOPE_IDENTITY(); @p0 = 'http://www.nablasoft.com', @p1 = 'BD827105DDFBEE299C04B461A322FFC21A1CC919D2FDB5A3E1CCC78B3D3BF93F', @p2 = '0', @p3 = '<DetailData
  UserName="Alkampfer"
  Title="Nablasoft HomePAge"
  Description="Not avaliable"
  Category="MySite">
  <Tags>one</Tags>
  <Tags>two</Tags>
  <Tags>three</Tags>
</DetailData>'

Now I can simply use the DetailData property of the class, working with a full object, but when the object gets saved, the DetailData property is simply serialized into an xml stream.

alk.

Tags: nhibernate Xml Serialization

Using Bidirectional Associations in nhibernate can be tricky, the problem is that you need to manage associations for both ends. This is really important: suppose you have a class called Parent with a collection of childs called Childs, and a child class with a property called Parent; if you expose these two property to the user, you can write this

Parent John = new Parent();
Parent Mark = new Parent();
Child Bart = new Child();

John.Childs.Add(Bart);
Bart.Parent = Mark;

With such a code Bart’s parent is Mark, but Bart is in John Child collection, this is WRONG. To avoid this problem you should maintain integrity in the domain model, managing the consistency of the relationship. Suppose you have the same situation with two objects, a StockKeepingUnit and a StockContainer, here it is the code for StockKeepingUnit

 public virtual StockContainer Parent
 {
    get { return parent;}
    set
    {
       if (parent != null)
          parent._Content.Remove(this);

       parent = value;

       if (value != null)
          value._Content.Add(this);
    }
 }

 private StockContainer parent;

As you can see in the setter part I first check if this object has a parent, if yes we need to remove it from the _Content collection of the parent object (because actually I’m detatching from it); then if the value is different from null it means that we have a new parent, so the object assign itself to the _Content collection of the new father to mantain integrity. Surely you now need to map this property in directly on the field to avoid problem

<many-to-one name="parent" access="field" class="StockKeepingUnit" ... />

It is of fundamental importance that you map to the field, this because when nhibernate rebuild the object from database, you must avoiding calling the Set part of the Parent property, because the coherence of the objects are guaranteed by nhibernate itself. Now here is how I implemented the Collection part on the SockContainer class

 public virtual IEnumerable <StockKeepingUnit> Content
 {
    get { return _Content;}
 }

 internal virtual ISet<StockKeepingUnit> _Content
 {
    get
    {
       return content ?? (content = new HashedSet <StockKeepingUnit>());
    }
    set
    {
        content = value;
    }
 }
 private ISet<StockKeepingUnit> content;

First of all the ISet class is a private field, and the accessor property, called _Content, is internal because it must be accessed by the StockKeepingUnit code seen before, but must not be accessed from external code. The property is implemented with lazy creation, if the content property is null, I simply create an HashedSet, this is useful when you first create the object, because initially this property is null. When nhibernate rebuild the object from database data, the content private field is set by nhibernate, so I can avoid unnecessary creation of HashedSet. With this kind of structure you can map nhibernate to the _Content property and not to the field.

Now a question arise: How can the user of this class access the Collection of StockKeepingUnit if the _Content property is private? The answer is in the property Content that is of type IEnumerable<StockKeepingUnit>. With Ienumerable I permit the user to use fully LINQ syntax to access collection of StockKeepingUnit, this is enough for most scenarios because with LINQ you can iterate, filter, select and doing whatever you want to access all StockKeepingUnit contained in a stockContainer.

Alk

Tags: NHibernate Domain Model

Suppose you have a legacy database, and an entity called ViewOfBaseData that have this id.

 <composite-id class="ViewOfBaseDataId" name="Id"  >
    <key-many-to-one class="LinkResult" name="Link" column="AnalysisId" lazy="proxy" />
    <key-property name="AnalysisDate" type="System.DateTime" column="AnalysisDate" />
 </composite-id>

Now suppose you need to retrieve all object ViewOfBaseData linked to a LinkResult object with a property KeyList equal to a certain value. In HQL is really simple

select v from ViewOfBaseData v where v.Id.Link.KeyList = 'blabla'

Resulting SQL query is a simple join between the two tables, but now suppose you cannot use HQL and instead you are forced to use ICriteria, you can try this one.

ICriteria c = uow.TheSession.CreateCriteria(typeof(ViewOfBaseData ))
 .CreateCriteria("Id").CreateCriteria("Link")
               .Add(Expression.Eq("KeyList", "blabla"));

But this failed with the error: no such column: linkresult2_.keyList , if you look at the SQL query issued to the database, you can verify that the query does not contain the join with the table for LinkResult entity. If you change the constant “blabla” with the integer 10 you will obtain the error Type mismatch in NHibernate.Criterion.SimpleExpression: KeyList expected type System.String, actual type System.Int32 thus confirming me that the path is specified correctly.

If you examine the inner metadata of the session you can find that the composite id ViewOfBaseDataId is a ComponentType and probably internally, when the engine that build sql query verify that Id property of ViewOfBaseData is a componentType determines that each column is contained in the base table. I do not know if it is a bug of nhibernate or if there is another way to specify the criteria, but if you absolutely need not to use HQL you can use DetatchedCriteria

ICriteria c = uow.TheSession.CreateCriteria(typeof(ViewOfBaseeData), "root");

DetachedCriteria dc = DetachedCriteria.For(typeof (LinkResult))
   .Add(Expression.Eq("KeyList", "blabla"))
   .SetProjection(Projections.Property("Id"))
   .Add(Property.ForName("Id").EqProperty("root.Id.Link.Id"));

c.Add(Subqueries.Exists(dc));
c.List();

This generates the following query

SELECT this_.AnalysisId as AnalysisId98_0_, this_.AnalysisDate as Analysis2_98_0_, ...
FROM ViewOfBaseData this_ WHERE exists (SELECT this_0_.Id as y0_ FROM LinkResult this_0_
WHERE this_0_.keyList = @p0 and this_0_.Id = this_.AnalysisId); @p0 = 'blabla'

From the point of view of performance, probably this query is worst than a direct join, but it works

alk.

Tags: NHibernate ICriteria

Today I received a strange “null identifier” error when saving an object to db with nhibernate. Immediatly I realize that this error is caused by a Trigger INSTEAD OF INSERT, that apperars to broke the SCOPE_IDENTITY() function. Since NHibernate uses SCOPE_IDENTITY() to retrieve the id of the generated object, when you use INSTEAD OF INSERT Trigger the SCOPE_IDENTITY() returns null, and nhibernate could not know the value of the inserted record.

I first tried to specify with <sql.insert> the query to use, to make use of @@identity, but it does not work. After some time I discovered a issue that was fixed only in the trunk. My only solution was removing the trigger (fortunately I can do it) because nhibernate does not permits me to use <sql-insert> with entities that use identity to generate ids.

Another good reason not to use identity with nhibernate, but my project is a legacy one where a lot of operations are massive ones performed by stored procedure.

alk.

Some time ago I posted a link about a user type to store list of strings in a single database field. In a project of mine I have another usertype very similar, that stores list of integers into a single string database field in a # separated value, like #1#8#23# (note that the character # appears at the begin and the end of the string). Now Suppose you need to made some query on it like “select all Domains where activeCustomerList is not empty and contains at least one id:

IList<Domain> res = session
.CreateQuery("from Domain D where D.ActiveCustomerList != \"\"")
.List<Domain>();

In HQL the criteria needs to be expressed in string format, so I simply check for domain where the ActiveCustomerList is not an empty string, if you need to use Criteria API the situation is little different.

IList<Domain> res = session.CreateCriteria(typeof(Domain))
   .Add(Restrictions.Not(
      Restrictions.Eq("ActiveCustomerList", new List<Int32>())))
      .List<Domain>();

With criteria API you need to specify that you want the field not to be equal to a real empty string of IntegerList. This happens because the Criteria API works on the model on the entity, so if the property is of type List<Int32> for an equality operator it need to compare it with the result of applying the UserType to the Empty Integer List. In HQL you can also express some interesting query, as for example “All domains that contains and active customer with ID 9”

IList<Domain> res = session
.CreateQuery("from Domain D where D.ActiveCustomerList like '%#9#%'")
.List<Domain>();

This is  a simple like operator, the only problem is that the % at the begin and the end of the like will makes any index ineffective, so the query can be slow for a high number of record. Doing this with Criteria API is probably impossible because the Like Restriction accepts only strings, and we have no way to pass a sample object. I’ll keep investigating but for now I’m using the HQL version

alk.

Tags: NHibernate

Today I received a log of an error in a windows service that runs some scheduled actions, the error was TooManyRowsAffectedException and it is thrown by nhibernate when a session is flushed. The exact message said Unexpected row count: 2; expected: 1 , after a little moment of confusion I immediately realize that the problem is due to a trigger.

I modified a table to keep a log of all modifications of every row, and I did this with a simple trigger that, for each update, saves the last value of each modified row in an history table. Since the trigger runs in the same context of the update operation, when you update a row, the trigger fired, insert a row in history table and the whole update operation returns 2 as the number of affected rows. NHibernate check the affected row count to verify that the row was really updated by the UPDATE statement, when he saw a rowcount of 2 he throws exception because something was wrong since it issue an update of a single row.

The obvious solution is to issue a SET NOCOUNT ON at the beginning of the trigger and a SET NOCOUNT OFF at the end. This is a good practice, because in this way the trigger does not affect the number of affected rows. After all the trigger should be completely transparent to the application, and this is the best way to achieve this result.

alk.

Tags: NHibernate Triggers

One of the first improvement to the WCF logger is the ability to choose the list of logger to monitor during registration. A real application can generate tons of logs, suppose you are interested only in looking at the NHibernate generated query. The solution is to add another registration method and internally use an object that keeps care of the registration and senting log progress. Here is the new interface

[ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(IL4NClient))]
public interface IL4NServer
{
    [OperationContract]
    Boolean Register();

    [OperationContract]
    Boolean RegisterForSpecificLogger(params String[] loggerNameList);
}

Now I can choose the name of the logger I’m interested to filter messages log.

But this is not the only improvement I need. Quite often it happens that developer X called you telling “When I press the button Y the application responds after 20 seconds”, then you see with the SQL profiler that tons of query gets issued to the database. For a layered and complex application it can be difficult to understand where that queries are issued in the code, so I need a way to get a valid stack trace from the logger. To accomplish this task I modified the LogMessage object

[DataContract]
public class LogMessage
{
    [DataMember]
    public String Message { get; set; }

    [DataMember]
    public List<StackStep>  StackSteps { get; set; }

    public LogMessage()
    {
        StackSteps = new List<StackStep>();
        StackTrace trace = new StackTrace(true);
        var interestingFrames = from StackFrame frame in trace.GetFrames()
                                where frame.GetMethod().DeclaringType.Assembly.GetName().Name != "LiveLogger4Log4Net"
                                      && frame.GetMethod().DeclaringType.Assembly.GetName().Name != "log4net"
                                                && frame.GetFileLineNumber() != 0
                                select new StackStep()
                                           {
                                               SourceFile = frame.GetFileName(),
                                               LineNumber = frame.GetFileLineNumber()
                                           };
        StackSteps.AddRange(interestingFrames);
    }
}

First I have inserted in the message a list of stacksteps, a class that contains filename and line number, in the constructor of the message I use the StackTrace .NET class to obtain the stack trace, then I do a linq query to remove all the steps that have no source file or are part of my logging system. The result is really interesting.

Not only I’m able to intercept NHibernate generated SQL, but I have a full stack trace that tells me where the query is generated, now the next step is to build a better client interface to present the result in a more usable and readable form.

alk.

Tags: log4net NHibernate

I have a little project based on NSK, it uses a query model to abstract the caller from nhibernate. Despite the reason for having or not a Query Model, I expanded the base translator to translate my Query object into a NHIbernate ICriteria.

To make this translation you need to create alias, if I you create a query for the order object and setup a constraint for Customer.Name, the ICriteria tells you that the Order object does not have a property called Customer.Name. This can be easily accomplished using Alias, but only if the object is mapped as an entity and not as a component.

If the customer has an Address of type Address mapped as a component and you create a constraint for the property Customer.MainAddress.Number, we need to create only an alias for Customer (because is an entity). This means that my translator has to distinguish between entities and components. The solution to these kind of problems can be solved inspecting metadata mapping for nhibernate.

I created a class that handle alias creation

CriteriaAliasTranslator cat =
new CriteriaAliasTranslator(
_session.SessionFactory.GetAllClassMetadata(), _rootType);

This translator needs only the type of the root object, and a dictionary of all types metadata, obtained from the method GetAllClassMetadata() from the SessionFactory object.

Then for each dotted constraint found in the query object, I pass it to this alias translator

public String AddAlias(String fullpath)
{
    String[] path = fullpath.Split('.');
    String CurrentAliasPath = path[0];
    String ReturnValue = path[0];
    Type currentType = baseType;

    for (Int32 I = 0; I < path.Length - 1; ++I)
    {
        IEntityPersister mapping = (IEntityPersister) mappingMetadata[currentType];
        if (mapping.GetPropertyType(path[I]) is ComponentType)
        {
            for (Int32 innerI = I+1; innerI < path.Length; ++innerI)
                ReturnValue += "." + path[innerI];
            return ReturnValue;
        }

        ...

I split the string with “.” character, then cycles through all the part of the property, and for each property I first check from the metadata if this is a component or not. If is a component than I can return from the function, because I do not need to create alias for components. The IEntityPersister interface stores all information for a type, then with the GetPropertyType you can get the NHibernate type of the property; to verify if the property is a component you can check with the is operator against the ComponentType.

If the component is an entity, then I go through the standard path, and store the aliases into a dictionary. When all the properties of the query gets translated I call the method CreateAlias() of the CriteriaAliasTranslator, that cycles through all values from the alias dictionary, and call create alias on the real ICriteria object.

A lot of thanks to Marco that originally told me this problem. In this little project I never used query model with components, so I never hit it. Marco created another querymodel, and when we made some confrontation he told me “Hey, you have this bug” , thanks again.

alk.

Tags: NHibernate Mapping Metadata

If you do not mind to issue a delete for each object, you can delete multiple objects using an overload version of the ISession.Delete() Method, here is an example.

uow.Session.Delete("select A from ActionSpawned A where A.ParentAction = :act",
 ParentAction, NHibernateUtil.Entity(typeof(Action)));

The code is quite concise, you specify the query to select a series of object, and pass it to the Delete method of the ISession, along with the parameters of the query. The result is that NHibernate executes the query, loads all objects and deletes each one.

If you have to delete a really great amount of objects, you can resort to use direct SQL to obtain greater performance, since all objects are deleted in a single roundtrip

Object result = theSession.CreateSQLQuery("DELETE from SchedulerAction where acti_parent = :act")
    .AddScalar("count", NHibernateUtil.Int32)
    .SetParameter("act", act1.Id)
    .UniqueResult();

With this query you can issue a very efficient DELETE instruction, but remember that you have to specify the real table and columns names, so you lose the advantage to abstract the model from the database. The above query returns null, because the delete instruction does not select any data, if you want to know the number of deleted row you can use

Object result = theSession.CreateSQLQuery("DELETE from SchedulerAction where acti_parent = :act ; select @@ROWCOUNT count;")
    .AddScalar("count", NHibernateUtil.Int32)
    .SetParameter("act", act1.Id)
    .UniqueResult();

alk.

Tags: NHibernate, Bulk Operation

I have an object that has 4 properties of IList<String> type. You can natively map these properties in a separate table with this simple mapping

<bag name="keys" access="field" cascade="all-delete-orphan" table="Keys" fetch="join">
    <key column="deps_id" />
    <element column="deps_key" type="String" />
</bag>

Ok, this is a simple mapping that store all the keys into another table with two columns, one is the foreign key to the main object, the other is a string column to store the data. But a similar mapping does not satisfy me, because I need to create 4 more table to store string coming from my 4 IList<String> properties…too bad.

The solution is…again….IUserType. The solution is store the strings in a single column, combining the strings in one with a separator that does not happens to be part of any string, as an example, if the collection contains (“Key1″, “Key2″) I want to be stored as “Key1#Key2″, here is the get part of the usertype

public object NullSafeGet(System.Data.IDataReader rs, string[] names, object owner)
{
    List<String> result = new List<String>();
    Int32 index = rs.GetOrdinal(names[0]);
    if (rs.IsDBNull(index) || String.IsNullOrEmpty((String) rs[index]))
        return result;
    foreach (String s in ((String)rs[index]).Split(cStringSeparator))
        result.Add(s);
    return result;
}

If the data in database is null, or is an empty string I return an empty List<String>, but if the data is not empty I split the string with the separator, and then add each single string in the list. The set part is similar

public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index)
{
    if (value == null || value == DBNull.Value)
    {
        NHibernateUtil.String.NullSafeSet(cmd, null, index);
    }
    IEnumerable<String> stringList = (IEnumerable<String>) value;
    StringBuilder sb = new StringBuilder();
    foreach(String s in stringList) {
        sb.Append(s);
        sb.Append(cStringSeparator);
    }
    if (sb.Length > 0) sb.Length--;
    NHibernateUtil.String.Set(cmd, sb.ToString(), index);
}

If the value is null I set null value, if not I simply cast the original value as an IEnumerable<String>, that is sufficient for me to enumerate all the string, store them in a StringBuilder, and finally remove the trailing separator and store the string in database. Here is a Test

...
Domain d = new Domain();
d.BaseUri = new Uri("http://www.nablasoft.com");
d.ContentBlackList.Add("Key1");
d.ContentBlackList.Add("Key2");
...

This piece of code produces this SQL

INSERT INTO Domain (doma_baseUrl, doma_contentBlackList, doma_Id)
VALUES (@p0, @p1, @p2);
@p0 = 'http://www.nablasoft.com/', @p1 = 'Key1#Key2', @p2 = '28857095-f642-4d11-875a-714eb35f0537'

As you can see the Uri is translated into a string and the two keywords are combined into one, in this way I can store all the 4 properties in the same table, having a clearer structure of the database.

alk.

Tags: NHibernate IUserType

Ok, today I faced a really simple problem, I have a domain class with a property of type uri, that seems to be not natively supported by NHibernate. Whenever you face a problem of this type the solution is IUserType, here is the full file, it is so simple to write a user type that I really does not check with google, after I write my class I found that other people had already created it, but it is worth to take a look to some particular piece of code.

public object NullSafeGet(System.Data.IDataReader rs, string[] names, object owner)
{
    Int32 index = rs.GetOrdinal(names[0]);
    if (rs.IsDBNull(index))
    {
        return null;
    }
    try
    {
        return new Uri(rs[index].ToString());
    }
    catch (FormatException)
    {
        //The uri is malformed, maybe it is worth to doing something else.
        return null;
    }
}

The NullSafeGet is called to retrieve the value from database columns in a null safe way, first of all get the index of the data into resultset, then check if it is null, (if is null return null is ok) then if some data is contained into the resultset you can try to create the uri trapping the FormatException. If you prefer you can call Uri.TryCreate that probably is a better solution respect trapping the exception

public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index)
{
    if (value == null || value == DBNull.Value)
    {
        NHibernateUtil.String.NullSafeSet(cmd, null, index);
    }
    Uri uri = (Uri)value;
    NHibernateUtil.String.Set(cmd, uri.AbsoluteUri, index);
}

The NullSafeSet has the duty to transform data from the original .net type (Uri) to something that can be stored in database, since I need to work only with AbsoluteUri, I store into the database the AbsoluteUri value or the Uri. Then we need to tell nhibernate the types involved

public Type ReturnedType
{
    get { return typeof(Uri); }
}

public NHibernate.SqlTypes.SqlType[] SqlTypes
{
    get { return new SqlType[] { NHibernateUtil.String.SqlType }; }
}

The ReturnedType tells nhibernate the .Net type handled by this UserType, the SqlTypes is used to tell nhibernate the structure of the data in the table, in this example a string is sufficient to store the AbsoluteUri and so I returned an array with only a string type.

alk.

Tags: NHibernate UserType Uri and NHibernate

Look at this mapping

<bag name="searchDefinition" access="field" cascade="all-delete-orphan" table="RawSearchDefinition" fetch="join">
    <key column="ParentObjectId" />
    <composite-element class="RawSearchDefinition">
        <property name="ExcludeKeyword" column="raws_excludeKeyword" type="String" />
        <property name="IncludeKeyword" column="raws_includeKeyword" type="String" />
    </composite-element>
</bag>

It seems ok but it has a subtle error, when you try to save the object,  a “collection was not an association” error will arise. This error is derived from the cascade=”all-delete-orphan”, this attribute is used for real entity object not value ones. A mapping with composite element does not need cascade, the RawSearchDefinition is a value object, its lifecycle will span that of the owner.

The solution is simply to remove cascade attribute, that is not required.

alk.

Tags: NHibernate

When you work with legacy database is not infrequent that boolean value are mapped to char(1) field in databse, with Y/N or 0/1 or some other chars. In the literature there are a lot of solution, you can find for example a discussion here. When you use a user type to handle this kind of situation when you build HQL query you cannot use true or false in condition, for example

Select o from Orders where o.IsProcessed = false

This usually lead to a SQL error because you are trying to compare a char(1) column with the value false. The solution is to use this setting in the setting file.

<add key="hibernate.query.substitutions" value="true 1, false 0" />

This permits to substitue the value true with the literal 1 and false with the literal 0,  but you can use whatever constant you want.

Alk.

Tags: NHibernate Boolean To Char Mapping

Today in a project I need to delete a lot of object from a table, the objects are instances of ActionLog and I want to delete all logs related to action when an action is deleted.

The problem is that nhibernate does not still support batch query as hibernate for java does (as explained in hibnernate in action). So I was forced to do a direct sql query.

uow.Session.CreateSQLQuery("Delete from SchedulerActionLog where aclg_ActionId = :actId")
   .AddScalar("count", NHibernateUtil.Int32)
   .SetInt32("actId", actionDto.Id)
   .UniqueResult();

This does not like me very much since with sqlquery you are actually bypassing the mapping and dialect. Today I’ve no time, but if someone knows a better solution please let me know

Alk.

One of the most feared missing feature of the ICriteria API is the possibility to specify condition on projection with Having. Suppose you have this simple connection between a container and a contained object,

The EntityContainer class has a property called Test, is an IList<EntityTest> and EntityTest has a Container property to link back to the container. This is the classic bidirectional association. Now we want to express with ICriteria API the following query

Select all EntityContainer that have more than one EntityTest in the Test collection

And I want to solve this problem using both the direction of association, I mean two criteria, one that use the many-to-one and the other that use the <bag> part. This is important because bidirectional association is not always the best solution, so it is possible to have a domain where the association is unidirectional.

Using the many-to-one part

ICriteria c = session.CreateCriteria(typeof(EntityContainer), "RootClass");

NEX.DetachedCriteria d = NEX.DetachedCriteria.For(typeof(EntityTest))
    .SetProjection(NEX.Projections.RowCount())
    .Add(NEX.Property.ForName("Container").EqProperty("RootClass.Id"));

//You can use also
//.Add(NEX.Expression.EqProperty("Encontained", "RootClass.Id"));

c.Add(NEX.Subqueries.Lt(1, d));
IList<EntityContainer> result = c.List<EntityContainer>();

The result is achieved using a DetatchedCriteria and a subquery, the detatched criteria is on the EntityTest class, set a simple count projection and set the join with the original query with a Expression.EqProperty. Once the DetatchedCriteria is build I simply add it to the root Criteria using the Subqueries.Lt (Less Than). Here is the SQL

SELECT this_.Id as Id2_0_, this_.PStr as PStr2_0_, this_.RegDate as RegDate2_0_
FROM EntityContainer this_
WHERE
  @p0 < (SELECT count(*) as y0_
              FROM EntityTest this_0_
              WHERE this_0_.ContainerId = this_.Id); @p0 = '1'

The code is quite good, I simply use a subquery to calculate the number of EntityTest associated to the object and I take the EntityContainer if this value is greater than 1. (Actually the syntax force me to use 1 is less than count )

Using the <bag> part

This is more difficult, because the direction of the association is from EntityContainer to EntityTest so the detatched criteria should be on EntityContainer.

ICriteria c = session.CreateCriteria(typeof(EntityContainer), "RootClass");

NEX.DetachedCriteria d = NEX.DetachedCriteria.For(typeof(EntityContainer))
    .CreateAlias("Tests", "Tests")
    .SetProjection(NEX.Projections.ProjectionList()
        .Add(NEX.Projections.RowCount()))
    .Add(NEX.Property.ForName("Id").EqProperty("RootClass.Id"));

c.Add(NEX.Subqueries.Lt(1, d));
IList<EntityContainer> result = c.List<EntityContainer>();

The solution is simple, I call CreateAlias to make the join with EntityTest through the Tests collection, add the projection rowCount and simply join with the original criteria with the EqProperty Id == RootClass.Id

Here is the sql generated

SELECT this_.Id as Id18_0_, this_.PStr as PStr18_0_, this_.RegDate as RegDate18_0_
FROM EntityContainer this_
WHERE @p0 <
(SELECT count(*) as y0_
FROM EntityContainer this_0_ inner join EntityTest tests1_ on this_0_.Id=tests1_.ContainerId
WHERE this_0_.Id = this_.Id); @p0 = '1'

And the game is done

Alk.

Thanks to my friend Janky for notice that I made a mistake in a previous post. In that post I speak about a “conversation” but actually I was describing a UnitOfWork, that was my fault. The exact definition of a conversation is given in “Hibernate In Action” where Gavin King states that.

“We call a unit of work that completes in several client/server request and response cycles a conversation“.

So a conversation is really a unit of work, but more complex than a standard one because it span several request, and naturally it use more than one NHibernate session.

Thanks again to janky for making me notice the error.

Alk.

When you begin to work with an ORM you encounter the concept of conversation, a conversation is the analogous of a transaction for database code, in a conversation I must be able to make a dialog to the ORM using the same context. In database there is no such concept, but I like it, and since sometimes I need to share nhibernate code and standard sql code in the same project I wish to be able to create a “conversation” that spans direct database access and nhibernate code. Basically a conversation has these properties

• All operation done into a conversation are transactional
• Inside a conversation Nhibernate share the same connection used by direct SQL code
• Inside a conversation I must use the same Nhibernate session.
• Code must be unaware of the presence of a conversation, this means that the code should not matter if we are in or outside a conversation

The first class I create is the Conversation, a class that takes care of the creation of the connection, session, transaction and so on. This class should implement IDisposable so I can use the semantic of using keyword that is really useful.

   public class Conversation : IDisposable {
 
      private DbConnection mConnection = null;
      private DbTransaction mTransaction = null;
      private ISession mSession = null;
      private Boolean mIsDirty = false;
 
      internal virtual DbConnection Connection {
         get {return mConnection ?? (mConnection = CreateConnection());}
      }
 
      internal virtual DbTransaction Transaction {
         get {return mTransaction;}
      }
 
      internal virtual ISession Session {
         get {return mSession ?? (mSession = SessionManager.CreateNewSession(Connection));}
      }

      public virtual void MarkDirty() {
         mIsDirty = true;
      }
 
      public virtual void Close() {
         try {
            if (!mIsDirty)
               mTransaction.Commit();
         }
         finally {
            mTransaction.Dispose();
            Session.Dispose();
            mConnection.Dispose();
         }
      }
 
      public void Dispose() {
         Close();
      }
    }
}

This class creates a connection when needed, it does the same thing with the Nhibernate session, using a session manager that inject code into nhibernate session. It is disposable, and when dispose is called the transaction will be committed if no one had called the ISDirty() method. If you want to rollback the conversation simply call IsDirty() method and when the conversation will be closed, all operations will be rolled back. Now we need a static class called ConversationManager to keep track of the concept of “Current Conversation”

BeginConversation() will return a conversation object and since it is diposable you can use code like this.

using (Conversation conv = ConversationManager.BeginConversation()) {
   //do your access code here using conv.Transaction or conv.Session
}

When code wants to access a database and wish to be enlisted in a Conversation, it should call ConversationManager.GetConversation(), this return a reference to the current conversation.

using (Conversation conversation = ConversationManager.GetConversation()) {
   //do your access code here using conv.Transaction or conv.Session
}

To make this code work The GetConversation() function in the ConversationManager class should not return a direct reference to the current conversation, because the caller code will dispose it before the conversation is really ended, so I use a weak reference.

public class ConversationWeakReference : Conversation {
 
   private Conversation mOriginal;
   public ConversationWeakReference (Conversation original) {
      mOriginal = original;
   }
 
   public override System.Data.Common.DbConnection Connection {
      get {return mOriginal.Connection;}
   }
 
   public override global::NHibernate.ISession Session {
      get {return mOriginal.Session;}
   }
 
   public override System.Data.Common.DbTransaction Transaction {
      get {return mOriginal.Transaction;}
   }
 
   protected override void Close() {}
}

As you can see this class Inherit from a Conversation and wraps the real Conversation, but override the CloseMethod with a no op method. This means that when a ConversationWeakReference gets disposed the real conversation still remain open. The key is in the GetConversation() method of the ConversationManager.

public static Conversation GetConversation() {
   Conversation current = GetFromStorage();
   return current == null ? new Conversation() : new ConversationWeakReference(current);   
}

As you can notice the ConversationManager check if there is an active Conversation, and returns a new conversation or a new conversationWeakReference if there is an active conversation. With this trick if the caller is in a ConversationScope he will get a weak reference, but if the code is not in a conversation it will obtain a full conversation object that gets committed at the end of the scope. Real code has some more check but this is the general idea. Basically if we are not in a Conversation the code

using (Conversation conversation = ConversationManager.GetConversation()) {
   //do your access code here using conversation.Transaction or conversation.Session
}

creates a new conversation that gets closed at the end of the scope, actually committing all work. But if the call chain is the following

using (Conversation conv = ConversationManager.BeginConversation()) {
   …
   //in another class or method called 
   using (Conversation conversation = ConversationManager.GetConversation()) {
      //do your access code here with conversation
   }
   …
   //in another class or method called 
   using (Conversation conversation = ConversationManager.GetConversation()) {
      //do your access code here with conversation
   }
}

The two inner using block will share the same conversation, accessed by two distinct ConnectionWeakReference. The good of this technique is that the inner code is unaware of the presence or absence of a conversation.

Final question is “where do you store the reference to the current conversation”? I use System.Runtime.Remoting.Messaging.CallContext because it can manage the concept of call context, and works well even in web scenario where the context will span a whole ASP.NET Request. If you dig with reflector in the HttpContext object you will end finding that the web context is stored in a CallContext.

Alk.