全部产品
云市场

SELECT

更新时间:2019-03-17 17:16:38

语法

  1. [ WITH with_query [, ...] ]
  2. SELECT [ ALL | DISTINCT ] select_expr [, ...]
  3. [ FROM from_item [, ...] ]
  4. [ WHERE condition ]
  5. [ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ]
  6. [ HAVING condition]
  7. [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
  8. [ ORDER BY expression [ ASC | DESC ] [, ...] ]
  9. [ LIMIT [ count | ALL ] ]

参数

  • from_item:有以下两种形式

    1. table_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
    1. from_item join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]
  • join_type:表的连接类型

    1. [ INNER ] JOIN
    2. LEFT [ OUTER ] JOIN
    3. RIGHT [ OUTER ] JOIN
    4. FULL [ OUTER ] JOIN
  • grouping_element

    1. ()
    2. expression

WITH 从句

这个 WITH 从句定义了一个命名好的关系以供在一个查询里面使用。 它可以扁平化嵌套查询或者简化子查询。 例如,下面的查询是等价的:

  1. SELECT a, b
  2. FROM (
  3. SELECT a, MAX(b) AS b FROM t GROUP BY a
  4. ) AS x;
  5. WITH x AS (SELECT a, MAX(b) AS b FROM t GROUP BY a)
  6. SELECT a, b FROM x;

也同意适用于多子查询的情况:

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

另外, 在 WITH 分句中定义的关系可以互相连接:

  1. WITH
  2. x AS (SELECT a FROM t),
  3. y AS (SELECT a AS b FROM x),
  4. z AS (SELECT b AS c FROM y)
  5. SELECT c FROM z;

GROUP BY从句

这个 GROUP BY 分句对 SELECT 语句的输出进行分组,分组中是匹配值的数据行。一个简单的 GROUP BY 分句可以包含 由输入列组成的任何表达式或者或列序号(从1开始).

以下查询是等价的。 他们都对 nationkey 列进行分组, 第一个查询使用列序号, 第二个查询使用列名:

  1. SELECT count(*), nationkey FROM customer GROUP BY 2;
  2. SELECT count(*), nationkey FROM customer GROUP BY nationkey;

在查询语句中没有指定列名的情况下, GROUP BY 子句也可以将输出进行分组。 例如,以下查询使用列 mktsegment 进行分组, 统计出 customer 表的行数。:

  1. SELECT count(*) FROM customer GROUP BY mktsegment;
  1. _col0
  2. -------
  3. 29968
  4. 30142
  5. 30189
  6. 29949
  7. 29752
  8. (5 rows)

SELECT 语句中使用 GROUP BY 子句时, 所有输出的列要么是聚会函数, 要么是 GROUP BY 子句中的列。

HAVING 从句

HAVING 子句与聚合函数以及 GROUP BY 子句共同使用, 用来控制选择分组。 HAVING 子句去掉不满足条件的分组。 在分组和聚合计算完成后,HAVING 对分组进行过滤。 以下示例查询 customer 表,并进行分组, 查出账户余额大于指定值的记录:

  1. SELECT count(*), mktsegment, nationkey,
  2. CAST(sum(acctbal) AS bigint) AS totalbal
  3. FROM customer
  4. GROUP BY mktsegment, nationkey
  5. HAVING sum(acctbal) > 5700000
  6. ORDER BY totalbal DESC;
  1. _col0 | mktsegment | nationkey | totalbal
  2. -------+------------+-----------+----------
  3. 1272 | AUTOMOBILE | 19 | 5856939
  4. 1253 | FURNITURE | 14 | 5794887
  5. 1248 | FURNITURE | 9 | 5784628
  6. 1243 | FURNITURE | 12 | 5757371
  7. 1231 | HOUSEHOLD | 3 | 5753216
  8. 1251 | MACHINERY | 2 | 5719140
  9. 1247 | FURNITURE | 8 | 5701952
  10. (7 rows)

UNION | INTERSECT | EXCEPT 从句

UNION INTERSECT 和 EXCEPT 都是全集合操作符。这些分句被用来组合多于一个查询语句的结果最终形成一个结果:

query UNION [ALL | DISTINCT] query

query INTERSECT query

query EXCEPT query

