NHhibernate - multiple queries in one roundtrip to server

Usually when we need to retrieve data from database server, we write code which looks like that

1
using (var session = DataAccesLayer.Instance.OpenSession())
2
{
3
    using (var transaction = session.BeginTransaction())
4
    {
5
        var projects = session.QueryOver<Project>().Where(val => val.Name == "Project").List();
6
        var tasks = session.QueryOver<Task>().Where(val => val.Name == "First task").List();
7
        //more queries
8
        //more queries
9
        //exception handling etc.
10
    }
11
}

This code will execute two queries,each of them in separate roundtrip to the server.

This is the most popular way of getting data for multiple tables etc. However it is possible to enhance the code above and execute several queries in only one roundtrip to the database server. NHibernate provides us with three different mechanisms to accomplish this goal:

MultiQuery

First way to execute several queries at once is MultiQuery. In my opinion this is not very handy mechanism because of the fact, that we must use HQL. Here is an example of usage

1
var projectQuery = session.CreateQuery("FROM Project as prj where prj.Name= :projectName")
2
                          .SetParameter("projectName", "Project");
3

4
var taskQuery = session.CreateQuery( "FROM Task as tsk where tsk.Name=:taskName" )
5
                       .SetParameter("taskName","First task");
6

7
var multiQueryByIndex = session.CreateMultiQuery( )
8
                               .Add<Project>( projectQuery )
9
                               .Add<Task>( taskQuery );

As You can see thanks to CreateMultiQuery method we are able to aggregate multiple queries. In order to get access to results, we have to execute code below

1
var result = multiQueryByIndex.List();

Now we can get result of specific query using indexer

1
var projects = result[0] as List<Project>;
2
var tasks = result[1] as List<Task>;

If we don’t like this approach, the CreateMultiQuery method has an overload which allows to give “names” to queries. Thanks to this we can get result of query by its name.

1
var multiQueryByKey = session.CreateMultiQuery( )
2
                             .Add<Project>( "project", projectQuery )
3
                             .Add<Task>( "task", taskQuery );
4

5
var projects = multiQueryByKey.GetResult( "project" ) as List<Project>;
6
var tasks = multiQueryByKey.GetResult( "task" ) as List<Task>;

MultiCriteria

Much better way of creating multiple queries is MultiCriteria. In this case we can use QueryOver API, so we don’t have to rely on HQL query strings.

1
var projectQuery = session.QueryOver<Project>().Where(val => val.Name == "Project");
2
var taskQuery = session.QueryOver<Task>( ).Where(val => val.Name == "First task");
3
var multiCriteriaByIndex = session.CreateMultiCriteria( )
4
                                  .Add( projectQuery )
5
                                  .Add( taskQuery );
6

7
var multiCriteriaByKey = session.CreateMultiCriteria( )
8
                                .Add( "project", projectQuery )
9
                                .Add( "task", taskQuery );
10

11
IList result = multiCriteriaByIndex.List( );
12
var projects = result[0] as List<Project>;
13
var tasks = result[1] as List<Task>;
14

15
projects = multiCriteriaByKey.GetResult( "project" ) as List<Project>;
16
tasks = multiCriteriaByKey.GetResult( "task" ) as List<Task>;

As You can see the usage of CreateMultiCriteria method is pretty consistent with CreateMultiQuery. Unfortunately we still have to retrieve data from specific query by index or by query name.

Future

My personal favorite for creating multi queries is Future. The usage is pretty straightforward

1
var projects = session.QueryOver<Project>().Where(val => val.Name == "Project").Future<Project>();
2
var tasks = session.QueryOver<Task>().Where(val => val.Name == "First task").Future<Task>();

As You can see, we can leverage QueryOver API and instead of calling List we call Future. NHibernate will aggregate our queries and will execute them once we start to iterate over one of them.

Despite the fact that all three mechanism has completely different syntax ,SQL created by all of them is the same and looks like that