SQL SELECT 查询语句用法详解

SQL概述

SQL的全称是Structured Query Language（结构化查询语言），是最早于1970年代提出并广泛应用于访问和管理关系型数据库（如Oracle/MySQL）的标准计算机语言。基于SQL的全面强大的功能及简单易用的特性，其历经50年风雨一直长盛不衰；很多近年来才快速发展起来的大数据处理系统如Presto/Flink/Spark/Hive等也实现了SQL或类SQL的语言。

基于具体的功能可以对SQL做进一步的细分，常用的有：

数据定义语言（DDL，Data Definition Language）：创建新表或修改、删除表，关键字包括CREATE、ALTER和DROP等
数据操作语言（DML，Data Manipulation Language）：用于添加、修改和删除数据，关键字包括INSERT、UPDATE和DELETE等
数据查询语言（DQL，Data Query Language）：用于从表中获得数据，关键字是SELECT

实际应用中，我们通常是编写SQL语句，提交给数据库或大数据系统来执行，然后获取执行结果；有几个容易搞迷糊的概念如下：

Statement：语句，通常指整个SQL文本
Clause：子句，通常指SQL文本中的一部分，如From子句、Where子句、Group By子句
Query：查询，通常指SQL文本在系统中的一次执行实例
Database：库，一个库可以有多个表；含义类似的有：模式（Schema）
Table：表，一个表可以有很多行；含义类似的有：关系（Relation）
Row：行，一行可以有很多列；含义类似的有：记录（Record）、条目（Item）
Column，列，不再细分的具体值；含义类似的有：字段（Field）

需要强调的是，不同的数据库或大数据系统中的SQL会有一定的实现差异或特有的扩展功能，本文着重于介绍通识性的概念和用法，实际应用时请结合阅读相关系统的官方文档。

SQL查询语句

SQL查询语句用于从零个或多个表中检索数据行，其可以包含子查询语句，还可以用UNION等将多个SELECT语句组合起来获取结果，也可以用WITH子句定义在SELECT中可访问的公共表表达式（CTE，Common Table Expressions）。

OLTP领域追求SQL查询语句简单高效，很多功能特性都会避免使用，甚至不惜拆分多次执行以最大化数据库系统的并发能力；然而，在大数据、OLAP领域虽然也很期待查询能很快执行完成，但查询语句中往往直接夹杂着数据分析型业务逻辑或者ETL需求，从而导致查询语句变得非常长且复杂；因此我们来详细整理一下组成复杂查询语句的各个子句，熟练掌握这些子句才能比较容易看懂并写出满足需求的复杂查询SQL。

SQL查询语句的基本语法结构如下：