参数 ALL 或 DISTINCT 控制最终结果集包含哪些行。如果指定参数 ALL ,则包含全部行,即使行完全相同。如果指定参数 DISTINCT , 则合并结果集,结果集只有唯一不重复的行。如果不指定参数,执行时默认使用 DISTINCT。

多个集合操作符会从做到有的被处理,除非顺序通过括弧被显示指定。另外,INTERSECT 比 EXCEPT and UNION 有更高的优先级,这意味着 A UNION B INTERSECT C EXCEPT D 和这个表达式是相同的 A UNION (B INTERSECT C) EXCEPT D.

UNION

UNION 把所有结果集两个结果集合并起来。下面是一个最简单的可能使用 UNION 分句的例子。它选择了值 13 并且合并了第二个选择的值 42,把他们结合起来:

  1. SELECT 13
  2. UNION
  3. SELECT 42;
  1. _col0
  2. -------
  3. 13
  4. 42
  5. (2 rows)

INTERSECT

INTERSECT 只返回那些在同时在第一个和第二个查询里面都出现的行的结合。下面的例子是一个最简单的可能使用 INTERSECT 分句的例子。 它选择了值 13 和 42 并把他们和第二个查询选择的值 13 做合并。 既然 42 值在第一个查询的结果集中, 它并不会被包含在最终的结果集里面:

  1. SELECT 13
  2. INTERSECT
  3. SELECT 13;
  1. _col0
  2. -------
  3. 13
  4. (2 rows)

EXCEPT

EXCEPT 返回那些行仅存在于第一个查询结果集不在第二个查询结果集中。下面是最简单的使用 EXCEPT 分句的例子。 它选择了值42 并把他们和第二个查询选择的值 13 做合并。 既然 13 也同时存在在第二个查询结果集中, 它不会被包含在最终的结果集中:

  1. SELECT 42
  2. EXCEPT
  3. SELECT 13;
  1. _col0
  2. -------
  3. 42
  4. (2 rows)

ORDER BY Clause

ORDER BY 分句被用来排序一个结果集通过一个或者多个输出表达式:

ORDER BY expression [ ASC | DESC ] [, ...]

每个表达式由列名或列序号(从1开始)组成。 ORDER BY 子句作为查询的最后一步, 在 GROUP BY 和 HAVING 子句之后。

LIMIT Clause

LIMIT 分句限制了最终结果集的行数。 LIMIT ALL 和略去 LIMIT 分句的结果一样。 以下示例为查询一个大表, LIMIT 子句限制它只输出5行(因为查询没有 ORDER BY, 所以随意返回几行):

SELECT orderdate FROM orders LIMIT 5;

  1. o_orderdate
  2. -------------
  3. 1996-04-14
  4. 1992-01-15
  5. 1995-02-01
  6. 1995-11-12
  7. 1992-04-26
  8. (5 rows)

Joins

它允许你去合并来自多个关联的数据。

交叉连接

  1. SELECT *
  2. FROM nation, region;

nation 表包含了25行 region 表包含了 5 行, 所以结果两个表最终产生了 125 行:

子查询

一个子查询是一个包含了查询的表达式。子查询当它引用子查询之外的列时是相关的。 逻辑上来说, 子查询会被被它的外围查询逐行评估。被引用的列将因此是固定的在子查询的评估过程中。

Note

对于向关联的子查询是受限的,并不是每一个形式都是支持的。

EXISTS

EXISTS 断言决定是否一个子查询可以返回任何行:

  1. SELECT name
  2. FROM nation
  3. WHERE EXISTS (SELECT * FROM region WHERE region.regionkey = nation.regionkey)

IN

IN 断言决定一个子查询返回的值是否在一个被给定的结果集中。IN 的结果依照对 nulls 的标准结果。子查询必须产生仅仅一列:

  1. SELECT name
  2. FROM nation
  3. WHERE regionkey IN (SELECT regionkey FROM region)

标量子查询

标量子查询是一个非关联的子查询,他会返回零或者1行数据。如果这个子查询返回了多以一行的数据,那将是个错误。如果子查询没有返回任何行,则返回的结果是NULL:

  1. SELECT name
  2. FROM nation
  3. WHERE regionkey = (SELECT max(regionkey) FROM region)

当前只支持单列可以用在标量子查询里。