Why is NHibernate ignoring FetchMode.Join?

I have an entity called Member. A Member can follow many other Members (according to the domain), thus pertaining a many-to-many relationship. I've created a relationship table (member_follows) in my database. Using Fluent NHibernate I've also dedicated a new entity "MemberFollow" to map this relationship as seen below:

public class MemberMap : MapBase<Member>
{
    public MemberMap() 
        : base()
    {
        Table("members");

        Map(x => x.Id      ).Column("id"      );
        Map(x => x.Fullname).Column("fullname");
}

public class MemberFollowMap : MapBase<MemberFollow>
{
    public MemberFollowMap()
        : base()
    {
        Table("members_follows");

        Map(x => x.Id).Column("id");

        References<Member>(x => x.Follower)
            .Column("follower_id")
            .Fetch.Join();

        References<Member>(x => x开发者_开发问答.Member)
            .Column("member_id");
            .Fetch.Join();
    }
}

Since the FetchMode for MemberFollow mapping is set to Join, I was expecting this query to fetch the members in one query. However when I look at the logs, I see that NHibernate performs a simple select to find the Ids of each followed member and upon access, loads members one by one.

    public IList<Member> ListFollowings(Int32 FollwerId, Int32 Start, Int32 Size, String SortBy, SortOrder OrderBy)
    {
        DetachedCriteria Filter = DetachedCriteria.For<MemberFollow>();

        Filter.Add           (Expression.Eq("Follower.Id", FollwerId));
        Filter.AddOrder      (OrderBy == SortOrder.Asc ? Order.Asc(SortBy) : Order.Desc(SortBy));
        Filter.SetProjection (Projections.Property("Member"));
        Filter.SetFirstResult(Start);
        Filter.SetMaxResults (Size ); 

        return Find<Member>(Filter); 
    }

So my question is: Why is NHibernate ignoring the FetchMode set by the mapping class?

---

I think you may take it from the wrong angle. In NHibernate, it is quite unusual to explicitly map a many-to-many relationship as a model object. See below a proposal for changes.

Given the domain object MyMember and its overriden mapping:

public class MyMember : DomainObjectBase
{
    public virtual string Name { get; set; }
    public virtual IList<MyMember> Follows { get; set; }
}

public class MemberOverride : IAutoMappingOverride<MyMember>
{
    public void Override(AutoMapping mapping)
    {
        mapping.HasManyToMany<MyMember> (x => x.Follows)
            .Table("FollowMap")
            .ParentKeyColumn("FollowerID")
            .ChildKeyColumn("FollowedID")
            .Cascade.SaveUpdate(); ;
   }
}

The following test pass:

[Test]
public void WhoFollowsWho()
{
    var a = new MyMember {Name = "A"};
    var b = new MyMember {Name = "B"};
    var c = new MyMember {Name = "C"};
    var d = new MyMember {Name = "D"};
    var e = new MyMember {Name = "E"};

    a.Follows = new List<MyMember> { b, c, d, e };
    d.Follows = new List<MyMember> { a, c, e };

    using (var t = Session.BeginTransaction())
    {
        Session.Save(a);
        Session.Save(b);
        Session.Save(c);
        Session.Save(d);
        Session.Save(e);

        t.Commit();
    }

    using (var t = Session.BeginTransaction())
    {
        DetachedCriteria followersOfC = DetachedCriteria.For<MyMember>();

        followersOfC.CreateCriteria("Follows")
             .Add(Expression.Eq("Id", c.Id))
             .SetProjection(Projections.Property("Name"));

        var results = followersOfC.GetExecutableCriteria(Session).List();

        t.Commit();
        CollectionAssert.AreEquivalent(new[]{"A", "D"}, results);
    }

    using (var t = Session.BeginTransaction())
    {
        DetachedCriteria followedByA = DetachedCriteria.For<MyMember>();

        followedByA.CreateAlias("Follows", "f")
             .Add(Expression.Eq("Id", a.Id))
             .SetProjection(Projections.Property("f.Name"));

        var results = followedByA.GetExecutableCriteria(Session).List();

        t.Commit();
        CollectionAssert.AreEquivalent(new[]{"B", "C", "D", "E"}, results);
    }
}

And the produced SQL relies, as expected, on inner joins:

NHibernate: 
SELECT this_.Name as y0_ FROM "MyMember" this_ 
inner join FollowMap follows3_ on this_.Id=follows3_.FollowerID 
inner join "MyMember" mymember1_ on follows3_.FollowedID=mymember1_.Id 
WHERE mymember1_.Id = @p0

NHibernate: 
SELECT f1_.Name as y0_ FROM "MyMember" this_ 
inner join FollowMap follows3_ on this_.Id=follows3_.FollowerID 
inner join "MyMember" f1_ on follows3_.FollowedID=f1_.Id 
WHERE this_.Id = @p0

---

Note: If, instead of only retrieving the "Name" property of each MyMember, you retrieve the full instances of MyMember, the SQL statement keeps the same shape. Only additional projections are added to the SELECT clause. However, you'll have to fix the test to make it pass again ;-)

Note 2: Provided you're willing to deal with a many-to-many relationship which holds properties of its own, this post from Kyle Baley and this one from the Nhibernate blog may provide some help on this subject.

Note 3: I've given it a try :-)

Given the domain objects MySecondMember and MyFollowMap and their overriden mapping:

public class MySecondMember : DomainObjectBase
{
    public virtual string Name { get; set; }
    public virtual IList<MyFollowMap> Follows { get; set; }
}


public class MyFollowMap : DomainObjectBase
{
    public virtual MySecondMember Who { get; set; }
    public virtual DateTime StartedToFollowOn { get; set; }
}

public class MemberSecondOverride : IAutoMappingOverride<MySecondMember>
{
    public void Override(AutoMapping mapping)
    {
        mapping.HasMany(x => x.Follows);
    }
}

The following test pass:

[Test]
public void WhoFollowsWho2()
{

    var a = new MySecondMember { Name = "A" };
    var b = new MySecondMember { Name = "B" };
    var c = new MySecondMember { Name = "C" };
    var d = new MySecondMember { Name = "D" };
    var e = new MySecondMember { Name = "E" };

    var bfm = new MyFollowMap { Who = b, StartedToFollowOn = DateTime.UtcNow };
    var cfm = new MyFollowMap { Who = c, StartedToFollowOn = DateTime.UtcNow };
    var dfm = new MyFollowMap { Who = d, StartedToFollowOn = DateTime.UtcNow };
    var efm = new MyFollowMap { Who = e, StartedToFollowOn = DateTime.UtcNow };


    a.Follows = new List { bfm, cfm, dfm, efm };

    var afm = new MyFollowMap { Who = a, StartedToFollowOn = DateTime.UtcNow };
    cfm = new MyFollowMap { Who = c, StartedToFollowOn = DateTime.UtcNow };
    efm = new MyFollowMap { Who = e, StartedToFollowOn = DateTime.UtcNow };

    d.Follows = new List { afm, cfm, efm };


    using (var t = Session.BeginTransaction())
    {
        Session.Save(a);
        Session.Save(b);
        Session.Save(c);
        Session.Save(d);
        Session.Save(e);

        t.Commit();
    }

    using (var t = Session.BeginTransaction())
    {
        DetachedCriteria followersOfC = DetachedCriteria.For<MySecondMember>();

        followersOfC.CreateAlias("Follows", "f")
            .CreateAlias("f.Who", "w")
            .Add(Expression.Eq("w.Id", c.Id))
            .SetProjection(Projections.Property("Name"));

        var results = followersOfC.GetExecutableCriteria(Session).List();
        t.Commit();
        CollectionAssert.AreEquivalent(new[] { "A", "D" }, results);

    }

    using (var t = Session.BeginTransaction())
    {
        DetachedCriteria followedByA = DetachedCriteria.For<MySecondMember>();

        followedByA
            .CreateAlias("Follows", "f")
            .CreateAlias("f.Who", "w")
            .Add(Expression.Eq("Id", a.Id))
            .SetProjection(Projections.Property("w.Name"));

        var results = followedByA.GetExecutableCriteria(Session).List();
        t.Commit();
        CollectionAssert.AreEquivalent(new[] { "B", "C", "D", "E" }, results);
    }
}

And the produced SQL relies, as expected, on inner joins:

NHibernate: 
SELECT this_.Name as y0_ FROM "MySecondMember" this_ 
inner join "MyFollowMap" f1_ on this_.Id=f1_.MySecondMember_id 
inner join "MySecondMember" w2_ on f1_.Who_id=w2_.Id 
WHERE w2_.Id = @p0;

NHibernate: 
SELECT w2_.Name as y0_ FROM "MySecondMember" this_ 
inner join "MyFollowMap" f1_ on this_.Id=f1_.MySecondMember_id 
inner join "MySecondMember" w2_ on f1_.Who_id=w2_.Id 
WHERE this_.Id = @p0