7.2.2. WHERE 子句

WHERE 子句 的语法是

WHERE search_condition

这里的 search_condition 是任意返回一个类型为boolean的值表达式 （参阅 Section 4.2）。

在完成对FROM子句的处理之后，生成的每一行都会对搜索条件进行检查。 如果该条件的结果是真，那么该行输出到输出表中，否则（也就是说， 如果结果是假或空）就把它抛弃。搜索条件通常至少要引用一些在FROM子句里生成的列； 这不是必须的，但如果不是这样的话，那么WHERE子句就没什么用了。

    注意: 内连接的连接条件既可以写在 WHERE 子句也可以写在 JOIN 子句里。 比如，这些表表达式是等效的：

    FROM a, b WHERE a.id = b.id AND b.val > 5

    和

    FROM a INNER JOIN b ON (a.id = b.id) WHERE b.val > 5

    或者可能还有

    FROM a NATURAL JOIN b WHERE b.val > 5

    你想用哪个只是一个风格问题。FROM子句里的JOIN语法可能不那么容易移植到其它产品中。 对于外部连接（outer join）而言，我们在任何情况下都没有选择：它们必须在FROM子句中完成。 外部连接的 ON/USING 子句不等于WHERE条件， 因为它判断最终结果中行的增（那些不匹配的输入行）和删。

这里是一些 WHERE 子句的例子：

SELECT ... FROM fdt WHERE c1 > 5

SELECT ... FROM fdt WHERE c1 IN (1, 2, 3)

SELECT ... FROM fdt WHERE c1 IN (SELECT c1 FROM t2)

SELECT ... FROM fdt WHERE c1 IN (SELECT c3 FROM t2 WHERE c2 = fdt.c1 + 10)

SELECT ... FROM fdt WHERE c1 BETWEEN (SELECT c3 FROM t2 WHERE c2 = fdt.c1 + 10) AND 100

SELECT ... FROM fdt WHERE EXISTS (SELECT c1 FROM t2 WHERE c2 > fdt.c1)

在上面的例子里，fdt是从FROM子句中派生的表。 那些不符合WHERE子句的搜索条件的行从fdt中删除。 请注意我们把标量子查询当做一个值表达式来用。 就好象任何其它查询一样，子查询里可以使用复杂的表表达式。 同时还请注意fdt是如何引用子查询的。 把c1修饰成fdt.c1只有在c1是该子查询生成的列的名字时才是必须的。 但修饰列名字可以增加语句的准确性，即使有时候不是必须的。 这个例子就演示了字段名字范围如何从外层查询扩展到它的内层查询．
7.2.3. GROUP BY 和 HAVING 子句

在通过了WHERE过滤器之后，生成的输出表可以继续用GROUP BY 子句进行分组，然后用HAVING子句删除一些分组行。

SELECT select_list
        FROM ...
        [WHERE ...]
        GROUP BY grouping_column_reference [, grouping_column_reference]...

GROUP BY 子句 用于把那些在表中所列出的列上共享相同值的行聚集在一起。 这些列的列出顺序并没有什么关系。 效果是把每组共享相同值的行缩减为一个组行，它代表该组里的所有行。 这样就可以删除输出里的重复和/或计算应用于这些组的聚集。 比如：

=> SELECT * FROM test1;
x | y
---+---
a | 3
c | 2
b | 5
a | 1
(4 rows)

=> SELECT x FROM test1 GROUP BY x;
x
---
a
b
c
(3 rows)

在第二个查询里，我们不能写成 SELECT * FROM test1 GROUP BY x， 因为字段 y 里没有哪个值可以和每个组相关联起来。 被分组的字段可以在选择列表中引用是因为它们每个组都有单一的数值。

通常，如果一个表被分了组，那么没有在分组中引用的字段都不能引用，除了在聚集表达式中以外。 一个带聚集表达式的例子是：

=> SELECT x, sum(y) FROM test1 GROUP BY x;
x | sum
---+-----
a |   4
b |   5
c |   2
(3 rows)

这里的 sum 是一个聚集函数，它在整个组上计算一个数值。 有关可用的聚集函数的更多信息可以在 Section 9.15 中找到。

    提示: 没有聚集表达式的分组实际上计算了一个字段中独立数值的集合。 我们也可以用 DISTINCT 子句实现（参阅Section 7.3.3）。

这里是另外一个例子：它计算每种产品的总销售额。（而不是所有产品的总销售额）。

SELECT pid, p.name, (sum(s.units) * p.price) AS sales
  FROM products p LEFT JOIN sales s USING ( pid )
  GROUP BY pid, p.name, p.price;

