R – Nhibernate change from lazy=false to fetch=join many-to-many

lazy-loadingmany-to-manynhibernatenhibernate-mapping

i have:

<bag name="Categories" table="CMS_Articles_Categories" lazy="true">
    <key column="article_id"/>
    <many-to-many class="Framework.CMS.Domain.Category, Framework.CMS" column="category_id"/>
</bag>

This is under an Article mapping. An article can be in many categories and of course a category has many articles. When this is lazy=true then its fine. But the thing is that i want to eagerly load all categories. So the questions are:

1) I understand that i can change it to lazy=false but it seems that nhibernate still executes a separate query. Is it sending out the initial query (e.g. to get all articles) and the subsequent one (to get the categories of an article) in batches? cause it doesnt seem so

2) If i wanted to change this mapping to a join, is there any way to make nhibernate load all articles and their categories in one query and construct the objects accordingly? if i change it now to a join it brings back multiple objects for the same id. e.g. if article 5 is in cat 1 and 2 it brings back 5 twice.

Best Answer

You can do that in 2 ways, one is by setting the fetch option in hbm file, next is you can override the default fetch strategy in Query options.

E.g.

User user = (User) session.CreateCriteria(typeof(User))
            .SetFetchMode("Permissions", FetchMode.Join)
            .Add( Expression.Eq("Id", userId) )
            .UniqueResult();

Refer nhibernate ref docs

Related Solutions

Hibernate – When to use inverse=false on NHibernate / Hibernate OneToMany relationships

As Matthieu says, the only case where you wouldn't want to set inverse = true is where it does not make sense for the child to be responsible for updating itself, such as in the case where the child has no knowledge of its parent.

Lets try a real world, and not at all contrived example:

<class name="SpyMaster" table="SpyMaster" lazy="true">
  <id name="Id">
    <generator class="identity"/>
  </id>
  <property name="Name"/>
  <set name="Spies" table="Spy" cascade="save-update">
    <key column="SpyMasterId"/>
    <one-to-many class="Spy"/>
  </set>
</class>

<class name="Spy" table="Spy" lazy="true">
  <id name="Id">
    <generator class="identity"/>
  </id>
  <property name="Name"/>
</class>

Spymasters can have spies, but spies never know who their spymaster is, because we have not included the many-to-one relationship in the spy class. Also (conveniently) a spy may turn rogue and so does not need to be associated with a spymaster. We can create entities as follows:

var sm = new SpyMaster
{
    Name = "Head of Operation Treadstone"
};
sm.Spies.Add(new Spy
{
    Name = "Bourne",
    //SpyMaster = sm // Can't do this
});
session.Save(sm);

In such a case you would set the FK column to be nullable because the act of saving sm would insert into the SpyMaster table and the Spy table, and only after that would it then update the Spy table to set the FK. In this case, if we were to set inverse = true, the FK would never get updated.

R – Change to lazy loading at runtime

I think the best (only) way is to set lazy=false and then in your HQL use "join fetch" or in criterias use SetFetchMode on a collection that needs to be eagerly retrieved.

Read more here: http://ayende.com/Blog/archive/2006/05/02/CombatingTheSelectN1ProblemInNHibernate.aspx

/Asger

Related Topic

R – NHibernate: Change from lazy=true to fetch=join brings back the world