[ WITH with_query [, ...] ]
SELECT [ ALL | DISTINCT ] select_expr [, ...]
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ]
[ HAVING condition]
[ WINDOW window_name AS ( window_definition ) [, ...] ]
[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
[ ORDER BY {column_name | expr | position} [ASC | DESC], ... [WITH ROLLUP]]
[ LIMIT {[offset,] row_count | row_count OFFSET offset}]

SELECT子句

SELECT子句是查询语句中必不可少的部分，由SELECT关键字及至少一个标识要检索列的表达式构成，多个表达式之间以英文逗号分隔；支持的表达式包括但不限于如下情况：

字面量，如 SELECT 1, "hello"
所有列的简写，如 SELECT * FROM ...
限定表名或表别名的列，如 SELECT t1.name, t2.* FROM t1, table2 as t2
给选定的列指定别名，如 SELECT name as alias_name FROM ...
用反引号包裹列名或限定表名，如 SELECT name, t1.age FROM t1
运算表达式，如 SELECT 1+1, age+10 FROM ...
对列值做运算的函数，如 SELECT CONCAT(last_name,', ',first_name) FROM ...
关键字ALL/DISTINCT限定是否返回重复行，默认是ALL返回所有行，如 SELECT DISTINCT name FROM ...

运算符与函数

前面提到复杂查询往往夹杂着业务逻辑或ETL需求，因此在SELECT子句中对原始列数据值的处理是必不可少的。要灵活高效的处理数据值就需要有大量运算符与函数，常用的运算符与函数列举如下：

算术运算符：+, -, *, /, DIV, %/MOD
数值函数：ABS、FLOOR、CRC32、RAND、LOG、SIN、COS、TAN 等等
日期与实际函数：STR_TO_DATE、DATE_FORMAT、ADDDATE、CURDATE、TIMESTAMP 等等
字符串函数：CONCAT、LEFT、LENGTH、LIKE、LTRIM、REPLACE、SPLIT、TRIM、UPPER 等等
位操作符与函数：&, ~, |, ^, >>, <<
CAST类型转换函数：CAST(expr AS type)
控制流函数：CASE WHEN、IF、IFNULL、NULLIF 等等
聚合函数：GROUP BY子句中介绍
窗口函数：WINDOW子句中介绍
其他函数：JSON、GEO、IP、正则、加解密、压缩等等

FROM子句

FROM子句用于指定从哪些表中检索数据；如指定多个表则说明使用了连接 Join（联合查询也是Join），支持的书写方式有：

不指定表 SELECT 1, "hello"
指定表名、视图名、临时表名 SELECT ... FROM t1、 SELECT ... FROM v1、 SELECT ... FROM with1
指定表别名 SELECT ... FROM table2 as t2
多表联合查询 SELECT ... FROM t1, t2, t3
括号包含的子查询 SELECT ... FROM (SELECT ... FROM ...)
多表连接查询，JOIN指定连接的左右表，ON指定连接字段 SELECT ... FROM t1 JOIN t2 ON t1.id1 = t2.id2
指定内联表 SELECT * FROM (VALUES 13, 42)

JOIN 连接

对于JOIN 连接查询，更详细的语法格式如下：

table_name join_type table_name [ ON join_condition | USING ( join_column [, ...] ) ]

join_type有以下几种具体的连接方式：

[ INNER ] JOIN：内连接，也叫等值连接，只返回两个表中联结字段相等的行
LEFT [ OUTER ] JOIN：左（外）连接，返回包括左表中的所有记录和右表中联结字段相等的记录
RIGHT [ OUTER ] JOIN：右（外）连接，返回包括右表中的所有记录和左表中联结字段相等的记录
FULL [ OUTER ] JOIN：全（外）连接，返回包括左表和右表中的所有记录
CROSS JOIN：交叉连接，返回两个表的笛卡尔积，返回结果的行数等于两个表行数的乘积

USING用于简化两个表具有相同的连接字段时书写，如下面两种写法是等价的：

SELECT * FROM t1 JOIN t2 ON t1.c1 = t2.c1 AND t1.c2 = t2.c2
SELECT * FROM t1 JOIN t2 USING (c1, c2)

VALUES 内联表

VALUES用于创建一个没有列名的匿名表，但是可以使用带有列别名的AS子句来命名表和列，用法如下：

单个列：SELECT * FROM (VALUES 1, 2, 3)
多个列：SELECT * FROM (VALUES (1,'a'), (2,'b'), (3,'c'))
给列命名：SELECT * FROM (VALUES (1,'a'), (2,'b'), (3,'c')) as t(id, name)

WHERE子句

WHERE子句用于指定选择数据行时必须满足的一个或多个条件；WHERE条件是一个表达式，计算结果为true则选择该行，没有WHERE子句则选择所有行。Where条件中可以使用除分组聚合函数外的系统支持的函数，表达式常用写法如下：

单个比较条件：id = 1、id >= 1、id > 1、id <= 1、id < 1、id <> 1、id != 1
AND多个条件：id = 1 AND name = "peter"、id = 1 && name = "peter"
OR多个条件：id = 1 OR id = 2、id = 1 || id = 2
嵌套多个条件：(id = 1 OR id = 2) AND name = "peter"
IN/NOT IN：id IN (1,2,3)、id NOT IN (1,2,3)
IS NULL / IS NOT NULL：name IS NULL、id IS NOT NULL
BETWEEN AND：id BETWEEN 10 AND 100
LIKE：name LIKE "pet*"
EXISTS/NOT EXISTS：EXISTS (SELECT ...) 、NOT EXISTS (SELECT ...)

GROUP BY子句

GROUP BY 子句用于指定根据某列或某几列对查询结果进行分组，通常是为了分组后对数据做聚合(Aggregation)运算；用法举例：

按单个字段分组计算总数：SELECT name, COUNT(*) FROM orders GROUP BY name
按多个字段分组计算平均数：SELECT name, city, AVG(age) FROM users GROUP BY name, city;
GROUP BY子句中使用序号来引用所需列：SELECT name, city, AVG(age) FROM users GROUP BY 1, 2;

注意：部分系统的实现中SELECT子句中必须使用标准聚合函数（SUM/AVG/COUNT/ARBITRARY等）处理非分组的列，即所有SELECT的列必须是聚合函数或GROUP BY子句中出现的列，否则会报错；而有些系统的实现会对于不在GROUP BY子句中且没有用聚合函数处理的列随机出一行数据。

GROUPING SETS

GROUPING SETS 用于在同一个查询中指定多个GROUP BY的集合，作用相当于多个GROUP BY查询的UNION ALL组合，不属于单个GROUP BY的列被设置为NULL；但如果数据源数据会变化，多个UNION ALL因为多次读取数据所以可能并不等价。

如不考虑数据变化，下面两个SQL等价：

# sql 1
SELECT origin_state, origin_zip, destination_state, sum(package_weight)
FROM shipping
GROUP BY GROUPING SETS (
    (origin_state),
    (origin_state, origin_zip),
    (destination_state));

# sql 2
SELECT origin_state, NULL, NULL, sum(package_weight)
FROM shipping GROUP BY origin_state
UNION ALL
SELECT origin_state, origin_zip, NULL, sum(package_weight)
FROM shipping GROUP BY origin_state, origin_zip
UNION ALL
SELECT NULL, NULL, destination_state, sum(package_weight)
FROM shipping GROUP BY destination_state;

CUBE

CUBE 用于列出所有可能的分组集，下面两个SQL等同：

# sql 1
SELECT origin_state, destination_state, sum(package_weight)
FROM shipping
GROUP BY CUBE (origin_state, destination_state);

# sql 2
SELECT origin_state, destination_state, sum(package_weight)
FROM shipping
GROUP BY GROUPING SETS (
    (origin_state, destination_state),
    (origin_state),
    (destination_state),
    ());

ROLLUP

ROLLUP 用于以层级的方式列出分组集，下面两个SQL等同：

# sql 1
SELECT origin_state, origin_zip, sum(package_weight)
FROM shipping
GROUP BY ROLLUP (origin_state, origin_zip);

# sql 2
SELECT origin_state, origin_zip, sum(package_weight)
FROM shipping
GROUP BY GROUPING SETS ((origin_state, origin_zip), (origin_state), ());

GROUPING() 函数

GROUPING() 函数用于返回一个转换为十进制的二进制位的集合，指示分组中出现哪些列，也就是可以用来标记该行结果是属于哪个GROUPING SET。它必须与GROUPING SETS、CUBE、ROLLUP或GROUP BY一起使用，其参数必须与相应GROUPING SETS、CUBE、ROLLUP或GROUP BY子句中引用的列精确匹配。

GROUPING(col1, ..., colN) -> bigint

为了计算特定行的二进制位的集合，将位分配给参数列，最右边的列是最低有效位。对于给定的分组，如果对应的列包含在分组中，则该位设置为0，否则设置为1。例如下面的查询，第一个分组只包括origin_state列，而不包括origin_zip和destination_state列；为该分组构造的位集是011，其中最高有效位表示origin_state。

SELECT origin_state, origin_zip, destination_state, SUM(package_weight),
       GROUPING(origin_state, origin_zip, destination_state)
FROM shipping
GROUP BY GROUPING SETS (
        (origin_state),                        #  011 => 3
        (origin_state, origin_zip),            #  001 => 1
        (destination_state));                #  110 => 6

聚合运算函数

常用的聚合运算函数有：

ARBITRARY：随机返回一组数据中的任意一个值
AVG：该函数用于计算平均值
COUNT：该函数用于计算记录数
MAX：该函数用于计算最大值
MIN：该函数用于计算最小值
SUM：该函数用于计算汇总值
GROUP_CONCAT：该函数用于将GROUP BY返回结果中属于同一个分组的值连接起来，返回一个字符串结果
STD或STDDEV：返回数值的样本标准差
STDDEV_POP：返回数值的总体标准差
STDDEV_SAMP：返回一组数值（整数、小数或浮点）的样本标准差。
VAR_POP（标准SQL函数）：返回一组数值（整数、小数或浮点）的总体方差
VAR_SAMP：返回一组数值（整数、小数或浮点）的样本方差

一些有用的特性：

COUNT(*)（针对全表）将返回表格中所有存在的行的总数包括值为NULL的行
COUNT(列名)（针对某一列）将返回表格中某一列除去NULL以外的所有行的总数
COUNT(DISTINCT 列名)，得到的结果将是除去值为NULL和重复数据后的结果
- 如COUNT(DISTINCT orderstatus) 计算不重复且不为NULL的订单状态有多少个
SUM 空行为NULL，SUM(NULL) 为NULL，SUM(0) 为0
COUNT 空行为0，COUNT(NULL) 为0，COUNT(0) 为0
有GROUP BY时，空结果被分为0个分组，求COUNT输出空
无GROUP BY时，空结果在默认分组，求COUNT输出0

HAVING子句

HAVING子句用于指定过滤分组行（GROUP BY后的行）条件；WHERE子句会在应用GROUP BY之前就过滤掉数据行，而HAVING子句则过滤 GROUP BY创建的分组行，因此其条件表达式中的列必须是GROUP BY子句中出现的分组列、处理分组列的函数、处理其他列的聚合函数。用法如下：

分组列：... GROUP BY name HAVING ( name = "peter" )
处理分组列的函数： ... GROUP BY name HAVING ( UPPER(name) = "PETER" )
处理其他列的聚合函数：... GROUP BY name HAVING ( name = "peter" or AVG(age) > 20 )
没有GOURP BY时全局聚合函数： ... HAVING ( AVG(age) > 20 )

WINDOW子句

WINDOW子句用于定义一个可以在OVER关键字触发窗口函数时引用的窗口；也可以将窗口定义直接写在OVER关键字之后而不使用WINDOW子句，如下两个示例语句是等价的：

# sql 1
SELECT
  val,
  ROW_NUMBER() OVER w AS 'row_number',
  RANK()       OVER w AS 'rank',
  DENSE_RANK() OVER w AS 'dense_rank'
FROM numbers
WINDOW w AS (ORDER BY val);

# sql 2
SELECT
  val,
  ROW_NUMBER() OVER (ORDER BY val) AS 'row_number',
  RANK()       OVER (ORDER BY val) AS 'rank',
  DENSE_RANK() OVER (ORDER BY val) AS 'dense_rank'
FROM numbers;

WINDOW子句书写在在HAVING子句之后、 ORDER BY子句之前，同样窗口函数也是在HAVING子句和ORDER BY子句之间运行，语法如下：

WINDOW window_name AS (window_spec) [, window_name AS (window_spec)] ...

# window_spec
[window_name] [partition_clause] [order_clause] [frame_clause]

# partition_clause + order_clause + frame_clause
PARTITION BY a ORDER BY b RANGE|ROWS BETWEEN start AND end

窗口定义包含以下三个部分

分区规范：用于将输入行分散到不同的分区中，过程和GROUP BY子句的分散过程相似
排序规范：决定输入数据行在窗口函数中执行的顺序
窗口区间：指定计算数据的窗口边界。窗口区间支持RANGE、ROWS两种模式：
- RANGE按照计算列值的范围进行定义，ROWS按照计算列的行数进行范围定义
- RANGE、ROWS 中可以使用 BETWEEN start AND end 指定边界可取值：
  - CURRENT ROW，当前行
  - N PRECEDING，前n行
  - UNBOUNDED PRECEDING，直到第1行
  - N FOLLOWING，后n行
  - UNBOUNDED FOLLOWING，直到最后1行

查询示例：

SELECT year, country, profit,
    SUM(profit) OVER (
    PARTITION BY country ORDER BY year ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
  ) AS slidewindow 
FROM testwindow;

常用窗口运算函数：

聚合函数
排序函数
- CUME_DIST：返回一组数值中每个值的累计分布
- RANK：返回数据集中每个值的排名
- DENSE_RANK：返回一组数值中每个数值的排名
- NTILE：将每个窗口分区的数据分散到桶号从1到n的n个桶中
- ROW_NUMBER：根据行在窗口分区内的顺序，为每行数据返回一个唯一的有序行号，行号从1开始
- PERCENT_RANK：返回数据集中每个数据的排名百分比，其结果由(r - 1) / (n - 1)计算得出。其中r为RANK()计算的当前行排名， n为当前窗口分区内总的行数
值函数
- FIRST_VALUE：返回窗口分区第1行的值
- LAST_VALUE返回窗口分区最后1行的值
- LAG：返回窗口内距离当前行之前偏移offset后的值
- LEAD：返回窗口内距离当前行偏移offset后的值
- NTH_VALUE：返回窗口内偏移指定offset后的值，偏移量从1开始

ORDER BY子句

ORDER BY子句用于指定一个或多个表达式来对结果集进行排序，在GROUP BY或HAVING子句之后执行；更详细的语法如下：

ORDER BY expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...]