在这个例子里，字段pid， p.name，和p.price必须在GROUP BY子句里， 因为它们都在查询选择列表里被引用到。 （根据产品表具体的设置的不同，名字和价格可能和产品 ID 完全无关，因此理论上额外的分组可能是不必的， 但是这些尚未实现。） 字段s.units不必在GROUP BY列表里，因为它只是在一个聚集表达式（sum(...)） 里使用，它代表一组产品的销售额。对于每种产品，这个查询都返回一个该产品的所有销售额的总和。

在严格的 SQL 里，GROUP BY只能对源表的列进行分组，但 PostgreSQL 把这个扩展为也允许GROUP BY那些在选择列表中的字段。也允许对值表达式进行分组，而不仅是简单的字段．

如果一个表已经用GROUP BY子句分了组，然后你又只对其中的某些组感兴趣， 那么就可以用HAVING子句，它很象WHERE子句，用于删除一个分了组的表中的一些组。 语法是：

SELECT select_list FROM ... [WHERE ...] GROUP BY ... HAVING boolean_expression

在 HAVING 子句中的表达式可以引用分组的表达式和未分组的表达式（后者必须涉及一个聚集函数）。

例子：

=> SELECT x, sum(y) FROM test1 GROUP BY x HAVING sum(y) > 3;
x | sum
---+-----
a |   4
b |   5
(2 rows)

=> SELECT x, sum(y) FROM test1 GROUP BY x HAVING x < 'c';
x | sum
---+-----
a |   4
b |   5
(2 rows)

然后是一个更现实的例子：

SELECT product_id, p.name, (sum(s.units) * (p.price - p.cost)) AS profit
    FROM products p LEFT JOIN sales s USING (product_id)
    WHERE s.date > CURRENT_DATE - INTERVAL '4 weeks'
    GROUP BY product_id, p.name, p.price, p.cost
    HAVING sum(p.price * s.units) > 5000;

在上面的例子里，WHERE子句用于那些非分组的字段选择数据行。 （表达式只是对那些最近四周发生的销售为真）。 而HAVING子句选择那些单价超过 5000 的组的行。 请注意聚集函数不需要在查询中的所有地方都一样。

7.3. 选择列表

如前面的小节说明的那样， 在 SELECT 命令里的表表达式构造了一个中介性的虚拟表， 方法可能有组合表，视图，删除行，分组等等。 这个表最后传递给选择列表处理。 选择列表判断中间表的哪个字段最终实际输出。

7.3.1. 选择列表项

最简单的选择列表类型是 *，它发出表表达式生成的所有字段。 否则，一个选择列表是一个逗号分隔的值表达式的列表， （和在Section 4.2 里定义的一样）。 比如，它可能是一个字段名字的列表：

SELECT a, b, c FROM ...字段名字a，b，和c要么是在 FROM子句里引用的表中字段的实际名字， 要么是象 Section 7.2.1.2 里解释的那样的别名。 在选择列表里的名字空间和在 WHERE 子句里的名字空间是一样的， 除非你使用了分组，这时候它和HAVING子句一样。

如果超过一个表有同样的字段名字，那么你还必须给出表名字，象

SELECT tbl1.a, tbl2.a, tbl1.b FROM ...（又见 Section 7.2.2）。

如果将任意值表达式用于选择列表，那么它在概念上向返回的表中增加了一个新的虚拟字段。 值表达式为结果的每一行进行一次计算，计算之前用该行的数值代换任何表达式里引用的字段。 不过选择列表中的这个表达式并非一定要引用来自FROM子句中表表达式里面的字段， 比如，它也可以是任意常量算术表达式。

7.3.2. 字段标签
选择列表中的记录可以赋予名字，用于进一步的处理。 这里的"进一步处理"是一个可选的排序声明和客户端应用（比如，用于显示的字段头）。比如：

SELECT a AS value, b + c AS sum FROM ...
如果没有使用AS声明字段名字，那么系统赋予一个缺省值。对于简单的字段引用， 它是该字段的名字。对于函数调用，它是函数的名字。对于复杂表达式，系统会生成一个通用的名字。

注意: 输出字段的命名和在FROM子句里的命名是不一样的 （参阅 Section 7.2.1.2）。 这个管道实际上允许你对同一个列命名两次，但是在选择列表中选择的名字是要传递的名字。

7.3.3. DISTINCT
在处理完选择列表之后，生成的表可以删除重复行。 我们可以直接在 SELECT 后面写上 DISTINCT 关键字声明：

SELECT DISTINCT select_list ...（如果不用 DISTINCT 你可以用 ALL 声明保留所有行的缺省行为。）

显然，如果两行里至少有一个列有不同的值，那么我们认为它是独立的。空值在这种考虑中认为是相同的。

