Kingbase-SQL语法2-值表达式

2 值表达式

值表达式被用于各种各样的环境中，例如在 SELECT 命令的目标列表中、作为 INSERT 或 UPDATE 中的 新列值或者若干命令中的搜索条件。为了区别于一个表表达式（是一个表）的结果，一个值表达式的结果有 时候被称为一个标量 。值表达式因此也被称为 标量表达式 （或者甚至简称为 表达式 ）。表达式语法允许使用 算数、逻辑、集合和其他操作从原始部分计算值。

一个值表达式是下列之一：

• 一个常量或文字值

• 一个列引用

• 在一个函数定义体或预备语句中的一个位置参数引用

• 一个下标表达式

• 一个域选择表达式

• 一个操作符调用

• 一个函数调用

• 一个聚集表达式

• 一个窗口函数调用

• 一个类型转换

• 一个排序规则表达式

• 一个标量子查询

• 一个数组构造器

• 一个行构造器

• 另一个在圆括号（用来分组子表达式以及重载优先级）中的值表达式

在这个列表之外，还有一些结构可以被分类为一个表达式，但是它们不遵循任何一般语法规则。这些通常具有一个函数或操作符的语义并且在 函数和操作符 中的合适位置解释。一个例子是 IS NULL 子句。

我们已经在 常量 中讨论过常量。下面的小节会讨论剩下的选项。

2.1 列引用

一个列可以以下面的形式被引用：

correlation.columnname

“correlation“ 是一个表（有可能以一个模式名限定）的名字，或者是在 FROM 子句中为一个表定义的别名。如果列名在当前索引所使用的表中都是唯一的，关联名称和分隔用的句点可以被忽略（另见 查询 ）。

2.2.2 位置参数

一个位置参数引用被用来指示一个由 SQL 语句外部提供的值。参数被用于 SQL 函数定义和预备查询中。某些客户端库还支持独立于 SQL 命令字符串来指定数据值，在这种情况中参数被用来引用那些线外数据值。一 个参数引用的形式是：

$number

例如，考虑一个函数 dept 的定义：

CREATE FUNCTION dept(text) RETURNS dept

AS $$ SELECT * FROM dept WHERE name = $1 $$

LANGUAGE SQL;

这里 $1 引用函数被调用时第一个函数参数的值。

2.3 下标

如果一个表达式得到了一个数组类型的值，那么可以抽取出该数组值的一个特定元素：

expression[subscript]

或者抽取出多个相邻元素（一个“数组切片”）：

expression[lower_subscript:upper_subscript]

（这里，方括号 [ ] 表示其字面意思）。每一个 “ 下标 “ 自身是一个表达式，它必须得到一个整数值。

通常，数组 “ 表达式 “ 必须被加上括号，但是当要被加下标的表达式只是一个列引用或位置参数时，括号可以 被忽略。还有，当原始数组是多维时，多个下标可以被连接起来。例如：

mytable.arraycolumn[4]

mytable.two_d_column[17][34]

$1[10:42]

(arrayfunction(a,b))[42]

最后一个例子中的圆括号是必需的。详见 数组 。

2.4 域选择

如果一个表达式得到一个组合类型（行类型）的值，那么可以抽取该行的指定域

expression.fieldname

通常行 “ 表达式 “ 必须被加上括号，但是当该表达式是仅从一个表引用或位置参数选择时，圆括号可以被忽 略。例如：

mytable.mycolumn

$1.somecolumn

(rowfunction(a,b)).col3

（因此，一个被限定的列引用实际上只是域选择语法的一种特例）。一种重要的特例是从一个组合类型的表列

中抽取一个域：

(compositecol) . somefield

(mytable . compositecol) . somefield

这里需要圆括号来显示 compositecol 是一个列名而不是一个表名，在第二种情况中则是显示 mytable

是一个表名而不是一个模式名。

你可以通过书写 .* 来请求一个组合值的所有域：

(compositecol) .*

这种记法的行为根据上下文会有不同，详见 在查询中使用组合类型 。

2.5 操作符调用

对于一次操作符调用，有三种可能的语法：

“expression“ “operator“ “expression“ （二元中缀操作符）

“operator“ “expression“ （一元前缀操作符）

“expression“ “operator“ （一元后缀操作符）

其中 “operator“ 记号遵循 操作符 的语法规则，或者是关键词 AND 、 OR 和 NOT 之一，或者是一个如下形式的

