1

我正在尝试使用 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所述- 子查询的正确使用。

4

1 回答 1

3

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

为什么接收不明显？

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

家长：

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# 代码，这将导致多个父母（因为事实上，将生成相同的 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和SubqueriesNHibernate 功能）并且没有更多的重复项！

于 2013-05-18T15:24:35.987 回答