关系型数据库中的表与集合理论中的集合类似，表是由行（记录）组成的集合。因此，SQL 支持基于数据行的各种集合运算，包括并集运算（Union）、交集运算（Intersect）和差集运算（Except）。它们都可以将两个查询的结果集合并成一个结果集，但是合并的规则各不相同。

本文比较了五种主流数据库实现的集合运算，包括 MySQL、Oracle、SQL Server、PostgreSQL 以及 SQLite。

执行 SQL 集合运算时，集合操作中的两个查询结果需要满足以下条件：

• 两个查询结果集中字段的数量必须相同。

• 两个查询结果集中对应字段的类型必须匹配或兼容。SQLite 使用动态数据类型，不要求字段类型匹配或兼容。

交集求同

SQL 交集运算的运算符是 INTERSECT，它可以用于获取两个查询结果集中的共同部分，也就是同时出现在第一个查询结果集和第二个查询结果集中的数据，如下图所示：

图 中的 1 和 2 是两个查询结果集中都存在的元素，因此交集运算的结果只包含 1 和 2。

SQL 交集运算的语法如下：

SELECT column1, column2, ...
FROM table1
INTERSECT [DISTINCT | ALL]
SELECT col1, col2, ...
FROM table2;

其中，DISTINCT 表示对合并后的结果集进行去重操作，只保留不重复的记录。ALL 表示保留合并结果中的重复记录。如果省略，默认值为 DISTINCT。

注意：MySQL 8.0开始支持 INTERSECT 运算符以及 ALL 选项。PostgreSQL 支持完整的 DISTINCT 和 ALL 选项，Oracle 21c 开始支持 ALL 选项，SQL Server 以及 SQLite 支持简写的 INTERSECT。

我们首先创建两个简单的测试表 t_set1 和 t_set2。

CREATE TABLE t_set1
(
 id INTEGER,
 name VARCHAR(10)
);
INSERT INTO t_set1 VALUES (1, 'apple');
INSERT INTO t_set1 VALUES (2, 'banana');
INSERT INTO t_set1 VALUES (3, 'orange');
CREATE TABLE t_set2
(
 id INTEGER,
 name VARCHAR(10)
);
INSERT INTO t_set2 VALUES (1, 'apple');
INSERT INTO t_set2 VALUES (2, 'banana');
INSERT INTO t_set2 VALUES (4, 'pear');

然后使用以下语句查找两个表中的共同记录。

SELECT id, name
FROM t_set1
INTERSECT
SELECT id, name
FROM t_set2;

查询返回的结果如下：

id|name 
--|------
1|apple 
2|banana

其中，“apple”和“banana”是两个表中的共同数据。

以上示例中两个 SELECT 语句返回的列名都是 id 和 name，因此最终结果返回的列表也是 id 和 name。如果两个语句返回的列名不同，最终结果使用第一个语句返回的列名。

通常来说，交集运算都可以改写为等价的内连接查询。上面的查询语句可以改写为下面这样：

SELECT DISTINCT t1.id, t1.name
FROM t_set1 t1
JOIN t_set2 t2
ON (t2.id = t1.id AND t2.name = t1.name);

注意，SELECT 列表中返回的全部字段（id 和 name）都必须作为连接查询的条件。

前文我们提到过，使用 SQL 集合运算的前提是，参与集合运算的两个查询结果集必须包含相同数量的字段，并且对应字段的数据类型必须匹配。因此，以下两个示例都会返回错误：

SELECT id
FROM t_set1
INTERSECT
SELECT id, name
FROM t_set2;

SELECT id, id
FROM t_set1
INTERSECT
SELECT id, name
FROM t_set2;

在第一个示例中，两个 SELECT 语句返回的字段数量不相同；在第二个示例中，两个 SELECT 语句返回的字段数据类型不一致。对于第二个查询示例，SQLite 不会返回错误。

并集存异

SQL 并集运算的运算符是 UNION，它可以用于计算两个查询结果集的相加，返回出现在第一个查询结果集或者第二个查询结果集中的数据，如下图所示。