受限定操作符名：

OPERATOR(schema.operatorname)

哪个特定操作符存在以及它们是一元的还是二元的取决于由系统或用户定义的那些操作符。 函数和操作符 描述了内建操作符。

2.6 函数调用

一个函数调用的语法是一个函数的名称（可能受限于一个模式名）后面跟上封闭于圆括号中的参数列表：

function_name ([expression [, expression ... ]] )

例如，下面会计算 2 的平方根：

sqrt( 2 )

当在一个某些用户不信任其他用户的数据库中发出查询时，在编写函数调用时应遵守 函数 中的安全防范措施。

内建函数的列表在 函数和操作符 中。其他函数可以由用户增加。

参数可以有选择地被附加名称。详见 调用函数 。

Note: 一个采用单一组合类型参数的函数可以被有选择地称为域选择语法，并且反过来域选择可以被写成函数的风格。也就是说，记号 col(table) 和 table.col 是可以互换的。这种行为是非 SQL 标准的但是在 KingbaseES 中被提供，因为它允许函数的使用来模拟“计算域”。详见 在查询中使用组合类型 。

2.7 聚集表达式

一个 聚集表达式 表示在由一个查询选择的行上应用一个聚集函数。一个聚集函数将多个输入减少到一个单一输出值，例如对输入的求和或平均。一个聚集表达式的语法是下列之一：

aggregate_name (expression [ , ... ] [ order_by_clause ] ) [ FILTER ( WHERE

filter_clause ) ]

aggregate_name (ALL expression [ , ... ] [ order_by_clause ] ) [ FILTER ( WHERE

filter_clause ) ]

aggregate_name (DISTINCT expression [ , ... ] [ order_by_clause ] ) [ FILTER (

WHERE filter_clause ) ]

aggregate_name ( * ) [ FILTER ( WHERE filter_clause ) ]

aggregate_name ( [ expression [ , ... ] ] ) WITHIN GROUP ( order_by_clause ) [

FILTER ( WHERE filter_clause ) ]

这里 “aggregate_name“ 是一个之前定义的聚集（可能带有一个模式名限定），并且 “expression“ 是任意自身不包

含聚集表达式的值表达式或一个窗口函数调用。可选的 “order_by_clause“ 和 “filter_clause“ 描述如下。

第一种形式的聚集表达式为每一个输入行调用一次聚集。第二种形式和第一种相同，因为 ALL 是默认选项。

第三种形式为输入行中表达式的每一个可区分值（或者对于多个表达式是值的可区分集合）调用一次聚集。

第四种形式为每一个输入行调用一次聚集，因为没有特定的输入值被指定，它通常只对于 count(*) 聚集 函数有用。最后一种形式被用于有序集 聚集函数，其描述如下。

大部分聚集函数忽略空输入，这样其中一个或多个表达式得到空值的行将被丢弃。除非另有说明，对于所有内建聚集都是这样。

例如， count(*) 得到输入行的总数。 count(f1) 得到输入行中 f1 为非空的数量，因为 count 忽略空

值。而 count(distinct f1) 得到 f1 的非空可区分值的数量。

一般地，交给聚集函数的输入行是未排序的。在很多情况中这没有关系，例如不管接收到什么样的输入， min 总是产生相同的结果。但是，某些聚集函数（例如 array_agg 和 string_agg ）依据输入行的排序产生 结果。当使用这类聚集时，可选的 “order_by_clause“ 可以被用来指定想要的顺序。 “order_by_clause“ 与查询级别

的 ORDER BY 子句（如 行排序 所述）具有相同的语法，除非它的表达式总是仅有表达式并且不能是输出列 名称或编号。例如：

SELECT array_agg(a ORDER BY b DESC) FROM table;

在处理多参数聚集函数时，注意 ORDER BY 出现在所有聚集参数之后。例如，要这样写：

SELECT string_agg(a, ',' ORDER BY a) FROM table;

而不能这样写：

SELECT string_agg(a ORDER BY a, ',' ) FROM table;

-- 不正确

后者在语法上是合法的，但是它表示用两个 ORDER BY 键来调用一个单一参数聚集函数（第二个是无用的，因为它是一个常量）。

如果在 “order_by_clause“ 之外指定了 DISTINCT ，那么所有的 ORDER BY 表达式必须匹配聚集的常规参数。

也就是说，你不能在 DISTINCT 列表没有包括的表达式上排序。

