Question

使用C＃和Linq to SQL，我发现我的多个where查询比一个where / and慢了几个数量级。

这是查询

using (TeradiodeDataContext dc = new TeradiodeDataContext())
{
    var filterPartNumberID = 71;
    var diodeIDsInBlades = (from bd in dc.BladeDiodes
                            select bd.DiodeID.Value).Distinct();
    var diodesWithTestData = (from t in dc.Tests
                              join tt in dc.TestTypes on t.TestTypeID equals tt.ID
                              where tt.DevicePartNumberID == filterPartNumberID
                              select t.DeviceID.Value).Distinct();
    var result = (from d in dc.Diodes
                  where d.DevicePartNumberID == filterPartNumberID
                  where diodesWithTestData.Contains(d.ID)
                  where !diodeIDsInBlades.Contains(d.ID)
                  orderby d.Name
                  select d);
    var list = result.ToList();
    // ~15 seconds
}

但是，当最终查询中的条件是这个

时

where d.DevicePartNumberID == filterPartNumberID
& diodesWithTestData.Contains(d.ID)
& !diodeIDsInBlades.Contains(d.ID)
// milliseconds

非常快。

在调用result之前比较ToList()中的SQL，以下是查询（手动添加值71代替@params）

-- MULTIPLE WHERE
SELECT [t0].[ID], [t0].[Name], [t0].[M2MID], [t0].[DevicePartNumberID], [t0].[Comments], [t0].[Hold]
FROM [dbo].[Diode] AS [t0]
WHERE (NOT (EXISTS(
    SELECT NULL AS [EMPTY]
    FROM (
        SELECT DISTINCT [t2].[value]
        FROM (
            SELECT [t1].[DiodeID] AS [value]
            FROM [dbo].[BladeDiode] AS [t1]
            ) AS [t2]
        ) AS [t3]
    WHERE [t3].[value] = [t0].[ID]
    ))) AND (EXISTS(
    SELECT NULL AS [EMPTY]
    FROM (
        SELECT DISTINCT [t6].[value]
        FROM (
            SELECT [t4].[DeviceID] AS [value], [t5].[DevicePartNumberID]
            FROM [dbo].[Test] AS [t4]
            INNER JOIN [dbo].[TestType] AS [t5] ON [t4].[TestTypeID] = ([t5].[ID])
            ) AS [t6]
        WHERE [t6].[DevicePartNumberID] = (71)
        ) AS [t7]
    WHERE [t7].[value] = [t0].[ID]
    )) AND ([t0].[DevicePartNumberID] = 71)
ORDER BY [t0].[Name]

和

-- SINGLE WHERE
SELECT [t0].[ID], [t0].[Name], [t0].[M2MID], [t0].[DevicePartNumberID], [t0].[Comments], [t0].[Hold]
FROM [dbo].[Diode] AS [t0]
WHERE ([t0].[DevicePartNumberID] = 71) AND (EXISTS(
    SELECT NULL AS [EMPTY]
    FROM (
        SELECT DISTINCT [t3].[value]
        FROM (
            SELECT [t1].[DeviceID] AS [value], [t2].[DevicePartNumberID]
            FROM [dbo].[Test] AS [t1]
            INNER JOIN [dbo].[TestType] AS [t2] ON [t1].[TestTypeID] = ([t2].[ID])
            ) AS [t3]
        WHERE [t3].[DevicePartNumberID] = (71)
        ) AS [t4]
    WHERE [t4].[value] = [t0].[ID]
    )) AND (NOT (EXISTS(
    SELECT NULL AS [EMPTY]
    FROM (
        SELECT DISTINCT [t6].[value]
        FROM (
            SELECT [t5].[DiodeID] AS [value]
            FROM [dbo].[BladeDiode] AS [t5]
            ) AS [t6]
        ) AS [t7]
    WHERE [t7].[value] = [t0].[ID]
    )))
ORDER BY [t0].[Name]

两个SQL查询在＆lt;在SSMS中1秒并产生相同的结果。

所以我想知道为什么第一个在LINQ方面较慢。这让我很担心，因为我知道我在其他地方使用了多个where，而没有意识到这种严重的性能影响。

This question甚至已经回复了多个＆amp;在哪里this answer甚至建议使用多个where子句。

有人可以解释为什么会发生这种情况吗？

Answer 1

因为这样写作

myQuery = from t in Table
          where t.SomeField1 == someParam1
             && t.SomeField2 == someParam2
          select t;

与 NOT（upd）相同（如果someParam1和someParam2！= 0）

myQuery = from t in Table
          where t.SomeField1 == someParam1
          where t.SomeField2 == someParam2
          select t;

（未删除）与

相同

t.Where(r => t.SomeField1 == someParam1 && t.SomeField2 == someParam2)

<强> UPD

是的，我错了。第二个查询是相同的，第一个不相同。

第一次和第二次查询不完全相同。让我告诉你我的意思。

使用lamda-expression的第一个查询写为

t.Where(r => r.SomeField1 == someParam1).Where(r => r.SomeField2 == someParam2)

第二个查询

SELECT <all field from Table>
  FROM table t
 WHERE t.SomeField1 = :someParam1
   AND t.SomeField2 = :someParam2

在这种情况下生成的SQL Predicate with SomeField2首先出现（重要的是，见下文）

在第一种情况下，我们得到这个SQL：

SELECT <all field from Table>
  FROM table t
 WHERE t.SomeField2 = :someParam2
   AND t.SomeField1 = :someParam1

在第二种情况下，SQL是：

WHERE

我们看到有两个'相同'的SQL。正如我们所看到的，OP的SQL也是“相同的”，它们在NOT EXISTS子句中的谓词顺序是不同的（如我的例子中所示）。我猜SQL优化器生成2个不同的执行计划，可能（!!!）执行EXISTS，然后执行EXISTS，然后过滤比首次过滤花费更多时间，之后执行{{1} }和NOT EXISTS

<强> UPD2

这是Linq Provider（ORM）的“问题”。我正在使用另一个ORM（linq2db），它在两种情况下都为我生成完全相同的SQL。

为什么LINQ中的多个位置如此之慢？

1 个答案: