哪个查询更快？
NOT EXISTS:
SELECT ProductID, ProductName
FROM Northwind..Products p
WHERE NOT EXISTS (
SELECT 1
FROM Northwind..[Order Details] od
WHERE p.ProductId = od.ProductId)
或者不在：
SELECT ProductID, ProductName
FROM Northwind..Products p
WHERE p.ProductID NOT IN (
SELECT ProductID
FROM Northwind..[Order Details])
查询执行计划显示它们做的是相同的事情。如果是这样，哪种形式是推荐的？基于NorthWind数据库。
[编辑]
刚刚发现这篇有用的文章：http://weblogs.sqlteam.com/mladenp/archive/2007/05/18/60210.aspx
我想我会坚持使用NOT EXISTS。
NOT EXISTS。NULL，NOT IN版本将需要做更多的工作（即使实际上数据中没有NULL），而且如果存在NULL，NOT IN的语义也不太可能是您想要的。Products.ProductID和[Order Details].ProductID都不允许NULL时，NOT IN将被视为以下查询的副本。SELECT ProductID,
ProductName
FROM Products p
WHERE NOT EXISTS (SELECT *
FROM [Order Details] od
WHERE p.ProductId = od.ProductId)
/*Not valid syntax but better reflects the plan*/
SELECT p.ProductID,
p.ProductName
FROM Products p
LEFT ANTI SEMI JOIN [Order Details] od
ON p.ProductId = od.ProductId
[订单详情].ProductID可以为NULL，则查询将变为：SELECT ProductID,
ProductName
FROM Products p
WHERE NOT EXISTS (SELECT *
FROM [Order Details] od
WHERE p.ProductId = od.ProductId)
AND NOT EXISTS (SELECT *
FROM [Order Details]
WHERE ProductId IS NULL)
[Order Details]包含任何NULLProductId，则正确的语义是返回零结果。请查看计划中添加的额外反半连接和行计数池以验证此内容的涵义。
Products.ProductID 也改为可空，则查询变为：SELECT ProductID,
ProductName
FROM Products p
WHERE NOT EXISTS (SELECT *
FROM [Order Details] od
WHERE p.ProductId = od.ProductId)
AND NOT EXISTS (SELECT *
FROM [Order Details]
WHERE ProductId IS NULL)
AND NOT EXISTS (SELECT *
FROM (SELECT TOP 1 *
FROM [Order Details]) S
WHERE p.ProductID IS NULL)
NOT IN子查询没有返回任何结果（即[Order Details]表为空），否则不应该在结果中返回NULL Products.ProductId。如果是这种情况，则应该返回NULL。在我的示例数据计划中，通过添加另一个反半连接来实现此目的。
这样做的效果在Buckley已经链接的博客文章中展示。在那个例子中，逻辑读取次数从大约400增加到500,000。
此外，单个NULL可以将行数减少到零，使基数估计非常困难。如果SQL Server假定会发生这种情况，但实际上数据中没有NULL行，则执行计划的其余部分可能会灾难性地恶化，如果这只是更大查询的一部分，例如造成不适当的嵌套循环导致昂贵的子树重复执行。
然而，这不是NULL列上的NOT IN的唯一可能执行计划。本文显示了另一个针对AdventureWorks2008数据库的查询的执行计划。
NOT IN或针对可空或非空列的NOT EXISTS，将提供以下计划。
NULL时，NOT IN计划现在的样子是这样的：
Sales.SalesOrderDetail.ProductID = <correlated_product_id>的单个相关索引搜索转换为每个外部行两次搜索。另一个搜索是在WHERE Sales.SalesOrderDetail.ProductID IS NULL上执行的。Sales.SalesOrderDetail不包含任何NULL ProductID，则需要的搜索操作数量将增加一倍。http://sqlinthewild.co.za/index.php/2010/02/18/not-exists-vs-not-in/
When the subquery returns even one null, NOT IN will not match any rows.
The reason for this can be found by looking at the details of what the NOT IN operation actually means.
Let’s say, for illustration purposes that there are 4 rows in the table called t, there’s a column called ID with values 1..4
WHERE SomeValue NOT IN (SELECT AVal FROM t)is equivalent to
WHERE SomeValue != (SELECT AVal FROM t WHERE ID=1) AND SomeValue != (SELECT AVal FROM t WHERE ID=2) AND SomeValue != (SELECT AVal FROM t WHERE ID=3) AND SomeValue != (SELECT AVal FROM t WHERE ID=4)Let’s further say that AVal is NULL where ID = 4. Hence that != comparison returns UNKNOWN. The logical truth table for AND states that UNKNOWN and TRUE is UNKNOWN, UNKNOWN and FALSE is FALSE. There is no value that can be AND’d with UNKNOWN to produce the result TRUE
Hence, if any row of that subquery returns NULL, the entire NOT IN operator will evaluate to either FALSE or NULL and no records will be returned
如果执行计划器说它们是一样的，那它们就是一样的。使用让你的意图更加明显的那个 - 在这种情况下，就是第二个。
实际上，我认为这可能是最快的方法：
SELECT ProductID, ProductName
FROM Northwind..Products p
outer join Northwind..[Order Details] od on p.ProductId = od.ProductId)
WHERE od.ProductId is null
我有一个表格，其中有大约120,000条记录，需要选择那些与四个其他表格（每个表格的行数约为1500、4000、40000和200）中的某个Varchar列不匹配的记录。所有涉及的表格都在相关的Varchar列上拥有唯一索引。
NOT IN花费了大约10分钟，而NOT EXISTS只花费了4秒钟。
我有一个递归查询，可能有一些未调整的部分导致了10分钟的时间，但是另一个选项只用了4秒钟，这至少对我来说说明NOT EXISTS要好得多，或者至少IN和EXISTS并不完全相同，在进行编码之前值得检查。
SELECT * from TABLE1 WHERE Col1 NOT IN (SELECT Col1 FROM TABLE2)
我发现它给出了错误的结果（我的意思是没有结果）。因为TABLE2.Col1中有一个NULL。
将查询更改为
SELECT * from TABLE1 T1 WHERE NOT EXISTS (SELECT Col1 FROM TABLE2 T2 WHERE T1.Col1 = T2.Col2)
给我正确的结果。
从那时起，我已经开始在各个地方使用NOT EXISTS。
NOT IN。 NOT IN语句内部的子查询可以在执行开始时进行评估，并且可以针对外部选择中的每个值检查临时表，而不需要像使用NOT EXISTS语句那样每次重新运行子查询。NOT EXISTS，因为优化器可能会发现简化，从而防止创建任何临时表来执行相同的功能。假设我们的数据库中存在以下两个表，它们形成了一对多的表关系。
student 表是父表，student_grade 是子表，因为它有一个 student_id 外键列引用 student 表的 id 主键列。
student 表包含以下两条记录：
| id | first_name | last_name | admission_score |
|---|---|---|---|
| 1 | Alice | Smith | 8.95 |
| 2 | Bob | Johnson | 8.75 |
student_grade 表存储学生获得的成绩：
| id | class_name | grade | student_id |
|---|---|---|---|
| 1 | Math | 10 | 1 |
| 2 | Math | 9.5 | 1 |
| 3 | Math | 9.75 | 1 |
| 4 | Science | 9.5 | 1 |
| 5 | Science | 9 | 1 |
| 6 | Science | 9.25 | 1 |
| 7 | Math | 8.5 | 2 |
| 8 | Math | 9.5 | 2 |
| 9 | Math | 9 | 2 |
| 10 | Science | 10 | 2 |
| 11 | Science | 9.4 | 2 |
假设我们想要获取所有在数学课程中获得10分的学生。
如果我们只关心学生的标识符，那么我们可以运行以下查询语句：
SELECT
student_grade.student_id
FROM
student_grade
WHERE
student_grade.grade = 10 AND
student_grade.class_name = 'Math'
ORDER BY
student_grade.student_id
然而，该应用程序希望显示学生的全名，而不仅仅是标识符，因此我们还需要从学生表中获取信息。
为了过滤在数学成绩上获得10分的学生记录，我们可以使用EXISTS SQL运算符，如下所示：
SELECT
id, first_name, last_name
FROM
student
WHERE EXISTS (
SELECT 1
FROM
student_grade
WHERE
student_grade.student_id = student.id AND
student_grade.grade = 10 AND
student_grade.class_name = 'Math'
)
ORDER BY id
student行列。然而，WHERE子句使用了EXISTS运算符和相关联的内部子查询。student_grade表的student_id列与外部student表的id列进行了匹配。student_grade的学生记录，我们可以运行以下SQL查询：SELECT
id, first_name, last_name
FROM
student
WHERE NOT EXISTS (
SELECT 1
FROM
student_grade
WHERE
student_grade.student_id = student.id AND
student_grade.grade < 9
)
ORDER BY id
| id | first_name | last_name |
|---|---|---|
| 1 | Alice | Smith |
它们非常相似，但并不完全相同。
就效率而言，当需要选择大量行时，我发现 left join is null 语句更有效。
如果优化器说它们是相同的，那么请考虑人为因素。我更喜欢看到 NOT EXISTS :)