Note: 在一个聚集函数中指定 DISTINCT 以及 ORDER BY 的能力是一种 KingbaseES 扩展。

按照到目前为止的描述，如果一般目的和统计性聚集中排序是可选的，在要为它排序输入行时可以在该聚集的常规参数列表中放置 ORDER BY 。有一个聚集函数的子集叫做 有序集聚集 ，它要求一个 “order_by_clause“ ，

通常是因为该聚集的计算只对其输入行的特定顺序有意义。有序集聚集的典型例子包括排名和百分位计算。按照上文的最后一种语法，对于一个有序集聚集，“order_by_clause“ 被写在 WITHIN GROUP (...) 中。

“order_by_clause“ 中的表达式会像普通聚集参数一样对每一个输入行计算一次，按照每个 “order_by_clause“ 的

要求排序并且交给该聚集函数作为输入参数（这和非 WITHIN GROUP “order_by_clause“ 的情况不同，在其中表达式的结果不会被作为聚集函数的参数）。如果有在 WITHIN GROUP 之前的参数表达式，会把它们称为 直

接参数 以便与列在 “order_by_clause“ 中的 聚集参数 相区分。与普通聚集参数不同，针对每次聚集调用只会计算一次直接参数，而不是为每一个输入行计算一次。这意味着只有那些变量被 GROUP BY 分组时，它们才能包含这些变量。这个限制同样适用于根本不在一个聚集表达式内部的直接参数。直接参数通常被用于百分数之类的东西，它们只有作为每次聚集计算用一次的单一值才有意义。直接参数列表可以为空，在这种情况下，写成 () 而不是 (*) （实际上 KingbaseES 接受两种拼写，但是只有第一种符合 SQL 标准）。

有序集聚集的调用例子：

SELECT percentile_cont( 0.5 ) WITHIN GROUP (ORDER BY income) FROM households;

percentile_cont

-----------------

50489

这会从表 households 的 income 列得到第 50 个百分位或者中位的值。这里 0.5 是一个直接参数，对于百分位部分是一个在不同行之间变化的值的情况它没有意义。

如果指定了 FILTER ，那么只有对 “filter_clause“ 计算为真的输入行会被交给该聚集函数，其他行会被丢弃。

例如：

SELECT

count( * ) AS unfiltered,

count( * ) FILTER (WHERE i < 5 ) AS filtered

FROM generate_series( 1 , 10 ) AS s(i);

unfiltered | filtered

------------+----------

10 |

4

( 1 row)

预定义的聚集函数在 聚集函数 中描述。其他聚集函数可以由用户增加。

另外，用户在使用聚集函数时，支持不带 group by 的 order by 聚集，例如

SELECT sum (a) FROM t1 ORDER BY a;

sum

-----

11

( 1 row)

一个聚集表达式只能出现在 SELECT 命令的结果列表或是 HAVING 子句中。在其他子句（如 WHERE ）中

禁止使用它，因为那些子句的计算在逻辑上是在聚集的结果被形成之前。

当一个聚集表达式出现在一个子查询中（见 标量子查询 和 子查询表达式 ），聚集通常在该子查询的行上被计算。但是如果该聚集的参数（以及 “filter_clause“ ，如果有）只包含外层变量则会产生一个异常：该聚集则属于最近的那个外层，并且会在那个查询的行上被计算。该聚集表达式从整体上则是对其所出现于的子查询的

一种外层引用，并且在那个子查询的任意一次计算中都作为一个常量。只出现在结果列表或 HAVING 子句

的限制适用于该聚集所属的查询层次。

2.8 窗口函数调用

一个 窗口函数调用 表示在一个查询选择的行的某个部分上应用一个聚集类的函数。和非窗口聚集函数调用不同，这不会被约束为将被选择的行分组为一个单一的输出行—在查询输出中每一个行仍保持独立。不过，窗口函数能够根据窗口函数调用的分组声明（PARTITION BY 列表）访问属于当前行所在分组中的所有行。

一个窗口函数调用的语法是下列之一：

function_name ([expression [, expression ... ]]) [ FILTER ( WHERE filter_clause )

] OVER window_name

function_name ([expression [, expression ... ]]) [ FILTER ( WHERE filter_clause )

] OVER ( window_definition )

function_name ( * ) [ FILTER ( WHERE filter_clause ) ] OVER window_name

function_name ( * ) [ FILTER ( WHERE filter_clause ) ] OVER ( window_definition )

其中 “window_definition“ 的语法是

[ existing_window_name ]

[ PARTITION BY expression [, ...] ]

[ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST

} ] [, ...] ]

[ frame_clause ]

可选的 “frame_clause“ 是下列之一

{ RANGE | ROWS | GROUPS } frame_start [ frame_exclusion ]

{ RANGE | ROWS | GROUPS } BETWEEN frame_start AND frame_end [ frame_exclusion ]

其中 “frame_start“ 和 “frame_end“ 可以是下面形式中的一种

UNBOUNDED PRECEDING

offset PRECEDING

CURRENT ROW

offset FOLLOWING

UNBOUNDED FOLLOWING

而 “frame_exclusion“ 可以是下列之一

EXCLUDE CURRENT ROW

EXCLUDE GROUP

EXCLUDE TIES

EXCLUDE NO OTHERS

这里， “expression“ 表示任何自身不含有窗口函数调用的值表达式。

“window_name“ 是对定义在查询的 WINDOW 子句中的一个命名窗口声明的引用。还可以使用在 WINDOW 子

句中定义命名窗口的相同语法在圆括号内给定一个完整的 “window_definition“ ，详见 SELECT 参考页。值得指出的是，OVER wname 并不严格地等价于 OVER (wname ......) ，后者表示复制并修改窗口定义，并且 在被引用窗口声明包括一个帧子句时会被拒绝。

PARTITION BY 选项将查询的行分组成为 分区 ，窗口函数会独立地处理它们。 PARTITION BY 工作起来类 似于一个查询级别的 GROUP BY 子句，不过它的表达式总是只是表达式并且不能是输出列的名称或编号。

如果没有 PARTITION BY ，该查询产生的所有行被当作一个单一分区来处理。 ORDER BY 选项决定被窗口 函数处理的一个分区中的行的顺序。它工作起来类似于一个查询级别的 ORDER BY 子句，但是同样不能使 用输出列的名称或编号。如果没有 ORDER BY ，行将被以未指定的顺序被处理。

“frame_clause“ 指定构成 窗口帧 的行集合，它是当前分区的一个子集，窗口函数将作用在该帧而不是整个分区。

帧中的行集合会随着哪一行是当前行而变化。在 RANGE 、 ROWS 或者 GROUPS 模式中可以指定帧，在每一 种情况下，帧的范围都是从 “frame_start“ 到 “frame_end“ 。如果 “frame_end“ 被省略，则末尾默认为 CURRENT

ROW 。

UNBOUNDED PRECEDING 的 一 个 “frame_start“ 表 示 该 帧 开 始 于 分 区 的 第 一 行， 类 似 地 UNBOUNDED

FOLLOWING 的一个 “frame_end“ 表示该帧结束于分区的最后一行。

在 RANGE 或 GROUPS 模式中， CURRENT ROW 的一个 “frame_start“ 表示帧开始于当前行的第一个 平级 行（被窗口的 ORDER BY 子句排序为与当前行等效的行），而 CURRENT ROW 的一个 “frame_end“ 表示帧结束于当

前行的最后一个平级行。在 ROWS 模式中， CURRENT ROW 就表示当前行。

在 “offset“ PRECEDING 以及 “offset“ FOLLOWING 帧选项中， “offset“ 必须是一个不包含任何变量、聚集函数或 者窗口函数的表达式。“offset“ 的含义取决于帧模式：

• 在 ROWS 模式中， “offset“ 必须得到一个非空、非负的整数，并且该选项表示帧开始于当前行之前或者之后指定数量的行。

• 在 GROUPS 模式中， “offset“ 也必须得到一个非空、非负的整数，并且该选项表示帧开始于当前行的平级组之前或者之后指定数量的平级组 ，这里平级组是在 ORDER BY 顺序中等效的行集合（要使用 GROUPS 模式，在窗口定义中就必须有一个 ORDER BY 子句）。

• 在 RANGE 模式中，这些选项要求 ORDER BY 子句正好指定一列。 “offset“ 指定当前行中那一列的值与它在该帧中前面或后面的行中的列值的最大差值。“offset“ 表达式的数据类型会随着排序列的数据 类型而变化。对于数字的排序列，它通常是与排序列相同的类型，但对于日期时间排序列它是一个interval。例如，如果排序列是类型 date 或者 timestamp ，我们可以写 RANGE BETWEEN '1 day' PRECEDING AND '10 days' FOLLOWING。 “offset“ 仍然要求是非空且非负，不过“非负”的