另外，我们还可以用任意表达式来判断什么行可以认为是独立的：

SELECT DISTINCT ON (expression [, expression ...]) select_list ...这里 expression 是任意值表达式， 它为所有行计算。如果一个行集合里所有行计算出的该表达式的值是一样的， 那么我们认为它们是重复的并且因此只有第一行保留在输出中。 请注意这里的一个集合的"第一行"是不可预料的， 除非你在足够多的字段上对该查询排了序，保证到达DISTINCT过滤器的行的顺序是唯一的。 （DISTINCT ON处理是发生在ORDER BY排序后面的。）

DISTINCT ON子句不是 SQL 标准的一部分， 有时候有人认为它是一个糟糕的风格，因为它的结果是不可判定的。 如果用有选择的GROUP BY和在FROM中的子查询，那么我们可以避免使用这个构造， 但是通常它是更方便的候选方法。

7.4. 组合查询

两个查询的结果可以用集合操作并，交，差进行组合。语法是

query1 UNION [ALL] query2
query1 INTERSECT [ALL] query2
query1 EXCEPT [ALL] query2query1 和 query2 都是可以使用我们到此为止讨论的所有查询特性的查询。集合操作也可以嵌套和级连，比如

query1 UNION query2 UNION query3实际上说的是

(query1 UNION query2) UNION query3
UNION 有效地把 query2 的结果附加到 query1 的结果上（不过我们不能保证这就是这些行实际返回的顺序）并且删除结果中所有重复的行， 就象DISTINCT做的那样，除非你声明了UNION ALL。

INTERSECT 返回那些同时存在于 query1 的结果中和 query2的结果中的行，除非声明了INTERSECT ALL， 否则所有重复行都被删除。

EXCEPT 返回所有在 query1 的结果中但是不在 query2 的结果中的行。 （有时侯这叫做两个查询的差。） 除非声明了 EXCEPT ALL，否则所有重复行都被删除。

为了计算两个查询的并，交，差，这两个查询必须是"并集兼容的"，也就意味着它们都返回同样数量的列， 并且对应的列有兼容的数据类型，象 Section 10.5 里描述的那样。

7.5. 行排序

在一个查询生成一个输出表之后（在处理完选择列表之后）， 你还可以对它进行排序。如果没有选择排序，那么行将以未声明的顺序返回。 这时候的实际顺序将取决于扫描和连接规划类型和在磁盘上的顺序，但是肯定不能依赖这些东西。 一定的顺序只能在明确地使用了排序步骤之后才能保证。

ORDER BY子句声明了排序顺序

SELECT select_list
        FROM table_expression
        ORDER BY column1 [ASC | DESC] [, column2 [ASC | DESC] ...]column1，等指向选择列表： 它可以是一个列的名字（可以是明确的列标签也可以是缺省名字，象 Section 7.3.2 里解释的那样） 或者是一个列的编号。一些例子：

SELECT a, b FROM table1 ORDER BY a;
SELECT a + b AS sum, c FROM table1 ORDER BY sum;
SELECT a, sum(b) FROM table1 GROUP BY a ORDER BY 1;
作为对标准 SQL 的扩展，PostgreSQL 还允许对任意表达式进行排序：

SELECT a, b FROM table1 ORDER BY a + b;还允许引用 FROM 子句中的字段名，但是没有出现在选择列表中的字段名字：

SELECT a FROM table1 ORDER BY b;但是这个特性在涉及UNION，INTERSECT，或 EXCEPT的查询中是不能用的，而且也不可移植到其它 DBMS。

声明的每个字段都可以跟着一个可选的ASC或DESC 以设置排序方向。 缺省是ASC。升序先输出小的数值，这里的"小"是以 < 操作符的角度定义的。类似的是， 降序是以 > 操作符来判断的。

如果声明了多于一个排序列，那么在前面的排序字段排序相等的情况下使用后面的排序项做进一步排序。

7.6. LIMIT 和 OFFSET

附加上 LIMIT和OFFSET 子句之后，你就可以检索原来查询语句查询出来的结果中的一部分数据行：

SELECT select_list
        FROM table_expression
        [LIMIT { number | ALL }] [OFFSET number]
如果给出了一个限制计数，那么返回不超过那么多的行。 （但可能更少些，因为查询本身可能生成的行数就比较少。） LIMIT ALL和省略 LIMIT子句一样。

OFFSET说明在开始返回行之前忽略多少行。 OFFSET 0和省略OFFSET子句是一样的。 如果OFFSET和LIMIT都出现了， 那么在计算LIMIT个行之前忽略OFFSET行。

