在 NHibernate 中，使用 Disjunction 会产生双重结果

Question

我正在尝试使用 DetachedCriteria 进行选择，我想在运行时添加几个由 OR 分隔的条件。

如果我使用：

Restrictions.Or( cond1, Restrictions.Or(cond2, Restrictions.Or(cond3, cond4)) )

我得到了我想要的结果。

但是如果我像这样使用析取：

var disjunction = Restrictions.Disjunction();
disjunction.Add(cond1);
disjunction.Add(cond2);
disjunction.Add(cond3);
disjunction.Add(cond4);

我有 cond1 和 cond2 对他们来说是真的实体，在结果中我得到它们两次（相同的实体在列表结果中返回两次）。

我不希望使用 QueryOver，因为我正在尝试完成一些使用 QueryOver 难以完成的事情（我尝试做的最终结果是从过滤器的 json 中获取 sql 查询）。

是什么导致析取返回双精度值？有没有办法在最后添加一个 DISTINCT ？我做错了吗，我不应该对同一张桌子上的不同条件使用析取吗？

更新：

对于 DISTINCT 部分：

criteria.SetResultTransformer(new NHibernate.Transform.DistinctRootEntityResultTransformer());

或

Projections.Distinct(Projections.Id())

真正的解决方案如 Radim Köhler 所述——子查询的正确使用。

Answer 1

一个小借口：问题没有提供任何映射，也缺少查询......所以只能猜测是什么问题。但是让我们尝试提供一些解释

为什么接收不清晰？

让我们有两个表（如问题下方的一个 cmets 中给出的）

家长：

ParentId | Name
1        | Parent_A
2        | Parent_B

孩子：

ChildId | Color | ParentId
1       | green | 1
2       | grey  | 1
3       | gold  | 1
4       | green | 2

如果我们要在纯 SQL 中创建简单的选择，那么就有这个

SELECT p.ParentId, p.Name
FROM Parent AS p
  INNER JOIN Child AS c
    ON p.ParentId = c.ParentId
WHERE 
  c.Color = 'green' OR c.Color = 'grey' OR c.Color = 'gold'

这个查询的结果是什么？

1 | Parent_A
1 | Parent_A
1 | Parent_A
2 | Parent_B

如果我们将其转换为类似的标准：

var sesion = ... // get session 

var parent = sesion.CreateCriteria<Parent>();

var children = parent.CreateCriteria("Children");

// restrict the children
children.Add(Restrictions.Disjunction()
    .Add(Restrictions.Eq("Color", "green"))
    .Add(Restrictions.Eq("Color", "grey"))
    .Add(Restrictions.Eq("Color", "gold"))
    );

var list = parent
    .SetMaxResults(10) // does not matter in our example, but ... it should be used always
    .List<Parent>();

这是Criteria C#代码，会产生多个Parent（因为上面说的会生成相同的SQL）

如我们所见，问题绝对不在 NHiberante 方面。真的！ NHibernate 不仅是无辜的，而且还在做需要做的事情。

解决方案

解决方案在子选择中

在SQL中会是这样的

SELECT p.ParentId, p.Name
FROM Parent AS p
WHERE p.ParentId IN (
  SELECT c.ParentId
  FROM Child AS c
    WHERE c.ParentId = p.ParentId
    AND c.Color = 'green' OR c.Color = 'grey' OR c.Color = 'gold'
)

这将为我们提供我们最可能想要的结果：

1 | Parent_A
2 | Parent_B

以及如何在 NHibernate 中做到这一点？

var sesion = ... // get session 

var parent = sesion.CreateCriteria<Parent>();

//var children = parent.CreateCriteria("Children");
var children = DetachedCriteria.For(typeof(Child));

// restrict the children
children.Add(Restrictions.Disjunction()
    .Add(Restrictions.Eq("Color", "green"))
    .Add(Restrictions.Eq("Color", "grey"))
    .Add(Restrictions.Eq("Color", "gold"))
    );

// ad SELECT into this sub-select
children.SetProjection( Projections.Property("ParentId"));

// filter the parent
parent
    .Add(Subqueries.PropertyIn("ParentId", children));


var list = parent
    .SetMaxResults(10) // does not matter in our example, but ... it should be used always
    .List<Parent>();

现在，我们确实有子选择（DetachedCriteria 和 Subqueries NHibernate 功能）并且没有更多重复项！