用法举例：

单个列：ORDER BY id ASC
多个列：ORDER BY id ASC, status DESC
指定NULL值排在最前面：ORDER BY id ASC NULLS FIRST
使用序号来引用所需列：SELECT name, city ... ORDER BY 1, 2;

LIMIT子句

LIMIT子句用于限制结果集中的行数，LIMIT子句可以和ORDER BY子句一起使用，对结果集排序后取前多少个，也就是TOP N；还可以指定offset来跳过结果集前面的行用于查询结果分页；对于分布式系统来说，如果没有和ORDER BY子句配合使用，多次执行返回的数据将会是不同的；LIMIT ALL与省略LIMIT子句相同；用法举例：

不限制行数：SELECT * FROM orders LIMIT ALL
单独使用：SELECT * FROM orders LIMIT 5
和ORDER BY配合使用：SELECT * FROM orders ORDER BY id DESC LIMIT 5
指定offeset跳过行：SELECT * FROM orders LIMIT 100, 5
使用OFFSET子句跳过行：SELECT * FROM orders OFFSET 100 LIMIT 5

WITH子句

WITH子句用于定义一个或者多个在主查询中使用的命名临时表，以扁平化嵌套查询或简化子查询。在部分系统的实现中，WITH定义的临时表可以作为CTE（通用表表达式 Common Table Express）从而只需执行一次以提高性能，但也有的系统只是将其对应的SQL内联到用到的地方从而会被执行多次，具体需要查看对应系统的文档。

