子查询中 SQL WHERE EXISTS 的有趣观察

Question

我想知道是否有人可以解释为什么会发生以下情况：

我有我制作的下表。它有 2 列“A”和“B”：

A       B
==========
1,      11
2,      12
3,      13
4,      14
5,      15
6,      16
7,      17
8,      18
9,      19

如果我运行以下查询：-

SELECT * FROM 
    (SELECT A,B FROM Table_1) T1
WHERE EXISTS 
    (SELECT 'X' FROM Table_1 WHERE A = 3)

我会得到整个表。我理解这一点，因为 EXISTS 子句检查它是否在语句中找到它所做的单行

但是，如果我运行以下查询，我只得到表的一部分部分

SELECT * FROM 
    (SELECT A,B FROM Table_1) T1
WHERE EXISTS 
    (SELECT 'X' FROM Table_1 WHERE T1.A=3 OR T1.A=4)

结果如下

A     B
========
3,    13
4,    14

任何​​人都可以解释为什么会发生这种情况吗？

Answer 1

让我们分解一下您实际要求数据库服务器执行的操作。

SELECT * FROM - 获取所有字段。从现在开始我将忽略这一点，因为它并不重要。

(SELECT A,B FROM Table_1) T1 - 从表中获取所有行，并将结果集命名为“T1”。

WHERE EXISTS (SELECT 'X' FROM Table_1 WHERE A = 3) - 选择与上述无关的表中的所有行。这种情况在表中每行发生一次 - 但总是做同样的事情，因为子查询中不使用 T1。如果表中的某一行 A=3（总是这种情况），则不做任何限制。否则，丢弃该特定的T1（这里不会发生这种情况）。

WHERE EXISTS (SELECT 'X' FROM Table_1 WHERE T1.A=3 OR T1.A=4) - 这个很棘手。您正在对表中的所有行进行第二次选择，但受到以下条件的限制：T1.A=3 OR T1.A=4。此条件基于 T1 的结果 - 但这不是整个表，只是特定行。当您说 SELECT * FROM mytable WHERE mytable.A=3 时，您的意思并不是“如果某行具有 A=3，则选择 mytable 的所有行”，您的意思只是选择那些特定的行，其中确实如此。因此，子查询 SELECT 'X' FROM Table_1 WHERE T1.A=3 OR T1.A=4 要么不包含任何行，要么包含 Table_1 中的所有行，具体取决于哪个值位于 T1.A 中。因为您使用 EXISTS，所以所有行都为 true，无行为 false。

这就是为什么您会得到不同的结果 - 您的子查询在 Table_1 中每行执行一次。在第一种情况下，它始终包含一行。在第二种情况下，它要么不包含行，要么包含全部九行，具体取决于 T1 中包含的 Table_1 的特定行。

Answer 2

如果删除一些子查询可能会更容易。您的查询基本上可归结为以下内容：

查询 1：从 Table_1 中选择 true 中的所有记录。这是因为 Table_1 中有包含 3 或 4 的 A 字段。

查询 2：选择 Table_1 中的所有记录，其中 A< /code> 等于 3 或 A 等于 4

用 SQL 表达，您的查询可以简化为

SELECT * FROM Table_1

和

SELECT * FROM Table_1
WHERE A IN (3,4)

Answer 3

我相信它会检查 T1 的当前行来查看 A=3 或 A=4，类似于您写道：

SELECT * FROM 
  (SELECT A,B FROM Table_1) T1
WHERE A=3 OR A=4;

Answer 4

在 SQL 中总是有多种方法来编写相同的内容。例如，这

SELECT * FROM 
    (SELECT A,B FROM Table_1) T1

......可以重写为：

SELECT A, B
  FROM Table_1

后者更简单，我认为没有理由更喜欢前者。相应地重写您的第一个查询，

SELECT A, B
  FROM Table_1
 WHERE EXISTS (
               SELECT 'X' 
                 FROM Table_1 
                WHERE A = 3
              );

我删除了相关名称 T1 因为它没有任何用途。子查询不引用其“外部”表表达式，因此不需要消除每个外观 Table_1 的歧义。

我想您明白这里发生了什么：如果 Table_1 中的一行或多行满足搜索条件 A = 3 则返回整个表，否则返回空集回来了。虽然它是一个有效的查询，但它通常不是一个非常有用的结构。

然而，对于您的第二个查询，至少需要一个相关名称，因为子查询确实引用了其外部表：

SELECT A, B
  FROM Table_1 T1
 WHERE EXISTS (
               SELECT 'X' 
                 FROM Table_1 T2
                WHERE T1.A IN (3, 4)
              );

这在语义上再次与您的第二个查询等效。请注意，我已为子查询中 Table_1 的外观指定了相关名称 T2，但 T2 并未出现在子查询的 WHERE 中 子句。因为没有使用 T2，所以我们可以完全删除子查询（因此需要相关名称）：

SELECT A, B
  FROM Table_1
 WHERE A IN (3, 4);

值得指出的是，通常会利用子查询引用“外部”表表达式的能力作为“相关子查询”，即搜索条件（WHERE 子句）涉及“内部”和“外部”表（您的第二个查询的搜索条件涉及“外部”表 仅有的）。

使用常用零件和供应商数据库，下面是一个相关子查询的示例，用于实现<一个href="https://stackoverflow.com/questions/6449544/findout-duplicate-rows-in-a-table-while-inserting/6450663#6450663">半加入寻找供应商（S< /code>) 提供 (SP) 至少一部分：

SELECT SNO, SNAME
  FROM S
 WHERE EXISTS (
               SELECT *
                 FROM SP
                WHERE SP.SNO = S.SNO
              );

请注意，子查询的搜索条件将“外部”表 SP 与“内部”表S。此外，“外部”表中的投影 SELECT SNO, SNAME 不需要包含相关名称 S，因为来自 ' “外部”表不在“内部”表的范围内。

Answer 5

哇，酷。

那里有一些额外的 SQL。你真正在做的是：

 SELECT * FROM Table_1 T1 WHERE EXISTS 
    (SELECT 'X' FROM Table_1 WHERE T1.A = 3 OR T1.A = 4)

那么发生了什么？

当您将 Table_1 的每一行读取为 T1 时，引擎会评估子选择，以决定 T1 中的行是否应包含在结果集中。

在第一行，T1.A 为 1，则 T1.A = 3 为 FALSE，T1.A = 4 为 FALSE，因此子选择失败。该行不包含在结果集中。

A = 2 时相同。不包括 A = 2 的行。

但对于接下来的两行（3 和 4 的 T1.A），OR 的至少一侧计算结果为 TRUE 并且子选择成功。所以这两行都包含在内。

当 T1.A 达到 5 时，对于表的其余部分，子选择将失败。