图中的 1 和 2 是两个查询结果集中都存在的元素，不过它们在最终结果中只出现了一次，因为 UNION 运算符排除了查询结果中的重复记录。

SQL 并集运算的语法如下：

SELECT column1, column2, ...
FROM table1
UNION [DISTINCT | ALL]
SELECT col1, col2, ...
FROM table2;

其中，DISTINCT 表示对合并的结果集进行去重操作，只保留不重复的记录。ALL 表示保留最终结果中的重复记录。如果省略，默认值为 DISTINCT。

以下是一个 UNION 运算符的示例：

SELECT id, name
FROM t_set1 
UNION
SELECT id, name
FROM t_set2;

查询返回的结果如下：

id|name 
--|------
1|apple 
2|banana
3|orange
4|pear 

虽然“apple”和“banana”在两个表中都存在，但是它们在最终的结果中只出现了一次。

UNION 运算符可以改写为等价的全外连接查询。例如，上面的查询语句可以改写为下面这样：

-- Oracle、Microsoft SQL Server、PostgreSQL 以及 SQLite 
SELECT COALESCE(t1.id, t2.id), COALESCE(t1.name, t2.name)
FROM t_set1 t1
FULL JOIN t_set2 t2
ON (t2.id = t1.id AND t2.name = t1.name);

其中，全外连接可以返回左表和右表中的全部数据，COALESCE 函数的作用就是当左表字段为空时返回右表中的字段。MySQL 目前不支持全外连接查询。

如果我们想要保留并集运算结果中的重复记录，可以使用 UNION ALL 运算符。例如：

SELECT id, name
FROM t_set1 
UNION ALL
SELECT id, name
FROM t_set2;

查询返回的结果如下：

id|name 
--|------
1|apple 
2|banana
3|orange
1|apple 
2|banana
4|pear 

此时，“apple”和“banana”在结果中分别出现了两次。

提示：通常来说，UNION ALL 运算符无须进行重复值的去除，其性能比 UNION 运算符更好（尤其在数据量比较大的情况下）。

对于 UNION 和 UNION ALL 运算符，两个查询结果必须包含相同数量的字段，同时对应字段的数据类型也要兼容。不过，MySQL 和 SQLite 会执行隐式的数据类型转换，例如：

-- MySQL 和 SQLite
SELECT 1 AS id
UNION ALL
SELECT 'sql' AS name;

MySQL 将第一个查询返回的字段转换为字符串类型，SQLite 将第二个查询返回的字段转换为整数类型。查询返回的结果如下：

id 
---
1 
sql

差集排他

SQL 差集运算的运算符是 EXCEPT，它可以用于计算两个查询结果集的相减，返回出现在第一个查询结果集中但不在第二个查询结果集中的数据，如下图所示。

图 中第一个查询的结果只有元素 3 没有出现在第二个查询的结果中，因此差集运算的结果只返回了 3。SQL 差集运算的语法如下：

SELECT column1, column2, ...
FROM table1
EXCEPT [DISTINCT | ALL]
SELECT col1, col2, ...
FROM table2;

其中，DISTINCT 表示对合并的结果集进行去重操作，只保留不重复的记录。ALL 表示保留最终结果集中的重复记录。如果省略，默认值为 DISTINCT。

注意：MySQL 8.0 开始支持 EXCEPT 运算符以及 ALL 选项。Oracle 21c 开始支持 EXCEPT 关键字以及 ALL 选项，其以前的版本使用等价的 MINUS 运算符。PostgreSQL 支持完整的 DISTINCT 和 ALL 选项，SQL Server 以及 SQLite 支持简写的 EXCEPT。

以下是一个 EXCEPT 运算符的示例：

SELECT id, name
FROM t_set1 
EXCEPT
SELECT id, name
FROM t_set2;

如果使用 Oracle 19c 以及更早的版本，等价的查询语句如下：