在类MySQL系统的语法中，WITH子句通常放在SELECT、UPDATE、DELETE语句之前，对于包含SELECT语句的语句则是紧挨着SELECT：

WITH...SELECT...
WITH...UPDATE...
WITH...DELETE...
SELECT...WHERE id IN(WITH...SELECT...)...
SELECT * FROM (WITH ... SELECT ...) AS dt ...
INSERT...WITH...SELECT...
REPLACE...WITH...SELECT...
CREATE TABLE...WITH...SELECT...
CREATE VIEW...WITH...SELECT...
EXPLAIN...WITH...SELECT...

下面的等价语句展示了WITH的用法

# sql 1
SELECT a, b
FROM (
  SELECT a, MAX(b) AS b FROM t GROUP BY a
) AS x;

# sql 2
WITH x AS (SELECT a, MAX(b) AS b FROM t GROUP BY a)
SELECT a, b FROM x;

WITH子句可用于多子查询：

WITH
  t1 AS (SELECT a, MAX(b) AS b FROM x GROUP BY a),
  t2 AS (SELECT a, AVG(d) AS d FROM y GROUP BY a)
SELECT t1.*, t2.*
FROM t1
JOIN t2 ON t1.a = t2.a;

WITH子句中定义的关系可以互相连接

WITH
  x AS (SELECT a FROM t),
  y AS (SELECT a AS b FROM x),
  z AS (SELECT b AS c FROM y)