含义取决于它的数据类型。

在任何一种情况下，到帧末尾的距离都受限于到分区末尾的距离，因此对于离分区末尾比较近的行来说，帧可能会包含比较少的行。

注意在 ROWS 以及 GROUPS 模式中， 0 PRECEDING 和 0 FOLLOWING 与 CURRENT ROW 等效。通常在RANGE 模式中，这个结论也成立（只要有一种合适的、与数据类型相关的“零”的含义）。

“frame_exclusion“ 选项允许当前行周围的行被排除在帧之外，即便根据帧的开始和结束选项应该把它们包括

在帧中。 EXCLUDE CURRENT ROW 会把当前行排除在帧之外。 EXCLUDE GROUP 会把当前行以及它在顺序

上的平级行都排除在帧之外。 EXCLUDE TIES 把当前行的任何平级行都从帧中排除，但不排除当前行本身。

EXCLUDE NO OTHERS 只是明确地指定不排除当前行或其平级行的这种默认行为。

默认的帧选项是 RANGE UNBOUNDED PRECEDING ，它和 RANGE BETWEEN UNBOUNDED PRECEDING

AND CURRENT ROW 相同。如果使用 ORDER BY ，这会把该帧设置为从分区开始一直到当前行的最后

一个 ORDER BY 平级行的所有行。如果不使用 ORDER BY ，就意味着分区中所有的行都被包括在窗口帧中，

因为所有行都成为了当前行的平级行。

限制是 “frame_start“ 不能是 UNBOUNDED FOLLOWING 、 “frame_end“ 不能是 UNBOUNDED PRECEDING ，并且

在上述 “frame_start“ 和 “frame_end“ 选项的列表中 “frame_end“ 选择不能早于 “frame_start“ 选择出现—例如不允许

RANGE BETWEEN CURRENT ROW AND offset PRECEDING ，但允许 ROWS BETWEEN 7 PRECEDING

AND 8 PRECEDING ，虽然它不会选择任何行。

如果指定了 FILTER ，那么只有对 “filter_clause“ 计算为真的输入行会被交给该窗口函数，其他行会被丢弃。

只有是聚集的窗口函数才接受 FILTER 。

用户可以加入其他窗口函数。此外，任何内建的或者用户定义的通用聚集或者统计性聚集都可以被用作窗口

函数（有序集和假想集聚集当前不能被用作窗口函数）。

使用 * 的语法被用来把参数较少的聚集函数当作窗口函数调用，例如 count(*) OVER (PARTITION BY

x ORDER BY y) 。星号（ * ）通常不被用于窗口相关的函数。窗口相关的函数不允许在函数参数列表中使

用 DISTINCT 或 ORDER BY 。

只有在 SELECT 列表和查询的 ORDER BY 子句中才允许窗口函数调用。

更多关于窗口函数的信息可以在 窗口函数 、 窗口函数 以及 窗口函数处理 中找到。

2.9 类型转换

一个类型造型指定从一种数据类型到另一种数据类型的转换。 KingbaseES 接受两种等价的类型造型语法：

CAST ( expression AS type )

expression::type

CAST 语法遵从 SQL ，而用 :: 的语法是 KingbaseES 的历史用法。

当一个造型被应用到一种未知类型的值表达式上时，它表示一种运行时类型转换。只有已经定义了一种合适

的类型转换操作时，该造型才会成功。注意这和常量的造型（如 其他类型的常量 中所示）使用不同。应用于

一个未修饰串文字的造型表示一种类型到一个文字常量值的初始赋值，并且因此它将对任意类型都成功（如

果该串文字的内容对于该数据类型的输入语法是可接受的）。

如果一个值表达式必须产生的类型没有歧义（例如当它被指派给一个表列），通常可以省略显式类型造型，

在这种情况下系统会自动应用一个类型造型。但是，只有对在系统目录中被标记为“ OK to apply implicitly ”

的造型才会执行自动造型。其他造型必须使用显式造型语法调用。这种限制是为了防止出人意料的转换被无

声无息地应用。

还可以用像函数的语法来指定一次类型造型：

typename ( expression )

但是，这只对那些名字也作为函数名可用的类型有效。例如， double precision 不能以这种方式使用，