-- Oracle
SELECT id, name
FROM t_set1 
MINUS
SELECT id, name
FROM t_set2;

查询返回的结果如下：

id|name 
--|------
3|orange

只有“orange”出现在表 t_set1 但不在表 t_set2 中。

差集运算可以改写为等价的左外连接或者右外连接，上面的查询语句可以改写为下面这样：

SELECT t1.id, t1.name
FROM t_set1 t1
LEFT JOIN t_set2 t2
ON (t2.id = t1.id AND t2.name = t1.name)
WHERE t2.id IS NULL;

其中的 WHERE 条件是关键，它保留了连接结果中 t_set2.id 为空的数据，也就是只在 t_set1 中出现的记录。

集合运算与排序

我们在使用集合运算符时需要注意几个事项，首先就是排序操作。如果我们想要对集合运算的结果进行排序操作，必须将 ORDER BY 子句写在整个查询语句的最后，集合运算符之前的 SELECT 语句中不能出现排序子句。

下面是一个错误的查询示例：

-- 集合运算中的错误排序子句
SELECT id, name
FROM t_set1
ORDER BY id
UNION ALL
SELECT id, name
FROM t_set2;

无论我们使用哪种数据库，以上语句都会返回语法错误。因为在集合运算之前进行排序没有意义，最终结果的返回顺序可能会发生改变。正确的做法是在整个查询语句的最后指定排序操作，例如：

SELECT id, name
FROM t_set1
UNION ALL
SELECT id, name
FROM t_set2
ORDER BY id;

查询返回的结果如下：

id|name 
--|------
1|apple 
1|apple 
2|banana
2|banana
3|orange
4|pear 

运算符的优先级

另一个关于集合运算的注意事项就是 3 种集合运算符的优先级。当我们使用集合运算符将多个查询语句进行组合时，需要注意它们之间的优先级和执行顺序：

• 按照 SQL 标准，交集运算符（INTERSECT）的优先级高于并集运算符（UNION）和差集运算符（EXCEPT）。但是 Oracle 和 SQLite 中所有集合运算符的优先级相同。

• 相同的集合运算符按照从左至右的顺序执行。

• 使用括号调整多个集合运算符的执行顺序。

-- Microsoft SQL Server、PostgreSQL 以及 SQLite
SELECT 1 AS n
UNION ALL
SELECT 1
INTERSECT 
SELECT 1;

以上语句在 Microsoft SQL Server 和 PostgreSQL 中返回的结果如下：

n
-
1
1

查询返回了 2 个重复的 1。因为查询先执行 INTERSECT 运算符，结果包含 1 个 1。然后执行 UNION ALL 运算符，最终的结果保留了重复的 1。

以上语句在 Oracle 和 SQLite 中返回的结果如下：

n
-
1

查询只返回了 1 个 1。因为查询先执行 UNION ALL 运算符，结果包含 2 个 1。然后再执行 INTERSECT 运算符，最终的结果去除了重复值。

以下示例说明了相同集合运算符的执行顺序：

SELECT 1 AS n
UNION ALL
SELECT 1
UNION
SELECT 1;

查询返回的结果如下：

n
-
1

以上语句只返回了 1 个 1，因为第二个 UNION 运算符去除了重复的记录。

如果我们将以上示例中的两个并集运算符交换位置：

SELECT 1 AS n
UNION
SELECT 1
UNION ALL
SELECT 1;

查询返回的结果如下：

n
-
1
1

以上语句返回了 2 个重复的 1，因为第二个 UNION ALL 运算符保留了重复的记录。

最后，我们可以在使用括号来修改多个集合运算符的执行顺序：

-- MySQL、Oracle、Microsoft SQL Server 和 PostgreSQL
SELECT 1 AS n
UNION ALL
(SELECT 1
INTERSECT
SELECT 1);

以上示例先执行括号内的查询语句，因此查询返回的结果如下：

n
-
1
1

SQLite 目前不支持这种修改集合运算符优先级的方式。