SELECT c FROM z;

子查询

子查询是一条语句中的SELECT语句；

标量子查询

标量子查询是和外围查询不相关且只返回零行或一行一列的子查询，标量子查询产生多个行或多个列是错误的，如果没有产生行则返回值为NULL。标量子查询通常用于和外围查询的某个列做比较，支持 = > < >= <= <> != <=> 等比较运算符：

SELECT name FROM nation
WHERE regionkey = (SELECT max(regionkey) FROM region)

IN、ANY/SOME、ALL 子查询

IN 用于判断子查询产生的任何值是否有等于所提供的表达式，IN后面的子查询必须恰好生成一个列:

SELECT name FROM nation WHERE regionkey IN (SELECT regionkey FROM region)

ANY关键字必须跟在比较操作符后面，意思是“如果子查询返回的列中的任何值的比较结果为TRUE，则返回TRUE”，SOME 是ANY的别名 :

SELECT name FROM nation WHERE regionkey = ANY (SELECT regionkey FROM region); # 子查询里 = ANY 和 IN 等价
SELECT name FROM nation WHERE regionkey > SOME (SELECT regionkey FROM region);

ALL关键字也必须跟在比较操作符后面，意思是“如果子查询返回的列中的所有值的比较结果都是TRUE，则返回TRUE。”例如：