但是等效的 float8 可以。还有，如果名称 interval 、 time 和 timestamp 被用双引号引用，那么由

于语法冲突的原因，它们只能以这种风格使用。因此，函数风格的造型语法的使用会导致不一致性并且应该

尽可能被避免。

Note: 函数风格的语法事实上只是一次函数调用。当两种标准造型语法之一被用来做一次运行时转换时，它

将在内部调用一个已注册的函数来执行该转换。简而言之，这些转换函数具有和它们的输出类型相同的名

字，并且因此函数风格的语法无非是对底层转换函数的一次直接调用。显然，一个可移植的应用不应当依赖

于它。详见 CREATE CAST 。

2.10 排序规则表达式

COLLATE 子句会重载一个表达式的排序规则。它被追加到它适用的表达式：

expr COLLATE collation

这里 “collation“ 可能是一个受模式限定的标识符。 COLLATE 子句比操作符绑得更紧，需要时可以使用圆括号。

如果没有显式指定排序规则，数据库系统会从表达式所涉及的列中得到一个排序规则，如果该表达式没有涉及列，则会默认采用数据库的默认排序规则。

COLLATE 子句的两种常见使用是重载 ORDER BY 子句中的排序顺序，例如：

SELECT a, b, c FROM tbl WHERE ... ORDER BY a COLLATE "C" ;

以及重载具有区域敏感结果的函数或操作符调用的排序规则，例如：

SELECT * FROM tbl WHERE a > 'foo' COLLATE "C" ;

注意在后一种情况中， COLLATE 子句被附加到我们希望影响的操作符的一个输入参数上。 COLLATE 子句被

附加到该操作符或函数调用的哪个参数上无关紧要，因为被操作符或函数应用的排序规则是考虑所有参数得

来的，并且一个显式的 COLLATE 子句将重载所有其他参数的排序规则（不过，附加非匹配 COLLATE 子句

到多于一个参数是一种错误。详见 排序规则支持）。因此，这会给出和前一个例子相同的结果：

SELECT * FROM tbl WHERE a COLLATE "C" > 'foo' ;

但是这是一个错误：

SELECT * FROM tbl WHERE (a > 'foo' ) COLLATE "C" ;

因为它尝试把一个排序规则应用到 > 操作符的结果，而它的数据类型是非可排序数据类型 boolean 。

2.11 标量子查询

一个标量子查询是一种圆括号内的普通 SELECT 查询，它返回一行一列（关于书写查询可见 查询 ）。 SELECT

查询被执行并且该单一返回值被使用在周围的值表达式中。将一个返回超过一行或一列的查询作为一个标量子查询使用是一种错误（但是如果在一次特定执行期间该子查询没有返回行则不是错误，该标量结果被当做为空）。该子查询可以从周围的查询中引用变量，这些变量在该子查询的任何一次计算中都将作为常量。对

于其他涉及子查询的表达式还可见 子查询表达式 。

例如，下列语句会寻找每个州中最大的城市人口：

SELECT name, (SELECT max (pop) FROM cities WHERE cities . state = states . name)

FROM states;

2.12 数组构造器

一个数组构造器是一个能构建一个数组值并且将值用于它的成员元素的表达式。一个简单的数组构造器由关

键词 ARRAY 、一个左方括号 [ 、一个用于数组元素值的表达式列表（用逗号分隔）以及最后的一个右方括

号 ] 组成。例如：

SELECT ARRAY[ 1 , 2 , 3 + 4 ];

array

---------

{ 1 , 2 , 7 }

( 1 row)

默认情况下，数组元素类型是成员表达式的公共类型，使用和 UNION 或 CASE 结构（见 UNION 、 CASE 和相

关结构 ）相同的规则决定。可以通过显式将数组构造器造型为想要的类型来重载，例如：

SELECT ARRAY[ 1 , 2 , 22.7 ]::integer[];

array

----------

{ 1 , 2 , 23 }

( 1 row)

这与把每一个表达式单独地造型为数组元素类型的效果相同。关于构造的更多信息见 类型转换 。

多维数组值可以通过嵌套数组构造器来构建。在内层的构造器中，关键词 ARRAY 可以被忽略。例如，这些

语句产生相同的结果：

SELECT ARRAY[ARRAY[ 1 , 2 ], ARRAY[ 3 , 4 ]];

array

---------------

{{ 1 , 2 },{ 3 , 4 }}