如果使用LIMIT，那么用ORDER BY 子句把结果行约束成一个唯一的顺序是一个好主意。 否则你就会拿到一个不可预料的该查询的行的子集。 — 你要的可能是第十到二十行，但以什么顺序的十到二十？ 除非你声明了ORDER BY，否则顺序是不知道的。

查询优化器在生成查询规划的时候会考虑LIMIT，因此如果你给 LIMIT和OFFSET不同的东西，那么你很可能收到不同的规划（产生不同的行顺序）。 因此，使用不同的LIMIT/OFFSET值选择不同的查询结果的子集将生成不一致的结果， 除非你用ORDER BY强制一个可预料的顺序。这可不是臭虫； 这是一个很自然的结果，因为 SQL 没有许诺把查询的结果按照任何特定的顺序发出，除非用了ORDER BY来约束顺序。

OFFSET 子句忽略的行仍然需要在服务器内部计算；因此，一个很大的 OFFSET 可能还是不够有效率的。

8.1. 数值类型
8.1.1. 整数类型
8.1.2. 任意精度数值
8.1.3. 浮点数类型
8.1.4. Serial（序号）类型
8.2. 货币类型
8.3. 字符类型
8.4. 二进制数据类型
8.5. 日期/时间类型
8.5.1. 日期/时间输入
8.5.2. 日期/时间输出
8.5.3. 时区
8.5.4. 内部
8.6. 布尔类型
8.7. 几何类型
8.7.1. Point（点）
8.7.2. 线段
8.7.3. Box（方）
8.7.4. Path（路径）
8.7.5. Polygon（多边形）
8.7.6. Circle（圆）
8.8. 网络地址数据类型
8.8.1. inet
8.8.2. cidr
8.8.3. inet 与 cidr 对比
8.8.4. macaddr
8.9. 位串类型
8.10. 数组
8.10.1. 数组类型的声明
8.10.2. 数组值输入
8.10.3. 访问数组
8.10.4. 修改数组
8.10.5. 在数组中检索
8.10.6. 数组输入和输出语法
8.11. 复合类型
8.11.1. 声明复合类型
8.11.2. 复合类型值输入
8.11.3. 访问复合类型
8.11.4. 修改复合类型
8.11.5. 复合类型输入和输出语法
8.12. 对象标识符类型
8.13. 伪类型

PostgreSQL 有着丰富的数据类型可用。 用户可以使用 CREATE TYPE 命令为 PostgreSQL 增加新的数据类型。

Table 8-1 显示了所有内置的普通数据类型。 在"别名"列里列出的大多数可选名字都是因历史原因 PostgreSQL 在内部使用的名字。 另外，还有一些内部使用的或者废弃的类型也可以用，但没有在这里列出。

Table 8-1. 数据类型

名字 别名 描述
bigint int8 有符号 8 字节整数
bigserial serial8 自增八字节整数
bit [ (n) ]   定长位串
bit varying [ (n) ] varbit 变长位串
boolean bool 逻辑布尔量 （真/假）
box   平面中的长方形
bytea   二进制数据（"字节数组"）
character varying [ (n) ] varchar [ (n) ]  变长字符串
character [ (n) ]  char [ (n) ]  定长字符串
cidr   IPv4 或者 IPv6 网络地址
circle   平面中的圆
date   日历日期（年，月，日）
double precision float8 双精度浮点数字
inet   IPv4 或者 IPv6 网络地址
integer int，int4 四字节长有符号整数
interval [ (p) ]    时间间隔
line   平面中的无限长直线
lseg   平面中的线段
macaddr   MAC 地址
money   货币金额
numeric [ (p, s) ] decimal [ (p, s) ] 可选精度的准确数字
path   平面中的几何路径
point   平面中的点
polygon   平面中的封闭几何路径
real float4 单精度浮点数
smallint int2 有符号两字节整数
serial serial4 自增四字节整数
text   变长字符串
time [ (p) ] [ without time zone ]   一天里的时间
time [ (p) ] with time zone timetz 一天里的时间，包括时区
timestamp [ (p) ] [ without time zone ]   日期和时间
timestamp [ (p) ] with time zone timestamptz 日期和时间

兼容性: 下列类型（或者那样拼写的）是SQL声明的： bit，bit varying，boolean， char，character，character varying，varchar，date， double precision，integer， interval，numeric，decimal， real，smallint，time （包括有时区和无时区的）， timestamp （包括有时区和无时区的）。

每种数据类型都有一个由其输入和输出函数决定的外部表现形式。 许多内建的类型有明显的格式。不过，许多类型要么是 PostgreSQL 所特有的，比如几何路径，要么可能是有几种不同的格式，比如日期和时间类型。 有些输入和输出函数是不可逆的。也就是说，输出函数的输出结果和原始的输入比较的时候可能丢失精度。