SELECT s1 FROM t1 WHERE s1 > ALL (SELECT s1 FROM t2);

# NOT IN 与 <> ALL 等价
SELECT s1 FROM t1 WHERE s1 <> ALL (SELECT s1 FROM t2); 
SELECT s1 FROM t1 WHERE s1 NOT IN (SELECT s1 FROM t2);

EXISTS 和 NOT EXISTS 子查询

如果子查询返回任何行，EXISTS子查询为TRUE，NOT EXISTS子查询为FALSE：
SELECT column1 FROM t1 WHERE EXISTS (SELECT * FROM t2);
上面的例子中如果t2包含任何行，即使是只有NULL值的行，EXISTS条件为TRUE；这样的查询实际上没有什么意义，通常EXISTS/NOT EXISTS 子查询中的条件总是和外面的查询有关：

SELECT DISTINCT store_type FROM stores WHERE EXISTS (
  SELECT * FROM cities_stores WHERE cities_stores.store_type = stores.store_type);

关联子查询

如上面例子中，当子查询引用子查询之外的列时称为关联子查询。逻辑上来说，关联子查询将对周围查询中的每一行计算子查询，在子查询的任何单个求值过程中，引用的列都是常量。关联子查询有时候会比较复杂，部分系统的实现对关联查询可能支持并不完善，这里不做过多展开，请查阅相关系统的文档。

SELECT * FROM t1 WHERE column1 = ANY (
  SELECT column1 FROM t2 WHERE t2.column2 = t1.column2);

# 多层时从里到外寻找关联列，如下面语句 最内层的x.column2 找到是t2的列
SELECT column1 FROM t1 AS x
  WHERE x.column1 = (SELECT column1 FROM t2 AS x
    WHERE x.column1 = (SELECT column1 FROM t3
      WHERE x.column2 = t3.column1));

集合查询

集合查询是指将多个SELECT语句的结果组合成一个结果集，有 UNION、INTERSECT和EXCEPT 三种集合运算。集合运算将null值作为普通值处理，即如有两行数据的列值都为null会被认为是重复行。

UNION：返回两个查询表达式的集合运算。
UNION ALL：ALL关键字用于保留UNION中产生的重复行。
INTERSECT：返回只有在两个集合中同时出现的行，返回结果将删除两个集合中的重复行。

EXCEPT：先删除两个集合中重复的数据行，返回只在第一个集合中出现且不在第二个集合中出现的行。

SELECT * FROM t1 UNION SELECT * FROM t2;
SELECT * FROM t1 UNION ALL SELECT * FROM t2;
SELECT * FROM t1 INTERSECT SELECT * FROM t2;
SELECT * FROM t1 EXCEPT SELECT * FROM t2;

要将ORDER BY或LIMIT子句应用于单个SELECT，请将SELECT用括号括起来，并将子句放在括号中：

(SELECT a FROM t1 WHERE a=10 AND B=1 ORDER BY a LIMIT 10)
UNION
(SELECT a FROM t2 WHERE a=11 AND B=2 ORDER BY a LIMIT 10);

单个语句中的ORDER BY并不意味着这些行在最终结果中出现的顺序，UNION在默认情况下会生成无序的行集；如果上面的语句有ORDER BY没有LIMIT，则ORDER BY其实没有意义可以优化掉。要使用ORDER BY或LIMIT子句对整个UNION结果进行排序或限制，请将各个SELECT语句括起来，并将ORDER BY或LIMIT放在最后一个语句的后面：

(SELECT a FROM t1 WHERE a=10 AND B=1)
UNION
(SELECT a FROM t2 WHERE a=11 AND B=2)
ORDER BY a LIMIT 10;

参考资料

Presto SELECT文档：https://prestodb.io/docs/curr...
PostgresSQL SELECT文档：http://postgres.cn/docs/14/sq...
MySQL SELECT Statement文档 : https://dev.mysql.com/doc/ref...
AnalyticDB MySQL SELECT 文档：https://help.aliyun.com/docum...

SQL SELECT 查询语句 用法详解