使用 NHibernate 3.0.0 时对抗笛卡尔积（x-join）

Question

我数学不好，但我大概知道笛卡尔积是什么。
这是我的情况（简化）：

public class Project{
 public IList<Partner> Partners{get;set;}
}
public class Partner{
 public IList<PartnerCosts> Costs{get;set;}
 public IList<Address> Addresses{get;set;}
}
public class PartnerCosts{
 public Money Total{get;set;}
}
public class Money{
 public decimal Amount{get;set;}
 public int CurrencyCode{get;set;}
}
public class Address{
 public string Street{get;set;}
}

我的目标是有效加载整个项目。

当然问题是：

• 如果我尝试急切加载合作伙伴及其成本，查询会返回大量行
• 如果我延迟加载 Partner.Costs，数据库会收到垃圾邮件请求（这比第一种方法要快一点）

据我所知，常见的解决方法是使用 MultiQueries，但我有点不明白。
所以我希望通过这个例子来学习。

如何有效加载整个项目？

Ps我使用的是NHibernate 3.0.0。
请不要使用 hql 或字符串形式的标准 api 方法发布答案。

Answer 1

好的，我为自己写了一个示例，反映了您的结构，这应该可行：

int projectId = 1; // replace that with the id you want
// required for the joins in QueryOver
Project pAlias = null;
Partner paAlias = null;
PartnerCosts pcAlias = null;
Address aAlias = null;
Money mAlias = null;

// Query to load the desired project and nothing else    
var projects = repo.Session.QueryOver<Project>(() => pAlias)
    .Where(p => p.Id == projectId)
    .Future<Project>();

// Query to load the Partners with the Costs (and the Money)
var partners = repo.Session.QueryOver<Partner>(() => paAlias)
    .JoinAlias(p => p.Project, () => pAlias)
    .Left.JoinAlias(() => paAlias.Costs, () => pcAlias)
    .JoinAlias(() => pcAlias.Money, () => mAlias)
    .Where(() => pAlias.Id == projectId)
    .Future<Partner>();

// Query to load the Partners with the Addresses
var partners2 = repo.Session.QueryOver<Partner>(() => paAlias)
    .JoinAlias(o => o.Project, () => pAlias)
    .Left.JoinAlias(() => paAlias.Addresses, () => aAlias)
    .Where(() => pAlias.Id == projectId)
    .Future<Partner>();

// when this is executed, the three queries are executed in one roundtrip
var list = projects.ToList();
Project project = list.FirstOrDefault();

我的类有不同的名称，但反映了完全相同的结构。我替换了名字，希望没有错别字。

说明：

连接需要别名。我定义了三个查询来加载您想要的 Project、Partners 及其 Costs 和 Partners 及其 <代码>地址。通过使用 .Futures()，我基本上告诉 NHibernate 在我真正想要结果时使用 projects.ToList() 在一次往返中执行它们。

这将导致在一次往返中确实执行了 3 个 SQL 语句。这三个语句将返回以下结果：
1) 1 行包含您的项目
2) x 行包含合作伙伴及其成本（和资金），其中 x 是项目合作伙伴的成本总数
3) y 行包含合作伙伴及其地址，其中 y 是项目合作伙伴的地址总数

您的数据库应返回 1+x+y 行，而不是 x*y 行，这将是笛卡尔积。我确实希望您的数据库实际上支持该功能。

Answer 2

如果您在 NHibernate 上使用 Linq，则可以通过以下方式简化笛卡尔预防：

int projectId = 1;
var p1 = sess.Query<Project>().Where(x => x.ProjectId == projectId);


p1.FetchMany(x => x.Partners).ToFuture();

sess.Query<Partner>()
.Where(x => x.Project.ProjectId == projectId)
.FetchMany(x => x.Costs)
    .ThenFetch(x => x.Total)
.ToFuture();

sess.Query<Partner>()
.Where(x => x.Project.ProjectId == projectId)
.FetchMany(x => x.Addresses)
.ToFuture();


Project p = p1.ToFuture().Single();

此处详细说明：http://www.ienablemuch.com/2012/08/solving-nhibernate-thenfetchmany.html

Answer 3

不要急于获取多个集合并获得令人讨厌的笛卡尔积：

Person expectedPerson = session.Query<Person>()
    .FetchMany(p => p.Phones)
        .ThenFetch(p => p.PhoneType)
    .FetchMany(p => p.Addresses)
    .Where(x => x.Id == person.Id)
    .ToList().First();

您应该在一个数据库调用中批量处理子对象：

// create the first query
var query = session.Query<Person>()
      .Where(x => x.Id == person.Id);
// batch the collections
query
   .FetchMany(x => x.Addresses)
   .ToFuture();
query
   .FetchMany(x => x.Phones)
   .ThenFetch(p => p.PhoneType)
   .ToFuture();
// execute the queries in one roundtrip
Person expectedPerson = query.ToFuture().ToList().First();

我刚刚写了一篇关于它的博客文章，其中解释了如何使用 Linq、QueryOver 或 HQL 来避免这种情况
http://blog.raffaeu.com/archive/2014 /07/04/nhibernate-fetch-strategies/

Answer 4

我只是想为弗洛里安的真正有用的答案做出贡献。我发现了困难的方法
所有这一切的关键是别名。别名决定了 sql 中的内容
并被 NHibernate 用作“标识符”。成功加载的最小 Queryover
三级对象图是这样的：

Project pAlias = null;
Partner paAlias = null;

IEnumerable<Project> x = session.QueryOver<Project>(() => pAlias)
 .Where(p => p.Id == projectId)
 .Left.JoinAlias(() => pAlias.Partners, () => paAlias)
 .Future<Project>();


session.QueryOver(() => paAlias).Fetch(partner => partner.Costs).
 .Where(partner => partner.Project.Id == projectId)
 .Future<Partner>();

第一个查询加载项目及其子伙伴。重要的部分是 Partner 的别名。
合作伙伴别名用于命名第二个查询。第二个查询加载合作伙伴和成本。
当它作为“多重查询”执行时，Nhibernate 将“知道”第一个和第二个查询是连接的
通过 paAlias （或者更确切地说，生成的 sql 将具有“相同”的列别名）。
因此，第二个查询将继续加载第一个查询中已启动的合作伙伴。