( 1 row)

SELECT ARRAY[[ 1 , 2 ],[ 3 , 4 ]];

array

---------------

{{ 1 , 2 },{ 3 , 4 }}

( 1 row)

因为多维数组必须是矩形的，处于同一层次的内层构造器必须产生相同维度的子数组。任何被应用于外层

ARRAY 构造器的造型会自动传播到所有的内层构造器。

多维数组构造器元素可以是任何得到一个正确种类数组的任何东西，而不仅仅是一个子 - ARRAY 结构。例如：

CREATE TABLE arr(f1 int [], f2 int []);

INSERT INTO arr VALUES (ARRAY[[ 1 , 2 ],[ 3 , 4 ]], ARRAY[[ 5 , 6 ],[ 7 , 8 ]]);

SELECT ARRAY[f1, f2, '{{9,10},{11,12}}' :: int []] FROM arr;

array

-------------------------------------------------

{{{ 1 , 2 },{ 3 , 4 }},{{ 5 , 6 },{ 7 , 8 }},{{ 9 , 10 },{ 11 , 12 }}}

( 1 row)

可以构造一个空数组，但是因为无法得到一个无类型的数组，必须显式地把空数组构造成想要的类型。例如：

SELECT ARRAY[]::integer[];

array

-------

{}

( 1 row)

也可以从一个子查询的结果构建一个数组。在这种形式中，数组构造器被写为关键词 ARRAY 后跟着一个加

了圆括号（不是方括号）的子查询。例如：

SELECT ARRAY(SELECT oid FROM sys_proc WHERE proname LIKE 'bytea%' );

array

-----------------------------------------------------------------------

{ 2011 , 1954 , 1948 , 1952 , 1951 , 1244 , 1950 , 2005 , 1949 , 1953 , 2006 , 31 , 2412 , 2413 }

( 1 row)

SELECT ARRAY(SELECT ARRAY[i, i * 2 ] FROM generate_series( 1 , 5 ) AS a(i));

array

----------------------------------

{{ 1 , 2 },{ 2 , 4 },{ 3 , 6 },{ 4 , 8 },{ 5 , 10 }}

( 1 row)

子查询必须返回一个单一列。如果子查询的输出列是非数组类型，结果的一维数组将为该子查询结果中的每一行有一个元素，并且有一个与子查询的输出列匹配的元素类型。如果子查询的输出列是一种数组类型，结果将是同类型的一个数组，但是要高一个维度。在这种情况下，该子查询的所有行必须产生同样维度的数组，否则结果就不会是矩形形式。

用 ARRAY 构建的一个数组值的下标总是从一开始。更多关于数组的信息，请见 数组 。

2.2.13 行构造器

一个行构造器是能够构建一个行值（也称作一个组合类型）并用值作为其成员域的表达式。一个行构造器由

关键词 ROW 、一个左圆括号、用于行的域值的零个或多个表达式（用逗号分隔）以及最后的一个右圆括号

组成。例如：

SELECT ROW( 1 , 2.5 , 'this is a test' );

当在列表中有超过一个表达式时，关键词 ROW 是可选的。

一个行构造器可以包括语法 “rowvalue“ .* ，它将被扩展为该行值的元素的一个列表，就像在一个顶层 SELECT

列表（见 在查询中使用组合类型 ）中使用 .* 时发生的事情一样。例如，如果表 t 有列 f1 和 f2 ，那么这

些是相同的：

SELECT ROW(t .* , 42 ) FROM t;

SELECT ROW(t . f1, t . f2, 42 ) FROM t;

Note: 在 KingbaseES V7 以前， .* 语法不会在行构造器中被扩展，这样写 ROW(t.*, 42) 会创建一个有两个域的行，其第一个域是另一个行值。新的行为通常更有用。如果你需要嵌套行值的旧行为，写内层行值时不要用.*，例如 ROW(t, 42) 。

默认情况下，由一个 ROW 表达式创建的值是一种匿名记录类型。如果必要，它可以被造型为一种命名的组合类型—或者是一个表的行类型，或者是一种用 CREATE TYPE AS 创建的组合类型。为了避免歧义，可能需要一个显式造型：

CREATE TABLE mytable(f1 int, f2 float, f3 text);

CREATE FUNCTION getf1(mytable) RETURNS int AS 'SELECT $1.f1' LANGUAGE SQL;

-- 不需要造型因为只有一个 getf1() 存在

SELECT getf1(ROW(1,2.5,'this is a test'));

getf1

-------

1

(1 row)

CREATE TYPE myrowtype AS (f1 int, f2 text, f3 numeric);

CREATE FUNCTION getf1(myrowtype) RETURNS int AS 'SELECT $1.f1' LANGUAGE SQL;

-- 现在我们需要一个造型来指示要调用哪个函数：

SELECT getf1(ROW(1,2.5,'this is a test'));

ERROR: function getf1(record) is not unique

SELECT getf1(ROW(1,2.5,'this is a test')::mytable);

getf1

-------

1

(1 row)

SELECT getf1(CAST(ROW(11,'this is a test',2.5) AS myrowtype));

getf1

-------

11

(1 row)

行构造器可以被用来构建存储在一个组合类型表列中的组合值，或者被传递给一个接受组合参数的函数。还

有，可以比较两个行值，或者用 IS NULL 或 IS NOT NULL 测试一个行，例如：

SELECT ROW( 1 , 2.5 , 'this is a test' ) = ROW( 1 , 3 , 'not the same' );

SELECT ROW(table .* ) IS NULL FROM table;

-- detect all - null rows

详见 行和数组比较 。如 子查询表达式 中所讨论的，行构造器也可以被用来与子查询相连接。

2.14 表达式计算规则

子表达式的计算顺序没有被定义。特别地，一个操作符或函数的输入不必按照从左至右或其他任何固定顺序

进行计算。

此外，如果一个表达式的结果可以通过只计算其一部分来决定，那么其他子表达式可能完全不需要被计算。

例如，如果写：

SELECT true OR somefunc();

那么 somefunc() 将（可能）完全不被调用。如果写成下面这样也是一样：

SELECT somefunc() OR true;

注意这和一些编程语言中布尔操作符从左至右的“短路”不同。

因此，在复杂表达式中使用带有副作用的函数是不明智的。在 WHERE 和 HAVING 子句中依赖副作用或

计算顺序尤其危险，因为在建立一个执行计划时这些子句会被广泛地重新处理。这些子句中布尔表达式

（ AND / OR / NOT 的组合）可能会以布尔代数定律所允许的任何方式被重组。

当有必要强制计算顺序时，可以使用一个 CASE 结构（见 条件表达式 ）。在一个 WHERE 子句中使用下面的

方法尝试避免除零是不可靠的：

SELECT ... WHERE x > 0 AND y / x > 1.5 ;

但是这是安全的：

SELECT ... WHERE CASE WHEN x > 0 THEN y / x > 1.5 ELSE false END;

一个以这种风格使用的 CASE 结构将使得优化尝试失败，因此只有必要时才这样做（在这个特别的例子中，

最好通过写 y > 1.5*x 来回避这个问题）。

但是， CASE 不是这类问题的万灵药。上述技术的一个限制是，无法阻止常量子表达式的提早计算。如 函数易

变性分类 中所述，当查询被规划而不是被执行时，被标记成 IMMUTABLE 的函数和操作符可以被计算。因此

SELECT CASE WHEN x > 0 THEN x ELSE 1 / 0 END FROM tab;

很可能会导致一次除零失败，因为规划器尝试简化常量子表达式。即便是表中的每一行都有 x > 0 （这样运行时永远不会进入到 ELSE 分支）也是这样。

虽然这个特别的例子可能看起来愚蠢，没有明显涉及常量的情况可能会发生在函数内执行的查询中，因为因为函数参数的值和本地变量可以作为常量被插入到查询中用于规划目的。例如，在 PL/SQL 函数中，使用一个 IF - THEN - ELSE 语句来保护一种有风险的计算比把它嵌在一个 CASE 表达式中要小得多。

另一个同类型的限制是，一个 CASE 无法阻止其所包含的聚集表达式的计算，因为在考虑 SELECT 列表或 HAVING 子句中的其他表达式之前，会先计算聚集表达式。例如，下面的查询会导致一个除零错误：

SELECT CASE WHEN min (employees) > 0

THEN avg(expenses / employees)

END

FROM departments;

min() 和 avg() 聚集会在所有输入行上并行地计算，因此如果任何行存在 employees 等于零，在有机会测试 min() 的结果之前，就会发生除零错误。但是，可以使用 WHERE 或 FILTER 子句来首先阻止有问题的输入行到达一个聚集函数。