GBASE 8C——SQL参考 2 函数和操作符

原创 PEWSGGL 2022-05-24

538

函数和操作符

GBase 8c提供了大量的函数和操作符，用户也可以自己定义函数和操作符。

逻辑操作符

常用的逻辑操作符：

AND

NOT

比较操作符

操作符	描述
<	小于
>	大于
<=	小于等于
>=	大于等于
=	等于
<> or !=	不等于

1. 1. 数学函数和操作符

下表展示了所有GBase 8c可用的数学操作符：

操作符	描述	例子	结果
+	加	2 + 3	5
-	减	2 - 3	-1
*	乘	2 * 3	6
/	除（整数除法截断结果）	4 / 2	2
%	模（取余）	5 % 4	1
^	指数	2.0 ^ 3.0	8
\|/	平方根	\|/ 25.0	5
\|\|/	立方根	\|\|/ 27.0	3
!	阶乘	5 !	120
!!	阶乘（前缀操作符）	!! 5	120
@	绝对值	@ -5.0	5
&	按位与	91 & 15	11
\|	按位或	32 \| 3	35
#	按位异或	17 # 5	20
~	按位求反	~1	-2
<<	按位左移	1 << 4	16
>>	按位右移	8 >> 2	2

可用的数学函数如下表：

函数	返回类型	描述	例子	结果
abs(x)	（和输入相同）	绝对值	abs(-17.4)	17.4
cbrt(dp)	dp	立方根	cbrt(27.0)	3
ceil(dp or numeric)	（和输入相同）	不小于参数的最小整数	ceil(-42.8)	-42
ceiling(dp or numeric)	（和输入相同）	不小于参数的最小整数（ceil的别名）	ceiling(-95.3)	-95
degrees(dp)	dp	把弧度转为角度	degrees(0.5)	28.6478897565412
div(y numeric, x numeric)	numeric	y/x的整数商	div(9,4)	2
exp(dp or numeric)	（和输入相同）	指数	exp(1.0)	2.71828182845905
floor(dp or numeric)	（和输入相同）	不大于参数的最大整数	floor(-42.8)	-43
ln(dp or numeric)	（和输入相同）	自然对数	ln(2.0)	0.693147180559945
log(dp or numeric)	（和输入相同）	以10为底的对数	log(100.0)	2
log(b numeric, x numeric)	numeric	以b为底的对数	log(2.0, 64.0)	6.0000000000
mod(y, x)	（和参数类型相同）	y/x的余数	mod(9,4)	1
pi()	dp	“π”常数	pi()	3.14159265358979
power(a dp, b dp)	dp	求a的b次幂	power(9.0, 3.0)	729
power(a numeric, b numeric)	numeric	求a的b次幂	power(9.0, 3.0)	729
radians(dp)	dp	把角度转为弧度	radians(45.0)	0.785398163397448
round(dp or numeric)	（和输入相同）	圆整为最接近的整数	round(42.4)	42
round(v numeric, s int)	numeric	圆整为s位小数数字	round(42.4382, 2)	42.44
scale(numeric)	integer	参数的精度（小数点后的位数）	scale(8.41)	2
sign(dp or numeric)	（和输入相同）	参数的符号（-1, 0, +1）	sign(-8.4)	-1
sqrt(dp or numeric)	（和输入相同）	平方根	sqrt(2.0)	1.4142135623731
trunc(dp or numeric)	（和输入相同）	截断（向零靠近）	trunc(42.8)	42
trunc(v numeric, s int)	numeric	截断为s位小数位置的数字	trunc(42.4382, 2)	42.43
width_bucket(operand dp, b1 dp, b2 dp, count int)	int	返回一个桶，这个桶是在一个有count个桶，上界为b1，下界为b2的柱图中operand将被赋予的那个桶。为外部范围输入返回0或者count+1	width_bucket(5.35, 0.024, 10.06, 5)	3
width_bucket(operand numeric, b1 numeric, b2 numeric, count int)	int	返回一个桶，这个桶是在一个有count个桶，上界为b1，下界为b2的柱图中operand将被赋予的那个桶；为范围外的输入返回0或者count+1	width_bucket(5.35, 0.024, 10.06, 5)	3
width_bucket(operand anyelement, thresholds anyarray)	int	返回一个桶，它是给定数组列出桶的下限operand将被赋予的那个桶，为了输入低于第一下界返回0；thresholds数组必须被存储，首先最小值，或者获取意想不到的结果	width_bucket(now(), array['yesterday', 'today', 'tomorrow']::timestamptz[])	2

表中dp表示double precision。除非特殊指明，任何函数都返回和它参数相同的数据类型。

GBase 8c数据库产生随机数的函数如下：

函数	返回类型	描述
random()	dp	范围 0.0 <= x < 1.0 中的随机值
setseed(dp)	void	为后续的random()调用设置种子（值为于 -1.0 和 1.0 之间，包括边界值）

三角函数如下：

函数 (弧度)	函数 (角度)	描述
acos(x)	acosd(x)	反余弦
asin(x)	asind(x)	反正弦
atan(x)	atand(x)	反正切
atan2(y, x)	atan2d(y, x)	y/x的反正切
cos(x)	cosd(x)	余弦
cot(x)	cotd(x)	余切
sin(x)	sind(x)	正弦
tan(x)	tand(x)	正切

1. - 字符串函数和操作符

SQL定义的字符串函数，使用关键字而不是逗号来分隔参数，如下表所示：

函数	返回类型	描述	例子	结果
`string` `\|\| string`	`text`	串接	`'Post' \|\| 'greSQL'`	`PostgreSQL`
`string` `\|\| non-string` or `non-string` `\|\| string`	`text`	使用一个非字符串输入的串接	`'Value: ' \|\| 42`	`Value: 42`
`bit_length(string)`	`int`	串中的位数	`bit_length('jose')`	`32`
`char_length(string)` or `character_length(string)`	`int`	串中字符数	`char_length('jose')`	`4`
`lower(string)`	`text`	将字符串转换为小写形式	`lower('TOM')`	`tom`
`octet_length(string)`	`int`	串中的字节数	`octet_length('jose')`	`4`
`overlay(string placing string from int [`for `int])`	`text`	替换子串	`overlay('Txxxxas' placing 'hom' from 2 for 4)`	`Thomas`
`position(substring in string)`	`int`	定位指定子串	`position('om' in 'Thomas')`	`3`
`substring(string [`from `int] [`for `int])`	`text`	提取子串	`substring('Thomas' from 2 for 3)`	`hom`
`substring(string from pattern)`	`text`	提取匹配POSIX正则表达式的子串。	`substring('Thomas' from '...$')`	`mas`
`substring(string from pattern for escape)`	`text`	提取匹配SQL正则表达式的子串。	`substring('Thomas' from '%#"o_a#"_' for '#')`	`oma`
`trim([`leading \| trailing \| both`] [characters] from string)`	`text`	从`string`的开头、结尾、两端（默认是`both`）删除最长的只包含来自`characters`字符（默认是一个空格）的串	`trim(both 'xyz' from 'yxTomxx')`	`Tom`
`trim([`leading \| trailing \| both`] [`from`] string [`, `characters] )`	`text`	`trim()`的非标准语法	`trim(both from 'yxTomxx', 'xyz')`	`Tom`
`upper(string)`	`text`	将字符串转换成大写形式	`upper('tom')`	`TOM`

其他字符串函数：

函数	返回类型	描述	例子	结果
`ascii(string)`	`int`	参数第一个字符的ASCII代码。对于UTF8返回该字符的Unicode代码点。对于其他多字节编码，该参数必须是一个ASCII字符。	`ascii('x')`	`120`
`btrim(string text [`, `characters` `text])`	`text`	从`string`的开头或结尾删除最长的只包含`characters`（默认是一个空格）的串	`btrim('xyxtrimyyx', 'xyz')`	`trim`
`chr(int)`	`text`	给定代码的字符。对于UTF8该参数被视作一个Unicode代码点。对于其他多字节编码该参数必须指定一个ASCII字符。NULL (0) 字符不被允许，因为文本数据类型不能存储这种字节。	`chr(65)`	`A`
`concat(str "any" [, str "any" [, ...] ])`	`text`	串接所有参数的文本表示。NULL 参数被忽略。	`concat('abcde', 2, NULL, 22)`	`abcde222`
`concat_ws(sep text, str "any" [, str "any" [, ...] ])`	`text`	将除了第一个参数外的其他参数用分隔符串接在一起。第一个参数被用作分隔符字符串。NULL 参数被忽略。	`concat_ws(',', 'abcde', 2, NULL, 22)`	`abcde,2,22`
`convert(string bytea, src_encoding name, dest_encoding name)`	`bytea`	将字符串转换为`dest_encoding`。原始编码由`src_encoding`指定。`string`在这个编码中必须可用。转换可以使用`CREATE CONVERSION`定义。也有一些预定义的转换。	`convert('text_in_utf8', 'UTF8', 'LATIN1')`	用Latin-1编码(ISO 8859-1) 表示的`text_in_utf8`
`convert_from(string bytea, src_encoding name)`	`text`	将字符串转换为数据库编码。原始编码由`src_encoding`指定。`string`在这个编码中必须可用。	`convert_from('text_in_utf8', 'UTF8')`	用当前数据库编码表示的`text_in_utf8`
`convert_to(string text, dest_encoding name)`	`bytea`	将字符串转换为`dest_encoding`。	`convert_to('some text', 'UTF8')`	用UTF8编码表达的`some text`
`decode(string text, format text)`	`bytea`	从`string`中的文本表达解码二进制数据。`format`的选项和`encode`中的一样。	`decode('MTIzAAE=', 'base64')`	`\x3132330001`
`encode(data bytea, format text)`	`text`	将二进制数据编码成一个文本表达。支持的格式有：`base64`、`hex`、`escape`。`escape`将零字节和高位组字节转换为八进制序列（`\nnn`）和双写的反斜线。	`encode(E'123\\000\\001', 'base64')`	`MTIzAAE=`
`format(formatstr text [, formatarg "any" [, ...] ])`	`text`	根据一个格式字符串格式化参数。该函数和C函数`sprintf`相似。	`format('Hello %s, %1$s', 'World')`	`Hello World, World`
`initcap(string)`	`text`	将每一个词的第一个字母转换为大写形式并把剩下的字母转换为小写形式。词是由非字母数字字符分隔的字母数字字符的序列。	`initcap('hi THOMAS')`	`Hi Thomas`
`left(str text, n int)`	`text`	返回字符串中的前`n`个字符。当`n`为负时，将返回除了最后\|`n`\|个字符之外的所有字符。	`left('abcde', 2)`	`ab`
`length(string)`	`int`	`string`中的字符数	`length('jose')`	`4`
`length(string bytea, encoding name )`	`int`	`string`在给定`编码`中的字符数。`string`必须在这个编码中有效。	`length('jose', 'UTF8')`	`4`
`lpad(string text, length int [`, `fill` `text])`	`text`	将`string`通过前置字符`fill`（默认是一个空格）填充到长度`length`。如果`string`已经长于`length`，则它被（从右边）截断。	`lpad('hi', 5, 'xy')`	`xyxhi`
`ltrim(string text [`, `characters` `text])`	`text`	从`string`的开头删除最长的只包含`characters`（默认是一个空格）的串	`ltrim('zzzytest', 'xyz')`	`test`
`md5(string)`	`text`	计算`string`的 MD5 哈希，返回十六进制的结果	`md5('abc')`	`900150983cd24fb0 d6963f7d28e17f72`
`parse_ident(qualified_identifier text [, strictmode boolean DEFAULT true ] )`	`text[]`	把`qualified_identifier`分成一个标识符数组，移除单个标识符上的任何引号。默认情况下，最后一个标识符后面的多余字符会被当做错误。但是如果第二个参数为`false`，那么这一类多余的字符会被忽略（这种行为对于解析函数之类的对象名称有用）。注意这个函数不会截断超长标识符。如果想要进行截断，可以把结果转换成`name[]`。	`parse_ident('"SomeSchema".someTable')`	`{SomeSchema,sometable}`
`pg_client_encoding()`	`name`	当前的客户端编码名字	`pg_client_encoding()`	`SQL_ASCII`
`quote_ident(string text)`	`text`	将给定字符串返回成合适的引用形式，使它可以在一个SQL语句字符串中被用作一个标识符。只有需要时才会加上引号（即，如果字符串包含非标识符字符或可能是大小写折叠的）。嵌入的引号会被正确地双写。	`quote_ident('Foo bar')`	`"Foo bar"`
`quote_literal(string text)`	`text`	将给定字符串返回成合适的引用形式，使它可以在一个SQL语句字符串中被用作一个字符串文字。嵌入的引号会被正确地双写。注意`quote_literal`对空输入返回空；如果参数可能为空，`quote_nullable`通常更合适。	`quote_literal(E'O\'Reilly')`	`'O''Reilly'`
`quote_literal(value anyelement)`	`text`	强迫给定值为文本并且接着将它用引号包围作为一个文本。嵌入的单引号和反斜线被正确的双写。	`quote_literal(42.5)`	`'42.5'`
`quote_nullable(string text)`	`text`	将给定字符串返回成合适的引用形式，使它可以在一个SQL语句字符串中被用作一个字符串文字；或者，如果参数为空，返回`NULL`。嵌入的引号会被正确地双写。	`quote_nullable(NULL)`	`NULL`
`quote_nullable(value anyelement)`	`text`	强迫给定值为文本并且接着将它用引号包围作为一个文本；或者，如果参数为空，返回`NULL`。嵌入的单引号和反斜线被正确的双写。	`quote_nullable(42.5)`	`'42.5'`
`regexp_match(string text, pattern text [, flags text])`	`text[]`	将从POSIX正则表达式首次匹配产生的捕获子字符串返回给`string`。	`regexp_match('foobarbequebaz', '(bar)(beque)')`	`{bar,beque}`
`regexp_matches(string text, pattern text [, flags text])`	`setof text[]`	将从POSIX正则表达式匹配产生的捕获子字符串返回给`string`。	`regexp_matches('foobarbequebaz', 'ba.', 'g')`	`{bar}` `{baz}` (2 rows)
`regexp_replace(string text, pattern text, replacement text [, flags text])`	`text`	替换匹配一个POSIX正则表达式的子串。	`regexp_replace('Thomas', '.[mN]a.', 'M')`	`ThM`
`regexp_split_to_array(string text, pattern text [, flags text ])`	`text[]`	使用一个POSIX正则表达式作为分隔符划分`string`。	`regexp_split_to_array('hello world', E'\\s+')`	`{hello,world}`
`regexp_split_to_table(string text, pattern text [, flags text])`	`setof text`	使用一个POSIX正则表达式作为分隔符划分`string`。	`regexp_split_to_table('hello world', E'\\s+')`	`hello` `world` (2 rows)
`repeat(string text, number int)`	`text`	重复`string`指定的`number`次	`repeat('Pg', 4)`	`PgPgPgPg`
`replace(string text, from text, to text)`	`text`	将`string`中出现的所有子串`from`替换为子串`to`	`replace('abcdefabcdef', 'cd', 'XX')`	`abXXefabXXef`
`reverse(str)`	`text`	返回反转的字符串。	`reverse('abcde')`	`edcba`
`right(str text, n int)`	`text`	返回字符串中的最后`n`个字符。如果`n`为负，返回除最前面的\|`n`\|个字符外的所有字符。	`right('abcde', 2)`	`de`
`rpad(string text, length int [`, `fill` `text])`	`text`	将`string`通过增加字符`fill`（默认为一个空格）填充到长度`length`。如果`string`已经长于`length`则它会被截断。	`rpad('hi', 5, 'xy')`	`hixyx`
`rtrim(string text [`, `characters` `text])`	`text`	从`string`的结尾删除最长的只包含`characters`（默认是一个空格）的串	`rtrim('testxxzx', 'xyz')`	`test`
`split_part(string text, delimiter text, field int)`	`text`	按`delimiter`划分`string`并返回给定域（从1开始计算）	`split_part('abc~@~def~@~ghi', '~@~', 2)`	`def`
`strpos(string, substring)`	`int`	指定子串的位置（和`position(substring in string)`相同，但是注意相反的参数顺序）	`strpos('high', 'ig')`	`2`
`substr(string, from [`, `count])`	`text`	提取子串（与`substring(string from from for count)`相同）	`substr('alphabet', 3, 2)`	`ph`
`to_ascii(string text [`, `encoding` `text])`	`text`	将`string`从另一个编码转换到ASCII（只支持从`LATIN1`、`LATIN2`、`LATIN9`和`WIN1250`编码的转换）	`to_ascii('Karel')`	`Karel`
`to_hex(number int or bigint)`	`text`	将`number`转换到它等效的十六进制表示	`to_hex(2147483647)`	`7fffffff`
`translate(string text, from text, to text)`	`text`	`string`中任何匹配`from`集合中一个字符的字符会被替换成`to`集合中的相应字符。如果`from`比`to`长，`from`中的额外字符会被删除。	`translate('12345', '143', 'ax')`

1. 1. 1. format

函数format用于将字段的显示进行格式化。类似于C函数sprintf。语法：

format(formatstr text [, formatarg "any" [, ...] ])

formatstr指定了结果将被如何格式化。格式字符串中的文本，除格式说明符外，都将被直接复制到结果中。格式说明符定义了后续的函数参数将如何被格式化及插入到结果中。格式说明符由一个%字符开始，其语法表示为：

%[position][flags][width]type

其中：

position（可选）：形式为n&，其中n为要打印的参数的索引。如果忽略position会默认使用序列中的下一个参数；
flags（可选）：为符号-时，将格式说明符的输出左对齐。
width（可选）：用于显示格式说明符输出的最小字符数。表示形式：1）一个正整数；2）*表示使用下一个函数参数作为宽度；3）*n$的字符串表示使用第n个函数参数作为宽度。
type（必需）：格式转换的类型，用于产生格式说明符的输出，支持的类型为：1）s将参数格式化为一个简单的字符串；2）I将参数视为SQL标识符，并在必要时用双引号包围；3）L将参数引用为SQL文字。

下面为一些基本的格式转换的例子：

SELECT format('Hello %s', 'World');

结果：Hello World

SELECT format('Testing %s, %s, %s, %%', 'one', 'two', 'three');

结果：Testing one, two, three, %

SELECT format('INSERT INTO %I VALUES(%L)', 'Foo bar', E'O\'Reilly');

结果：INSERT INTO "Foo bar" VALUES('O''Reilly')

SELECT format('INSERT INTO %I VALUES(%L)', 'locations', E'C:\\Program Files');

结果：INSERT INTO locations VALUES(E'C:\\Program Files')

使用width和-标志的例子：

SELECT format('|%10s|', 'foo');

结果：| foo|

SELECT format('|%-10s|', 'foo');

结果：|foo |

SELECT format('|%*s|', 10, 'foo');

结果：| foo|

SELECT format('|%*s|', -10, 'foo');

结果：|foo |

SELECT format('|%-*s|', 10, 'foo');

结果：|foo |

SELECT format('|%-*s|', -10, 'foo');

结果：|foo |

使用position的例子：

SELECT format('Testing %3$s, %2$s, %1$s', 'one', 'two', 'three');

结果：Testing three, two, one

SELECT format('|%*2$s|', 'foo', 10, 'bar');

结果：| bar|

SELECT format('|%1$*2$s|', 'foo', 10, 'bar');

结果：| foo|

1. 1. 二进制串函数和操作符

本节描述了检查和操作类型为bytea的函数和操作符，下表为SQL二进制串函数和操作符：

函数	返回类型	描述	例子	结果
string \|\| string	bytea	串连接	E'\\\\Post'::bytea \|\| E'\\047gres\\000'::bytea	\\Post'gres\000
octet_length(string)	int	二进制串中的字节数	octet_length(E'jo\\000se'::bytea)	5
overlay(string placing string from int [for int])	bytea	替换子串	overlay(E'Th\\000omas'::bytea placing E'\\002\\003'::bytea from 2 for 3)	T\\002\\003mas
position(substring in string)	int	指定子串的位置	position(E'\\000om'::bytea in E'Th\\000omas'::bytea)	3
substring(string [from int] [for int])	bytea	提取子串	substring(E'Th\\000omas'::bytea from 2 for 3)	h\000o
trim([both] bytes from string)	bytea	从string的开头或结尾删除只包含出现在bytes中的字节的最长串	trim(E'\\000\\001'::bytea from E'\\000Tom\\001'::bytea)	Tom

以及一些其他二进制串函数：

函数	返回类型	描述	例子	结果
btrim(string bytea, bytes bytea)	bytea	从string的开头或结尾删除只包含出现在bytes中的字节的最长串	btrim(E'\\000trim\\001'::bytea, E'\\000\\001'::bytea)	trim
decode(string text, format text)	bytea	从string中的文本表示解码二进制数据。format的参数和在encode中一样。	decode(E'123\\000456', 'escape')	123\000456
encode(data bytea, format text)	text	将二进制数据编码为一个文本表示。支持的格式有：base64、hex、escape。escape将零字节和高位组字节转换为八进制序列（\nnn）和双反斜线。	encode(E'123\\000456'::bytea, 'escape')	123\000456
get_bit(string, offset)	int	从串中抽取位	get_bit(E'Th\\000omas'::bytea, 45)	1
get_byte(string, offset)	int	从串中抽取字节	get_byte(E'Th\\000omas'::bytea, 4)	109
length(string)	int	二进制串的长度	length(E'jo\\000se'::bytea)	5
md5(string)	text	计算string的MD5哈希码，以十六进制形式返回结果	md5(E'Th\\000omas'::bytea)	8ab2d3c9689aaf18 b4958c334c82d8b1
set_bit(string, offset, newvalue)	bytea	设置串中的位	set_bit(E'Th\\000omas'::bytea, 45, 0)	Th\000omAs
set_byte(string, offset, newvalue)	bytea	设置串中的字节	set_byte(E'Th\\000omas'::bytea, 4, 64)	Th\000o@as

get_byte和set_byte把一个二进制串中的一个字节计数为字节 0。get_bit和set_bit在每一个字节中从右边起计数位；例如位 0 是第一个字节的最低有效位，而位 15 是第二个字节的最高有效位。

1. 1. 位串函数和操作符

本节描述操作类型为bit和bit varying的值的函数和操作符。

操作符	描述	例子	结果
\|\|	连接	B'10001' \|\| B'011'	10001011
&	按位与	B'10001' & B'01101'	00001
\|	按位或	B'10001' \| B'01101'	11101
#	按位异或	B'10001' # B'01101'	11100
~	按位求反	~ B'10001'	01110
<<	按位左移	B'10001' << 3	01000
>>	按位右移	B'10001' >> 2	00100

1. 1. 模式匹配

GBase 8c提供了三种独立的实现模式匹配的方法：LIKE操作符、SIMILAR TO操作符和POSIX-风格的正则表达式。

1. 1. 1. LIKE

string LIKE pattern [ESCAPE escape-character]

string NOT LIKE pattern [ESCAPE escape-character]

如果该string匹配了提供的pattern，那么LIKE表达式返回真。例如：

'abc' LIKE 'abc' true

'abc' LIKE 'a%' true

'abc' LIKE '_b_' true

'abc' LIKE 'c' false

1. 1. 1. SIMILAR TO正则表达式

string SIMILAR TO pattern [ESCAPE escape-character]

string NOT SIMILAR TO pattern [ESCAPE escape-character]

SIMILAR TO操作符根据自己的模式是否匹配给定串而返回真或者假。例如：

'abc' SIMILAR TO 'abc' true

'abc' SIMILAR TO 'a' false

'abc' SIMILAR TO '%(b|d)%' true

'abc' SIMILAR TO '(b|c)%' false

1. 1. 1. POSIX正则表达式

下表列出了所有可用于POSIX正则表达式模式匹配的操作符：

操作符	描述	例子
~	匹配正则表达式，大小写敏感	'thomas' ~ '.thomas.'
~*	匹配正则表达式，大小写不敏感	'thomas' ~* '.Thomas.'
!~	不匹配正则表达式，大小写敏感	'thomas' !~ '.Thomas.'
!~*	不匹配正则表达式，大小写不敏感	'thomas' !~* '.vadim.'

例如：

'abc' ~ 'abc' true

'abc' ~ '^a' true

'abc' ~ '(b|d)' true

'abc' ~ '^(b|c)' false

1. 1. 数据类型格式化函数

GBase 8c数据库格式化函数提供一套强大的工具用于把各种数据类型（日期/时间、整数、浮点、数字）转换成格式化的字符串以及反过来从格式化的字符串转换成指定的数据类型。这些函数都遵循一个公共的调用习惯：第一个参数是待格式化的值，而第二个是一个定义输出或输入格式的模板。

函数	返回类型	描述	例子
to_char(timestamp, text)	text	把时间戳转成字符串	to_char(current_timestamp, 'HH12:MI:SS')
to_char(interval, text)	text	把间隔转成字符串	to_char(interval '15h 2m 12s', 'HH24:MI:SS')
to_char(int, text)	text	把整数转成字符串	to_char(125, '999')
to_char(double precision, text)	text	把实数或双精度转成字符串	to_char(125.8::real, '999D9')
to_char(numeric, text)	text	把数字转成字符串	to_char(-125.8, '999D99S')
to_date(text, text)	date	把字符串转成日期	to_date('05 Dec 2000', 'DD Mon YYYY')
to_number(text, text)	numeric	把字符串转成数字	to_number('12,454.8-', '99G999D9S')
to_timestamp(text, text)	timestamp with time zone	把字符串转成时间戳	to_timestamp('05 Dec 2000', 'DD Mon YYYY')

1. 1. 时间/日期函数和操作符

如下表为可用于处理日期/时间的函数：

函数	返回类型	描述	例子	结果
`age(timestamp, timestamp)`	`interval`	减去参数，生成一个使用年、月（而不是只用日）的“符号化”的结果	`age(timestamp '2001-04-10', timestamp '1957-06-13')`	`43` `年 9 月 27 日`
`age(timestamp)`	`interval`	从`current_date`（在午夜）减去	`age(timestamp '1957-06-13')`	`43 years 8 mons 3 days`
`clock_timestamp()`	`timestamp with time zone`	当前日期和时间（在语句执行期间变化）
`current_date`	`date`	当前日期
`current_time`	`time with time zone`	当前时间（一天中的时间）
`current_timestamp`	`timestamp with time zone`	当前日期和时间（当前事务开始时）
`date_part(text, timestamp)`	`double precision`	获得子域（等价于`extract`）	`date_part('hour', timestamp '2001-02-16 20:38:40')`	`20`
`date_part(text, interval)`	`double precision`	获得子域（等价于`extract`）	`date_part('month', interval '2 years 3 months')`	`3`
`date_trunc(text, timestamp)`	`timestamp`	截断到指定精度	`date_trunc('hour', timestamp '2001-02-16 20:38:40')`	`2001-02-16 20:00:00`
`date_trunc(text, interval)`	`interval`	截断到指定精度	`date_trunc('hour', interval '2 days 3 hours 40 minutes')`	`2 days 03:00:00`
`extract(field from timestamp)`	`double precision`	获得子域	`extract(hour from timestamp '2001-02-16 20:38:40')`	`20`
`extract(field from interval)`	`double precision`	获得子域	`extract(month from interval '2 years 3 months')`	`3`
`isfinite(date)`	`boolean`	测试有限日期（不是+/-无限）	`isfinite(date '2001-02-16')`	`true`
`isfinite(timestamp)`	`boolean`	测试有限时间戳（不是+/-无限）	`isfinite(timestamp '2001-02-16 21:28:30')`	`true`
`isfinite(interval)`	`boolean`	测试有限间隔	`isfinite(interval '4 hours')`	`true`
`justify_days(interval)`	`interval`	调整间隔这样30天时间周期可以表示为月	`justify_days(interval '35 days')`	`1 mon 5 days`
`justify_hours(interval)`	`interval`	调整间隔这样24小时时间周期可以表示为日	`justify_hours(interval '27 hours')`	`1 day 03:00:00`
`justify_interval(interval)`	`interval`	使用`justify_days`和`justify_hours`调整间隔，使用额外的符号调整	`justify_interval(interval '1 mon -1 hour')`	`29 days 23:00:00`
`localtime`	`time`	当前时间（一天中的时间）
`localtimestamp`	`timestamp`	当前日期和时间（当前事务的开始）
`make_date(year int, month int, day int)`	`date`	从年、月、日域创建日期	`make_date(2013, 7, 15)`	`2013-07-15`
`make_interval(years int DEFAULT 0, months int DEFAULT 0, weeks int DEFAULT 0, days int DEFAULT 0, hours int DEFAULT 0, mins int DEFAULT 0, secs double precision DEFAULT 0.0)`	`interval`	从年、月、周、日、时、分、秒域创建 interval	`make_interval(days => 10)`	`10 days`
`make_time(hour int, min int, sec double precision)`	`time`	从时、分、秒域创建时间	`make_time(8, 15, 23.5)`	`08:15:23.5`
`make_timestamp(year int, month int, day int, hour int, min int, sec double precision)`	`timestamp`	从年、月、日、时、分、秒域创建时间戳	`make_timestamp(2013, 7, 15, 8, 15, 23.5)`	`2013-07-15 08:15:23.5`
`make_timestamptz(year int, month int, day int, hour int, min int, sec double precision, [` `timezone` `text` `])`	`timestamp with time zone`	从年、月、日、时、分、秒域创建带时区的时间戳。如果没有指定`timezone`，则使用当前时区。	`make_timestamptz(2013, 7, 15, 8, 15, 23.5)`	`2013-07-15 08:15:23.5+01`
`now()`	`timestamp with time zone`	当前日期和时间（当前事务的开始）
`statement_timestamp()`	`timestamp with time zone`	当前日期和时间（当前事务的开始）
`timeofday()`	`text`	当前日期和时间（像`clock_timestamp`，但是作为一个`text`字符串）
`transaction_timestamp()`	`timestamp with time zone`	当前日期和时间（当前事务的开始）
`to_timestamp(double precision)`	`timestamp with time zone`	把 Unix 时间（从 1970-01-01 00:00:00+00 开始的秒）转换成 timestamp	`to_timestamp(1284352323)`	`2010-09-13 04:32:03+00`

操作符：

操作符	例子	结果
+	date '2001-09-28' + integer '7'	date '2001-10-05'
+	date '2001-09-28' + interval '1 hour'	timestamp '2001-09-28 01:00:00'
+	date '2001-09-28' + time '03:00'	timestamp '2001-09-28 03:00:00'
+	interval '1 day' + interval '1 hour'	interval '1 day 01:00:00'
+	timestamp '2001-09-28 01:00' + interval '23 hours'	timestamp '2001-09-29 00:00:00'
+	time '01:00' + interval '3 hours'	time '04:00:00'
-	- interval '23 hours'	interval '-23:00:00'
-	date '2001-10-01' - date '2001-09-28'	integer '3' (days)
-	date '2001-10-01' - integer '7'	date '2001-09-24'
-	date '2001-09-28' - interval '1 hour'	timestamp '2001-09-27 23:00:00'
-	time '05:00' - time '03:00'	interval '02:00:00'
-	time '05:00' - interval '2 hours'	time '03:00:00'
-	timestamp '2001-09-28 23:00' - interval '23 hours'	timestamp '2001-09-28 00:00:00'
-	interval '1 day' - interval '1 hour'	interval '1 day -01:00:00'
-	timestamp '2001-09-29 03:00' - timestamp '2001-09-27 12:00'	interval '1 day 15:00:00'
*	900 * interval '1 second'	interval '00:15:00'
*	21 * interval '1 day'	interval '21 days'
*	double precision '3.5' * interval '1 hour'	interval '03:30:00'
/	interval '1 hour' / double precision '1.5'	interval '00:40:00'

1. 1. 枚举支持函数

假设一个枚举类型被创建为：

CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple');

函数	描述	例子	例子结果
enum_first(anyenum)	返回输入枚举类型的第一个值	enum_first(null::rainbow)	red
enum_last(anyenum)	返回输入枚举类型的最后一个值	enum_last(null::rainbow)	purple
enum_range(anyenum)	将输入枚举类型的所有值作为一个有序的数组返回	enum_range(null::rainbow)	{red,orange,yellow,green,blue,purple}
enum_range(anyenum, anyenum)	以一个数组返回在给定两个枚举值之间的范围。值必须来自相同的枚举类型。如果第一个参数为空，其结果将从枚举类型的第一个值开始。如果第二参数为空，其结果将以枚举类型的最后一个值结束。	enum_range('orange'::rainbow, 'green'::rainbow)	{orange,yellow,green}
		enum_range(NULL, 'green'::rainbow)	{red,orange,yellow,green}
		enum_range('orange'::rainbow, NULL)	{orange,yellow,green,blue,purple}

1. 1. 几何函数和操作符

几何类型point、box、 lseg、line、path、 polygon和circle的本地支持函数：

函数	返回类型	描述	例子
area(object)	double precision	面积	area(box '((0,0),(1,1))')
center(object)	point	中心	center(box '((0,0),(1,2))')
diameter(circle)	double precision	圆的直径	diameter(circle '((0,0),2.0)')
height(box)	double precision	方框的垂直尺寸	height(box '((0,0),(1,1))')
isclosed(path)	boolean	一个封闭路径？	isclosed(path '((0,0),(1,1),(2,0))')
isopen(path)	boolean	一个开放路径？	isopen(path '[(0,0),(1,1),(2,0)]')
length(object)	double precision	长度	length(path '((-1,0),(1,0))')
npoints(path)	int	点数	npoints(path '[(0,0),(1,1),(2,0)]')
npoints(polygon)	int	点数	npoints(polygon '((1,1),(0,0))')
pclose(path)	path	将路径转换成封闭的	pclose(path '[(0,0),(1,1),(2,0)]')
popen(path)	path	将路径转换成开放	popen(path '((0,0),(1,1),(2,0))')
radius(circle)	double precision	圆的半径	radius(circle '((0,0),2.0)')
width(box)	double precision	方框的水平尺寸	width(box '((0,0),(1,1))')

几何操作符：

操作符	描述	例子
+	平移	box '((0,0),(1,1))' + point '(2.0,0)'
-	平移	box '((0,0),(1,1))' - point '(2.0,0)'
*	缩放/旋转	box '((0,0),(1,1))' * point '(2.0,0)'
/	缩放/旋转	box '((0,0),(2,2))' / point '(2.0,0)'
#	相交的点或方框	box '((1,-1),(-1,1))' # box '((1,1),(-2,-2))'
#	路径或多边形中的点数	# path '((1,0),(0,1),(-1,0))'
@-@	长度或周长	@-@ path '((0,0),(1,0))'
@@	中心	@@ circle '((0,0),10)'
##	第二个操作数上最接近第一个操作数的点	point '(0,0)' ## lseg '((2,0),(0,2))'
<->	距离	circle '((0,0),1)' <-> circle '((5,0),1)'
&&	是否重叠？（只要有一个公共点这就为真）	box '((0,0),(1,1))' && box '((0,0),(2,2))'
<<	是否严格地在左侧？	circle '((0,0),1)' << circle '((5,0),1)'
>>	是否严格地在右侧？	circle '((5,0),1)' >> circle '((0,0),1)'
&<	没有延展到右边？	box '((0,0),(1,1))' &< box '((0,0),(2,2))'
&>	没有延展到左边？	box '((0,0),(3,3))' &> box '((0,0),(2,2))'
<<\|	严格在下？	box '((0,0),(3,3))' <<\| box '((3,4),(5,5))'
\|>>	严格在上？	box '((3,4),(5,5))' \|>> box '((0,0),(3,3))'
&<\|	没有延展到上面？	box '((0,0),(1,1))' &<\| box '((0,0),(2,2))'
\|&>	没有延展到下面？	box '((0,0),(3,3))' \|&> box '((0,0),(2,2))'
<^	在下面（允许相切）？	circle '((0,0),1)' <^ circle '((0,5),1)'
>^	在上面（允许相切）？	circle '((0,5),1)' >^ circle '((0,0),1)'
?#	相交？	lseg '((-1,0),(1,0))' ?# box '((-2,-2),(2,2))'
?-	水平？	?- lseg '((-1,0),(1,0))'
?-	水平对齐？	point '(1,0)' ?- point '(0,0)'
?\|	垂直？	?\| lseg '((-1,0),(1,0))'
?\|	垂直对齐？	point '(0,1)' ?\| point '(0,0)'
?-\|	相互垂直？	lseg '((0,0),(0,1))' ?-\| lseg '((0,0),(1,0))'
?\|\|	平行？	lseg '((-1,0),(1,0))' ?\|\| lseg '((-1,2),(1,2))'
@>	包含？	circle '((0,0),2)' @> point '(1,1)'
<@	包含在内或在上？	point '(1,1)' <@ circle '((0,0),2)'
~=	相同？	polygon '((0,0),(1,1))' ~= polygon '((1,1),(0,0))'

几何类型转换函数：

函数	返回类型	描述	例子
box(circle)	box	圆到方框	box(circle '((0,0),2.0)')
box(point)	box	点到空方框	box(point '(0,0)')
box(point, point)	box	点到方框	box(point '(0,0)', point '(1,1)')
box(polygon)	box	多边形到方框	box(polygon '((0,0),(1,1),(2,0))')
bound_box(box, box)	box	盒到边界框	bound_box(box '((0,0),(1,1))', box '((3,3),(4,4))')
circle(box)	circle	方框到圆	circle(box '((0,0),(1,1))')
circle(point, double precision)	circle	中心和半径到圆	circle(point '(0,0)', 2.0)
circle(polygon)	circle	多边形到圆	circle(polygon '((0,0),(1,1),(2,0))')
line(point, point)	line	点到线	line(point '(-1,0)', point '(1,0)')
lseg(box)	lseg	方框对角线到线段	lseg(box '((-1,0),(1,0))')
lseg(point, point)	lseg	点到线段	lseg(point '(-1,0)', point '(1,0)')
path(polygon)	path	多边形到路径	path(polygon '((0,0),(1,1),(2,0))')
point(double precision, double precision)	point	构造点	point(23.4, -44.5)
point(box)	point	方框的中心	point(box '((-1,0),(1,0))')
point(circle)	point	圆的中心	point(circle '((0,0),2.0)')
point(lseg)	point	线段的中心	point(lseg '((-1,0),(1,0))')
point(polygon)	point	多边形的中心	point(polygon '((0,0),(1,1),(2,0))')
polygon(box)	polygon	方框到4点多边形	polygon(box '((0,0),(1,1))')
polygon(circle)	polygon	圆到12点多边形	polygon(circle '((0,0),2.0)')
polygon(npts, circle)	polygon	点到npts点多边形	polygon(12, circle '((0,0),2.0)')
polygon(path)	polygon	路径到多边形	polygon(path '((0,0),(1,1),(2,0))')

1. 1. 网络地址函数和操作符

可用于cidr和inet的操作符：

操作符	描述	例子
<	小于	inet '192.168.1.5' < inet '192.168.1.6'
<=	小于等于	inet '192.168.1.5' <= inet '192.168.1.5'
=	等于	inet '192.168.1.5' = inet '192.168.1.5'
>=	大于等于	inet '192.168.1.5' >= inet '192.168.1.5'
>	大于	inet '192.168.1.5' > inet '192.168.1.4'
<>	不等于	inet '192.168.1.5' <> inet '192.168.1.4'
<<	被包含在内	inet '192.168.1.5' << inet '192.168.1/24'
<<=	被包含在内或等于	inet '192.168.1/24' <<= inet '192.168.1/24'
>>	包含	inet '192.168.1/24' >> inet '192.168.1.5'
>>=	包含或等于	inet '192.168.1/24' >>= inet '192.168.1/24'
&&	包含或者被包含contains or is contained by	inet '192.168.1/24' && inet '192.168.1.80/28'
~	按位 NOT	~ inet '192.168.1.6'
&	按位 AND	inet '192.168.1.6' & inet '0.0.0.255'
\|	按位 OR	inet '192.168.1.6' \| inet '0.0.0.255'
+	加	inet '192.168.1.6' + 25
-	减	inet '192.168.1.43' - 36
-	减	inet '192.168.1.43' - inet '192.168.1.19'

可用于cidr和inet的函数：

函数	返回类型	描述	例子	结果
abbrev(inet)	text	缩写显示格式文本	abbrev(inet '10.1.0.0/16')	10.1.0.0/16
abbrev(cidr)	text	缩写显示格式文本	abbrev(cidr '10.1.0.0/16')	10.1/16
broadcast(inet)	inet	网络广播地址	broadcast('192.168.1.5/24')	192.168.1.255/24
family(inet)	int	抽取地址族；4为 IPv4， 6为 IPv6	family('::1')	6
host(inet)	text	抽取 IP 地址为文本	host('192.168.1.5/24')	192.168.1.5
hostmask(inet)	inet	为网络构造主机掩码	hostmask('192.168.23.20/30')	0.0.0.3
masklen(inet)	int	抽取网络掩码长度	masklen('192.168.1.5/24')	24
netmask(inet)	inet	为网络构造网络掩码	netmask('192.168.1.5/24')	255.255.255.0
network(inet)	cidr	抽取地址的网络部分	network('192.168.1.5/24')	192.168.1.0/24
set_masklen(inet, int)	inet	为inet值设置网络掩码长度	set_masklen('192.168.1.5/24', 16)	192.168.1.5/16
set_masklen(cidr, int)	cidr	为cidr值设置网络掩码长度	set_masklen('192.168.1.0/24'::cidr, 16)	192.168.0.0/16
text(inet)	text	抽取 IP 地址和网络掩码长度为文本	text(inet '192.168.1.5')	192.168.1.5/32
inet_same_family(inet, inet)	boolean	地址来自同一个地址族吗？	inet_same_family('192.168.1.5/24', '::1')	false
inet_merge(inet, inet)	cidr	最小的网络包括给定的两个网络	inet_merge('192.168.1.5/24', '192.168.2.5/24')	192.168.0.0/22

可以用于macaddr类型的函数：

函数	返回类型	描述	例子	结果
trunc(macaddr)	macaddr	设置最后3个字节为零	trunc(macaddr '12:34:56:78:90:ab')	12:34:56:00:00:00

可用于macaddr8 类型的函数：

函数	返回类型	描述	示例	结果
trunc(macaddr8)	macaddr8	将最后5个字节设置为零	trunc(macaddr8 '12:34:56:78:90:ab:cd:ef')	12:34:56:00:00:00:00:00
macaddr8_set7bit(macaddr8)	macaddr8	将第7位设置为1，也称为修改的EUI-64，以包含在IPv6地址中	macaddr8_set7bit(macaddr8 '00:34:56:ab:cd:ef')	02:34:56:ff:fe:ab:cd:ef

1. 1. 文本搜索函数和操作符

文本搜索操作符：

操作符	返回类型	描述	例子	结果
@@	boolean	tsvector匹配tsquery吗？	to_tsvector('fat cats ate rats') @@ to_tsquery('cat & rat')	t
@@@	boolean	@@的已废弃同义词	to_tsvector('fat cats ate rats') @@@ to_tsquery('cat & rat')	t
\|\|	tsvector	连接tsvector	'a:1 b:2'::tsvector \|\| 'c:1 d:2 b:3'::tsvector	'a':1 'b':2,5 'c':3 'd':4
&&	tsquery	将tsquery用 AND 连接起来	'fat \| rat'::tsquery && 'cat'::tsquery	( 'fat' \| 'rat' ) & 'cat'
\|\|	tsquery	将tsquery用 OR 连接起来	'fat \| rat'::tsquery \|\| 'cat'::tsquery	( 'fat' \| 'rat' ) \| 'cat'
!!	tsquery	对一个tsquery取反	!! 'cat'::tsquery	!'cat'
<->	tsquery	tsquery后面跟着tsquery	to_tsquery('fat') <-> to_tsquery('rat')	'fat' <-> 'rat'
@>	boolean	tsquery包含另一个？	'cat'::tsquery @> 'cat & rat'::tsquery	f
<@	boolean	tsquery被包含？	'cat'::tsquery <@ 'cat & rat'::tsquery	t

文本搜索函数：

函数	返回类型	描述	例子	结果
array_to_tsvector(text[])	tsvector	把词位数组转换成tsvector	array_to_tsvector('{fat,cat,rat}'::text[])	'cat' 'fat' 'rat'
get_current_ts_config()	regconfig	获得默认文本搜索配置	get_current_ts_config()	english
length(tsvector)	integer	tsvector中的词位数	length('fat:2,4 cat:3 rat:5A'::tsvector)	3
numnode(tsquery)	integer	tsquery中词位外加操作符的数目	numnode('(fat & rat) \| cat'::tsquery)	5
plainto_tsquery([ config regconfig , ] query text)	tsquery	产生tsquery但忽略标点符号	plainto_tsquery('english', 'The Fat Rats')	'fat' & 'rat'
phraseto_tsquery([ config regconfig , ] query text)	tsquery	产生忽略标点搜索短语的tsquery	phraseto_tsquery('english', 'The Fat Rats')	'fat' <-> 'rat'
querytree(query tsquery)	text	获得一个tsquery的可索引部分	querytree('foo & ! bar'::tsquery)	'foo'
setweight(tsvector, "char")	tsvector	为tsvector的每一个元素分配权重	setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A')	'cat':3A 'fat':2A,4A 'rat':5A
setweight(vector tsvector, weight "char", lexemes text[])	tsvector	为lexemes中列出的 vector元素分配权重	setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A', '{cat,rat}')	'cat':3A 'fat':2,4 'rat':5A
strip(tsvector)	tsvector	从tsvector中移除位置和权重	strip('fat:2,4 cat:3 rat:5A'::tsvector)	'cat' 'fat' 'rat'
to_tsquery([ config regconfig , ] query text)	tsquery	规范化词并转换成tsquery	to_tsquery('english', 'The & Fat & Rats')	'fat' & 'rat'
to_tsvector([ config regconfig , ] document text)	tsvector	缩减文档文本成tsvector	to_tsvector('english', 'The Fat Rats')	'fat':2 'rat':3
to_tsvector([ config regconfig , ] document json(b))	tsvector	将文档中的每个字符串值减少到tsvector，然后按文档顺序连接以生成一个tsvector	to_tsvector('english', '{"a": "The Fat Rats"}'::json)	'fat':2 'rat':3
ts_delete(vector tsvector, lexeme text)	tsvector	从vector中移除给定的 lexeme	ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, 'fat')	'cat':3 'rat':5A
ts_delete(vector tsvector, lexemes text[])	tsvector	从vector中移除 lexemes中词位的任何出现	ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, ARRAY['fat','rat'])	'cat':3
ts_filter(vector tsvector, weights "char"[])	tsvector	从vector 中只选择带有给定权重的元素	ts_filter('fat:2,4 cat:3b rat:5A'::tsvector, '{a,b}')	'cat':3B 'rat':5A
ts_headline([ config regconfig, ] document text, query tsquery [, options text ])	text	显示一个查询匹配	ts_headline('x y z', 'z'::tsquery)	x y <b>z</b>
ts_headline([ config regconfig, ] document json(b), query tsquery [, options text ])	text	显示查询匹配	ts_headline('{"a":"x y z"}'::json, 'z'::tsquery)	{"a":"x y <b>z</b>"}
ts_rank([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ])	float4	为查询排名文档	ts_rank(textsearch, query)	0.818
ts_rank_cd([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ])	float4	使用覆盖密度为查询排名文档	ts_rank_cd('{0.1, 0.2, 0.4, 1.0}', textsearch, query)	2.01317
ts_rewrite(query tsquery, target tsquery, substitute tsquery)	tsquery	在查询内用 substitute 替换 target	ts_rewrite('a & b'::tsquery, 'a'::tsquery, 'foo\|bar'::tsquery)	'b' & ( 'foo' \| 'bar' )
ts_rewrite(query tsquery, select text)	tsquery	使用来自一个SELECT的目标和替换者进行替换	SELECT ts_rewrite('a & b'::tsquery, 'SELECT t,s FROM aliases')	'b' & ( 'foo' \| 'bar' )
tsquery_phrase(query1 tsquery, query2 tsquery)	tsquery	制造搜索后面跟着query2的query1 的查询（和<->操作符相同）	tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'))	'fat' <-> 'cat'
tsquery_phrase(query1 tsquery, query2 tsquery, distance integer)	tsquery	制造查询来搜索在query1后面距离 distance上跟着query2的情况	tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'), 10)	'fat' <10> 'cat'
tsvector_to_array(tsvector)	text[]	把tsvector转换为词位数组	tsvector_to_array('fat:2,4 cat:3 rat:5A'::tsvector)	{cat,fat,rat}
tsvector_update_trigger()	trigger	用于自动tsvector列更新的触发器函数	CREATE TRIGGER ... tsvector_update_trigger(tsvcol, 'pg_catalog.swedish', title, body)
tsvector_update_trigger_column()	trigger	用于自动tsvector列更新的触发器函数	CREATE TRIGGER ... tsvector_update_trigger_column(tsvcol, configcol, title, body)
unnest(tsvector, OUT lexeme text, OUT positions smallint[], OUT weights text)	setof record	把一个tsvector扩展成一组行	unnest('fat:2,4 cat:3 rat:5A'::tsvector)	(cat,{3},{D}) ...

文本搜索调试函数：

函数	返回类型	描述	例子	结果
ts_debug([ config regconfig, ] document text, OUT alias text, OUT description text, OUT token text, OUT dictionaries regdictionary[], OUT dictionary regdictionary, OUT lexemes text[])	setof record	测试一个配置	ts_debug('english', 'The Brightest supernovaes')	(asciiword,"Word, all ASCII",The,{english_stem},english_stem,{}) ...
ts_lexize(dict regdictionary, token text)	text[]	测试一个字典	ts_lexize('english_stem', 'stars')	{star}
ts_parse(parser_name text, document text, OUT tokid integer, OUT token text)	setof record	测试一个解析器	ts_parse('default', 'foo - bar')	(1,foo) ...
ts_parse(parser_oid oid, document text, OUT tokid integer, OUT token text)	setof record	测试一个解析器	ts_parse(3722, 'foo - bar')	(1,foo) ...
ts_token_type(parser_name text, OUT tokid integer, OUT alias text, OUT description text)	setof record	获得解析器定义的记号类型	ts_token_type('default')	(1,asciiword,"Word, all ASCII") ...
ts_token_type(parser_oid oid, OUT tokid integer, OUT alias text, OUT description text)	setof record	获得解析器定义的记号类型	ts_token_type(3722)	(1,asciiword,"Word, all ASCII") ...
ts_stat(sqlquery text, [ weights text, ] OUT word text, OUT ndoc integer, OUT nentry integer)	setof record	获得一个tsvector列的统计	ts_stat('SELECT vector from apod')	(foo,10,15) ...

1. 1. XML函数

使用XML函数：

函数	描述	语法
xmlcomment	创建一个包含使用指定文本内容的XML文件，不包含“--”或“-”	xmlcomment(text)
xmlconcat	将由单个XML值组成的列表串成一个单独的值	xmlconcat(xml[, ...])
xmlelement	使用给定的名称、属性和内容生成一个XML元素	xmlelement(name name [, xmlattributes(value [AS attname] [, ... ])] [, content, ...])
xmlforest	使用给定的名称和内容产生一个XML序列	xmlforest(content [AS name] [, ...])
xmlpi	创建一个XML处理命令	xmlpi(name target [, content])
xmlroot	用于替换XML根节点的值属性	xmlroot(xml, version text \| no value [, standalone yes\|no\|no value])
xmlagg	函数xmlagg是一个聚集函数，将聚集函数调用的输入值串接起来	xmlagg(xml)

1. 1. JSON 函数和操作符

json和jsonb 操作符：

操作符	右操作数类型	描述	例子	例子结果
->	int	获得 JSON 数组元素（索引从 0 开始，负整数结束）	'[{"a":"foo"},{"b":"bar"},{"c":"baz"}]'::json->2	{"c":"baz"}
->	text	通过键获得 JSON 对象域	'{"a": {"b":"foo"}}'::json->'a'	{"b":"foo"}
->>	int	以文本形式获得 JSON 数组元素	'[1,2,3]'::json->>2	3
->>	text	以文本形式获得 JSON 对象域	'{"a":1,"b":2}'::json->>'b'	2
#>	text[]	获取在指定路径的 JSON 对象	'{"a": {"b":{"c": "foo"}}}'::json#>'{a,b}'	{"c": "foo"}
#>>	text[]	以文本形式获取在指定路径的 JSON 对象	'{"a":[1,2,3],"b":[4,5,6]}'::json#>>'{a,2}'	3

1. 1. 序列操作函数

序列操作函数是用于操作序列对象的函数，序列对象都是用CREATE SEQUENCE创建的特殊的单行表。

函数	返回类型	描述
currval(regclass)	bigint	返回最近一次用nextval获取的指定序列的值
lastval()	bigint	返回最近一次用nextval获取的任何序列的值
nextval(regclass)	bigint	递增序列并返回新值
setval(regclass, bigint)	bigint	设置序列的当前值
setval(regclass, bigint, boolean)	bigint	设置序列的当前值以及is_called标志

1. 1. 条件表达式

表达式	描述	语法
CASE	通用的条件表达式	CASE WHEN condition THEN result [WHEN ...] [ELSE result] END
COALESCE	COALESCE函数返回它的第一个非空参数的值。	COALESCE(value [, ...])
NULLIF	当value1和value2相等时，NULLIF返回一个空值。否则它返回value1。	NULLIF(value1, value2)
GREATEST和LEAST	从一个任意的数字表达式列表里选取最大或者最小的数值	GREATEST(value [, ...]) LEAST(value [, ...])

1. 1. 数组函数和操作符

下表显示了可以用于数组类型的操作符：

操作符	描述	例子	结果
=	等于	ARRAY[1.1,2.1,3.1]::int[] = ARRAY[1,2,3]	t
<>	不等于	ARRAY[1,2,3] <> ARRAY[1,2,4]	t
<	小于	ARRAY[1,2,3] < ARRAY[1,2,4]	t
>	大于	ARRAY[1,4,3] > ARRAY[1,2,4]	t
<=	小于等于	ARRAY[1,2,3] <= ARRAY[1,2,3]	t
>=	大于等于	ARRAY[1,4,3] >= ARRAY[1,4,3]	t
@>	包含	ARRAY[1,4,3] @> ARRAY[3,1]	t
<@	被包含	ARRAY[2,7] <@ ARRAY[1,7,4,2,6]	t
&&	重叠（具有公共元素）	ARRAY[1,4,3] && ARRAY[2,1]	t
\|\|	数组和数组串接	ARRAY[1,2,3] \|\| ARRAY[4,5,6]	{1,2,3,4,5,6}
\|\|	数组和数组串接	ARRAY[1,2,3] \|\| ARRAY[[4,5,6],[7,8,9]]	{{1,2,3},{4,5,6},{7,8,9}}
\|\|	元素到数组串接	3 \|\| ARRAY[4,5,6]	{3,4,5,6}
\|\|	数组到元素串接	ARRAY[4,5,6] \|\| 7	{4,5,6,7}

下表展示了可用于数组类型的函数：

函数	返回类型	描述	例子	结果
`array_append(anyarray, anyelement)`	`anyarray`	向一个数组的末端追加一个元素	`array_append(ARRAY[1,2], 3)`	`{1,2,3}`
`array_cat(anyarray, anyarray)`	`anyarray`	连接两个数组	`array_cat(ARRAY[1,2,3], ARRAY[4,5])`	`{1,2,3,4,5}`
`array_ndims(anyarray)`	`int`	返回数组的维度数	`array_ndims(ARRAY[[1,2,3], [4,5,6]])`	`2`
`array_dims(anyarray)`	`text`	返回数组的维度的文本表示	`array_dims(ARRAY[[1,2,3], [4,5,6]])`	`[1:2][1:3]`
`array_fill(anyelement, int[], [`, `int[]])`	`anyarray`	返回一个用提供的值和维度初始化好的数组，可以选择下界不为 1	`array_fill(7, ARRAY[3], ARRAY[2])`	`[2:4]={7,7,7}`
`array_length(anyarray, int)`	`int`	返回被请求的数组维度的长度	`array_length(array[1,2,3], 1)`	`3`
`array_lower(anyarray, int)`	`int`	返回被请求的数组维度的下界	`array_lower('[0:2]={1,2,3}'::int[], 1)`	`0`
`array_position(anyarray, anyelement [`, `int])`	`int`	返回数组中第二个参数第一次出现的下标。起始于第三个参数或第一个元素指示的元素位置（数组必须是一维的)	`array_position(ARRAY['sun','mon','tue','wed','thu','fri','sat'], 'mon')`	`2`
`array_positions(anyarray, anyelement)`	`int[]`	返回作为第一个参数的数组中第二个参数出现的数组下标（数组必须是一维的)	`array_positions(ARRAY['A','A','B','A'], 'A')`	`{1,2,4}`
`array_prepend(anyelement, anyarray)`	`anyarray`	向一个数组的首部追加一个元素	`array_prepend(1, ARRAY[2,3])`	`{1,2,3}`
`array_remove(anyarray, anyelement)`	`anyarray`	从数组中移除所有等于给定值的所有元素（数组必须是一维的）	`array_remove(ARRAY[1,2,3,2], 2)`	`{1,3}`
`array_replace(anyarray, anyelement, anyelement)`	`anyarray`	将每一个等于给定值的数组元素替换成一个新值	`array_replace(ARRAY[1,2,5,4], 5, 3)`	`{1,2,3,4}`
`array_to_string(anyarray, text [`, `text])`	`text`	使用提供的定界符和可选的空串连接数组元素	`array_to_string(ARRAY[1, 2, 3, NULL, 5], ',', '*')`	`1,2,3,*,5`
`array_upper(anyarray, int)`	`int`	返回被请求的数组维度的上界	`array_upper(ARRAY[1,8,3,7], 1)`	`4`
`cardinality(anyarray)`	`int`	返回数组中元素的总数，如果数组为空则返回 0	`cardinality(ARRAY[[1,2],[3,4]])`	`4`
`string_to_array(text, text [`, `text])`	`text[]`	使用提供的定界符和可选的空串将字符串划分成数组元素	`string_to_array('xx~^~yy~^~zz', '~^~', 'yy')`	`{xx,NULL,zz}`
`unnest(anyarray)`	`setof anyelement`	将一个数组扩展成一组行	`unnest(ARRAY[1,2])`	1 2 (2 rows)
`unnest(anyarray, anyarray [, ...])`	`setof anyelement, anyelement [, ...]`	把多维数组（可能是不同类型）扩展成一个行的集合。这只允许用在 FROM 子句中	`unnest(ARRAY[1,2],ARRAY['foo','bar','baz'])`

在array_position和array_positions中，每个数组元素与使用IS NOT DISTINCT FROM语法的搜索值进行比较。

在array_position中，如果没有找到该值，则返回NULL。

在array_positions中，如果数组是NULL，则返回NULL；如果数组中没有找到该值，相反返回空数组。

在string_to_array中，如果定界符参数为 NULL，输入字符串中的每一个字符将变成结果数组中的一个独立元素。如果定界符是一个空串，则整个输入字符串被作为一个单一元素的数组返回。否则输入字符串会被在每一个出现定界符字符串的位置分裂。

在string_to_array中，如果空值串参数被忽略或者为 NULL，输入中的子串不会被替换成 NULL。在array_to_string中，如果空值串参数被忽略或者为 NULL，该数组中的任何空值元素会被简单地跳过并且不会在输出串中被表示。

1. 1. 范围函数和操作符

下表为可用的范围类型操作符：

操作符	描述	例子	结果
=	等于	int4range(1,5) = '[1,4]'::int4range	t
<>	不等于	numrange(1.1,2.2) <> numrange(1.1,2.3)	t
<	小于	int4range(1,10) < int4range(2,3)	t
>	大于	int4range(1,10) > int4range(1,5)	t
<=	小于等于	numrange(1.1,2.2) <= numrange(1.1,2.2)	t
>=	大于等于	numrange(1.1,2.2) >= numrange(1.1,2.0)	t
@>	包含范围	int4range(2,4) @> int4range(2,3)	t
@>	包含元素	'[2011-01-01,2011-03-01)'::tsrange @> '2011-01-10'::timestamp	t
<@	范围被包含	int4range(2,4) <@ int4range(1,7)	t
<@	元素被包含	42 <@ int4range(1,7)	f
&&	重叠（有公共点）	int8range(3,7) && int8range(4,12)	t
<<	严格左部	int8range(1,10) << int8range(100,110)	t
>>	严格右部	int8range(50,60) >> int8range(20,30)	t
&<	不超过右部	int8range(1,20) &< int8range(18,20)	t
&>	不超过左部	int8range(7,20) &> int8range(5,10)	t
-\|-	相邻	numrange(1.1,2.2) -\|- numrange(2.2,3.3)	t
+	并	numrange(5,15) + numrange(10,20)	[5,20)
*	交	int8range(5,15) * int8range(10,20)	[10,15)
-	差	int8range(5,15) - int8range(10,20)	[5,10)

可用的范围类型的函数：

函数	返回类型	描述	例子	结果
lower(anyrange)	范围的元素类型	范围的下界	lower(numrange(1.1,2.2))	1.1
upper(anyrange)	范围的元素类型	范围的上界	upper(numrange(1.1,2.2))	2.2
isempty(anyrange)	boolean	范围为空？	isempty(numrange(1.1,2.2))	false
lower_inc(anyrange)	boolean	下界包含在内？	lower_inc(numrange(1.1,2.2))	true
upper_inc(anyrange)	boolean	上界包含在内？	upper_inc(numrange(1.1,2.2))	false
lower_inf(anyrange)	boolean	下界无限？	lower_inf('(,)'::daterange)	true
upper_inf(anyrange)	boolean	上界无限？	upper_inf('(,)'::daterange)	true
range_merge(anyrange, anyrange)	anyrange	最小范围其中包含两个给定范围	range_merge('[1,2)'::int4range, '[3,4)'::int4range)	[1,4)

如果范围为空或者被请求的界是无限的，lower和upper函数返回空值。函数lower_inc、upper_inc、lower_inf和upper_inf对一个空范围全部返回假。

1. 1. 聚集函数

聚集函数将结果集进行计算并通常返回一行。

通用聚集函数：

函数	参数类型	返回类型	局部模式	描述
`array_agg(expression)`	任何非数组类型	参数类型的数组	No	输入值（包括空）被连接到一个数组
`array_agg(expression)`	任何数组类型	和参数数据类型一样	No	级联到更高维数组的输入数组（输入必须都具有相同的维度，不能为空或NULL）
`avg(expression)`	`smallint`, `int`, `bigint`、`real`、`double precision`、`numeric`或`interval`	对于任何整数类型参数是`numeric`，对于一个浮点参数是`double precision`，否则和参数数据类型相同	Yes	所有输入值的平均值（算术平均）
`bit_and(expression)`	`smallint`、`int`、`bigint`或`bit`	与参数数据类型相同	Yes	所有非空输入值的按位与，如果没有非空值则结果是空值
`bit_or(expression)`	`smallint`, `int`, `bigint`, or `bit`	与参数数据类型相同	Yes	所有非空输入值的按位或，如果没有非空值则结果是空值
`bool_and(expression)`	`bool`	`bool`	Yes	如果所有输入值为真则结果为真，否则为假
`bool_or(expression)`	`bool`	`bool`	Yes	至少一个输入值为真时结果为真，否则为假
`count(*)`		`bigint`	Yes	输入的行数
`count(expression)`	any	`bigint`	Yes	`expression`值非空的输入行的数目
`every(expression)`	`bool`	`bool`	Yes	等价于`bool_and`
`json_agg(expression)`	`any`	`json`	No	将值聚集成一个 JSON 数组
`jsonb_agg(expression)`	`any`	`jsonb`	No	将值聚集成一个JSON数组
`json_object_agg(name, value)`	`(any, any)`	`json`	No	将名字/值对聚集成一个 JSON 对象
`jsonb_object_agg(name, value)`	`(any, any)`	`jsonb`	No	将名字/值对聚集成一个JSON对象
`max(expression)`	任意数字、字符串，日期/时间，网络，或枚举类型或这些类型数组	与参数数据类型相同	Yes	所有输入值中`expression`的最大值
`min(expression)`	任意数字、字符串，日期/时间，网络，或枚举类型或这些类型数组	与参数数据类型相同	Yes	所有输入值中`expression`的最小值
`string_agg(expression, delimiter)`	(`text`, `text`) 或 (`bytea`, `bytea`)	与参数数据类型相同	No	输入值连接成一个串，用定界符分隔
`sum(expression)`	`smallint`、`int`、 `bigint`、`real`、`double precision`、`numeric`、 `interval`或`money`	对`smallint`或`int`参数是`bigint`，对`bigint`参数是`numeric`，否则和参数数据类型相同	Yes	所有输入值的`expression`的和
`xmlagg(expression)`	`xml`	`xml`	No	连接 XML 值

用于统计的聚集函数：

函数	参数类型	返回类型	局部模式	描述
corr(Y, X)	double precision	double precision	Yes	相关系数
covar_pop(Y, X)	double precision	double precision	Yes	总体协方差
covar_samp(Y, X)	double precision	double precision	Yes	样本协方差
regr_avgx(Y, X)	double precision	double precision	Yes	自变量的平均值（sum(X)/N）
regr_avgy(Y, X)	double precision	double precision	Yes	因变量的平均值（sum(Y)/N）
regr_count(Y, X)	double precision	bigint	Yes	两个表达式都不为空的输入行的数目
regr_intercept(Y, X)	double precision	double precision	Yes	由（X, Y）对决定的最小二乘拟合的线性方程的 y截距
regr_r2(Y, X)	double precision	double precision	Yes	相关系数的平方
regr_slope(Y, X)	double precision	double precision	Yes	由（X, Y）对决定的最小二乘拟合的线性方程的斜率
regr_sxx(Y, X)	double precision	double precision	Yes	sum(X^2) - sum(X)^2/N（自变量的“平方和”）
regr_sxy(Y, X)	double precision	double precision	Yes	sum(XY) - sum(X) sum(Y)/N（自变量乘以因变量的“积之合”）
regr_syy(Y, X)	double precision	double precision	Yes	sum(Y^2) - sum(Y)^2/N（因变量的“平方和”）
stddev(expression)	smallint、int、 bigint、real、double precision或numeric	浮点参数为double precision，否则为numeric	Yes	stddev_samp的历史别名
stddev_pop(expression)	smallint、int、 bigint、real、double precision或numeric	浮点参数为double precision，否则为numeric	Yes	输入值的总体标准偏差
stddev_samp(expression)	smallint、int、 bigint、real、double precision或numeric	浮点参数为double precision，否则为numeric	Yes	输入值的样本标准偏差
variance(expression)	smallint、int、 bigint、real、double precision或numeric	浮点参数为double precision，否则为numeric	Yes	var_samp的历史别名
var_pop(expression)	smallint、int、 bigint、real、double precision或numeric	浮点参数为double precision，否则为numeric	Yes	输入值的总体方差（总体标准偏差的平方）
var_samp(expression)	smallint、int、 bigint、real、double precision或numeric	浮点参数为double precision，否则为numeric	Yes	输入值的样本方差（样本标准偏差的平方）

有序集聚集函数：

函数	直接参数类型	聚集参数类型	返回类型	局部模式	描述
mode() WITHIN GROUP (ORDER BY sort_expression)		任何可排序类型	与排序表达式相同	No	返回最频繁的输入值（如果有多个频度相同的值就选第一个）
percentile_cont(fraction) WITHIN GROUP (ORDER BY sort_expression)	double precision	double precision或者interval	与排序表达式相同	No	连续百分率：返回一个对应于排序中指定分数的值，如有必要就在相邻的输入项之间插值
percentile_cont(fractions) WITHIN GROUP (ORDER BY sort_expression)	double precision[]	double precision或者interval	排序表达式的类型的数组	No	多重连续百分率：返回一个匹配fractions参数形状的结果数组，其中每一个非空元素都用对应于那个百分率的值替换
percentile_disc(fraction) WITHIN GROUP (ORDER BY sort_expression)	double precision	一种可排序类型	与排序表达式相同	No	离散百分率：返回第一个在排序中位置等于或者超过指定分数的输入值
percentile_disc(fractions) WITHIN GROUP (ORDER BY sort_expression)	double precision[]	任何可排序类型	排序表达式的类型的数组	No	多重离散百分率：返回一个匹配fractions参数形状的结果数组，其中每一个非空元素都用对应于那个百分率的输入值替换

假想集聚集函数：

函数	直接参数类型	聚集参数类型	返回类型	局部模式	描述
rank(args) WITHIN GROUP (ORDER BY sorted_args)	VARIADIC "any"	VARIADIC "any"	bigint	No	假想行的排名，为重复的行留下间隔
dense_rank(args) WITHIN GROUP (ORDER BY sorted_args)	VARIADIC "any"	VARIADIC "any"	bigint	No	假想行的排名，不留间隔
percent_rank(args) WITHIN GROUP (ORDER BY sorted_args)	VARIADIC "any"	VARIADIC "any"	double precision	No	假想行的相对排名，范围从 0 到 1
cume_dist(args) WITHIN GROUP (ORDER BY sorted_args)	VARIADIC "any"	VARIADIC "any"	double precision	No	假想行的相对排名，范围从 1/N 到 1

这些假想集聚集的每一个args中给定的直接参数列表必须匹配sorted_args中给定的聚集参数的数量和类型。

分组操作：

函数	返回类型	描述
GROUPING(args...)	integer	整数位掩码表示当前分组集中不包含的参数

1. 1. 窗口函数

窗口函数提供实时的数据执行计算的能力。

窗口函数基于结果集进行计算，并将计算出的结果合并到输出的结果集上，并返回多行。使用聚集函数能大幅简化SQL代码。

通用的窗口函数：

函数	返回类型	描述
row_number()	bigint	当前行在其分区中的行号，从1计
rank()	bigint	带间隙的当前行排名；与该行的第一个同等行的row_number相同
dense_rank()	bigint	不带间隙的当前行排名；这个函数计数同等组
percent_rank()	double precision	当前行的相对排名： (rank- 1) / (总分区行数 - 1)
cume_dist()	double precision	累积分配： (当前行前面的分区行数或与当前行同等的行的分区行数)/(总分区行数)
ntile(num_buckets integer)	integer	从1到参数值的整数范围，尽可能等分分区
lag(value anyelement [, offset integer [, default anyelement ]])	和value的类型相同	返回value，它在分区内当前行的之前offset个位置的行上计算；如果没有这样的行，返回default替代。 (作为value必须是相同类型)。 offset和default都是根据当前行计算的结果。如果忽略它们，则offset默认是1，default默认是空值
lead(value anyelement [, offset integer [, default anyelement ]])	和value类型相同	返回value，它在分区内当前行的之后offset个位置的行上计算；如果没有这样的行，返回default替代。(作为value必须是相同类型)。offset和default都是根据当前行计算的结果。如果忽略它们，则offset默认是1，default默认是空值
first_value(value any)	same type as value	返回在窗口帧中第一行上计算的value
last_value(value any)	和value类型相同	返回在窗口帧中最后一行上计算的value
nth_value(value any, nth integer)	和value类型相同	返回在窗口帧中第nth行（行从1计数）上计算的value；没有这样的行则返回空值

上述函数，必须使用标准窗口函数语法（OVER）调用，且依赖于ORDER BY子句进行排序。具体的窗口函数语法细节请参考窗口函数。

1. 1. 子查询表达式

本节中的子查询表达式都返回布尔值结果（真/假）。

表达式	描述
EXISTS (subquery)	subquery可以是任意的SELECT语句。系统对子查询进行运算以判断它是否返回行。如果至少返回一行，那么EXISTS的结果就为“真”；如果子查询没有返回行，那么EXISTS的结果是“假”。
expression IN (subquery)	expression与subquery进行逐行比较，有任意行相等则为“真”，否则为“假”。如果没有相等的行且有至少一个空值，则结果为空。
expression NOT IN (subquery)	expression与subquery进行逐行比较，有任意行不相等则为“真”，否则为“假”
expression operator ANY (subquery) expression operator SOME (subquery)	ANY和SOME在这里是等效的。左边表达式使用operator对结果集的每一行进行一次比较运算，如果有一个运算结果是“真”，则表达式结果为“真”，如果比较结果全部是“假”表达式结果才是“假”。如果任一返回得到一个空值，则结果为空。
expression operator ALL (subquery)	左边表达式使用operator对结果集的每一行进行一次比较运算，如果有全部运算结果是“真”，则表达式结果为“真”，如果没有存在任何假值结果，那么结果是“假”。如果任何行都不返回假且至少返回一行空，则结果为空。
row_constructor operator (subquery)	该查询必须返回和左边行中表达式数目完全一样的列。左边表达式将使用给出的 operator对子查询的结果的每一行进行一次计算和比较。

1. 1. 行和数组比较

本节中的子查询表达式都返回布尔值结果（真/假）。

表达式	描述
expression IN (value [, ...])	如果左边表达式的结果等于右边表达式中的任一个，则结果为“真”，否则为假；如果没有相等的右边表达式且有至少一个空值，则结果为空。
expression NOT IN (value [, ...])	将左边的表达式与右边的子查询进行逐行比较，如果全部不相同则返回为“真”，如果有任一相等的行则为“假”，如果没有相同的行且任一行返回为空，则结果为空。
expression operator ANY (array expression) expression operator SOME (array expression)	ANY和SOME在这里是等效的。左边表达式使用operator对数组的元素进行一次比较运算，如果有一个运算结果是“真”，则表达式结果为“真”，如果比较结果全部是“假”表达式结果才是“假”。如果任一返回得到一个空值，则结果为空。
expression operator ALL (array expression)	左边表达式使用operator对数组元素进行一次比较运算，如果有全部运算结果是“真”，则表达式结果为“真”，如果没有存在任何假值结果，那么结果是“假”。如果任何行都不返回假且至少返回一行空，则结果为空。
row_constructor operator row_constructor	该查询必须返回和左边行中数组元素数目完全一样的列。左边表达式将使用给出的 operator对子查询的数组元素的每一行进行一次计算和比较。
record operator record	当操作符是 =、 <>、 <、 <=、 >或者 >=时或者具有与这些类似的语义时，允许组合类型的比较；=, <>, <, <=, >, and >=. 这些操作符比较两行的内部二进制表达。

1. 1. 集合返回函数

本节描述的函数，可能返回多行结果。首先，应用最广泛的是初级生成函数：

函数	参数类型	返回类型	描述
generate_series(start, stop)	int，bigint或者numeric	setof int，setof bigint或者setof numeric (与参数类型相同)	产生一系列值，从start到stop，步长为 1
generate_series(start, stop, step)	int，bigint或者numeric	setof int，setof bigint或者setof numeric (与参数类型相同)	产生一系列值，从start到stop，步长为step
generate_series(start, stop, step interval)	timestamp或timestamp with time zone	setof timestamp或setof timestamp with time zone（和参数类型相同）	产生一系列值，从start到stop，步长为step

下标生成函数：

函数	返回类型	描述
generate_subscripts(array anyarray, dim int)	setof int	生成一个级数组成给定数组的下标。
generate_subscripts(array anyarray, dim int, reverse boolean)	setof int	生成一个级数组成给定数组的下标。当reverse为真，级数以逆序返回。

1. 1. 系统信息函数

会话信息函数：

名称	返回类型	描述
`current_catalog`	`name`	当前数据库名（SQL 标准中称作“目录”）
`current_database()`	`name`	当前数据库名
`current_query()`	`text`	当前正在执行的查询的文本，和客户端提交的一样（可能包含多于一个语句）
`current_role`	`name`	等效于`current_user`
`current_schema[()]`	`name`	当前模式名
`current_schemas(boolean)`	`name[]`	搜索路径中的模式名，可以选择是否包含隐式模式
`current_user`	`name`	当前执行上下文的用户名
`inet_client_addr()`	`inet`	远程的客户端连接地址
`inet_client_port()`	`int`	远程的客户端连接端口
`inet_server_addr()`	`inet`	本地的服务端连接地址
`inet_server_port()`	`int`	本地的服务端连接端口
`pg_backend_pid()`	`int`	与当前会话关联的服务器进程的进程 ID
`pg_blocking_pids(int)`	`int[]`	正在阻止指定的服务器进程ID获取锁的进程ID
`pg_conf_load_time()`	`timestamp with time zone`	配置载入时间
`pg_current_logfile([text])`	`text`	主日志文件名称，或者登录日志采集器当前正在使用的请求格式的日志
`pg_my_temp_schema()`	`oid`	会话的临时模式的 OID，如果没有则为 0
`pg_is_other_temp_schema(oid)`	`boolean`	模式是另一个会话的临时模式吗？
`pg_listening_channels()`	`setof text`	会话当前正在监听的频道名称
`pg_notification_queue_usage()`	`double`	异步通知队列当前被占用的分数（0-1）
`pg_postmaster_start_time()`	`timestamp with time zone`	服务器启动时间
`pg_safe_snapshot_blocking_pids(int)`	`int[]`	阻止指定的服务器进程ID获取安全快照的进程ID
`pg_trigger_depth()`	`int`	触发器的当前嵌套层次（如果没有调用则为 0，直接或间接，从一个触发器内部开始）
`session_user`	`name`	会话用户名
`user`	`name`	等价于`current_user`
`version()`	`text`	数据库版本信息。参阅server_version_num获取机器可读版本。

1. 1. 系统管理函数
    1. 配置设定函数

名称	返回类型	描述
current_setting(setting_name [, missing_ok ])	text	获得设置的当前值
set_config(setting_name, new_value, is_local)	text	设置一个参数并返回新值

1. 1. 1. 服务器信号函数

名称	返回类型	描述
pg_cancel_backend(pid int)	boolean	取消一个后端的当前查询。如果调用角色是其后端正在被取消的角色的成员，然而只有超级用户可以取消超级用户的后端。这也是允许的。
pg_reload_conf()	boolean	导致服务器进程重载它们的配置文件
pg_rotate_logfile()	boolean	切换服务器的日志文件
pg_terminate_backend(pid int)	boolean	中止一个后端。如果调用角色是其后端被终止的角色成员，然而只有超级用户可以终止超级用户的后端。这也是允许的。

1. 1. 1. 备份控制函数

名称	返回类型	描述
pg_create_restore_point(name text)	pg_lsn	为执行恢复创建一个命名点（只限于超级用户）
pg_current_wal_flush_lsn()	pg_lsn	得到当前的预写式日志刷写位置
pg_current_wal_insert_lsn()	pg_lsn	获得当前预写式日志插入位置
pg_current_wal_lsn()	pg_lsn	获得当前预写式日志写入位置
pg_start_backup(label text [, fast boolean [, exclusive boolean ]])	pg_lsn	准备执行在线备份（只限于超级用户或者复制角色）
pg_stop_backup()	pg_lsn	完成执行排他的在线备份（默认只限于超级用户或者复制角色，但是可以授予其他用户 EXECUTE 特权来执行该函数）
pg_stop_backup(exclusive boolean [, wait_for_archive boolean ])	setof record	结束执行排他或者非排他的在线备份（默认只限于超级用户，但是可以授予其他用户 EXECUTE 特权来执行该函数）
pg_is_in_backup()	bool	如果一个在线排他备份仍在进行中则为真。
pg_backup_start_time()	timestamp with time zone	获得一个进行中的在线排他备份的开始时间。
pg_switch_wal()	pg_lsn	强制切换到一个新的预写式日志文件（只限于超级用户）
pg_walfile_name(lsn pg_lsn)	text	转换预写式日志位置为文件名
pg_walfile_name_offset(lsn pg_lsn)	text, integer	转换预写式日志位置为文件名以及文件内的十进制字节偏移
pg_wal_lsn_diff(lsn pg_lsn, lsn pg_lsn)	numeric	计算两个预写式日志位置间的差别

1. 1. 1. 恢复控制函数

恢复信息函数：

名称	返回类型	描述
pg_is_in_recovery()	bool	如果恢复仍在进行中，为真。
pg_last_wal_receive_lsn()	pg_lsn	获得最后一个收到并由流复制同步到磁盘的预写日志位置。当流复制在进行中时，这将单调增加。如果恢复已经完成，这将保持静止在恢复过程中收到并同步到磁盘的最后一个 WAL 记录。如果流复制被禁用，或者还没有被启动，该函数返回 NULL。
pg_last_wal_replay_lsn()	pg_lsn	获得恢复过程中被重放的最后一个预写日志位置。当流复制在进行中时，这将单调增加。如果恢复已经完成，这将保持静止在恢复过程中被应用的最后一个 WAL 记录。如果服务器被正常启动而没有恢复，该函数返回 NULL。
pg_last_xact_replay_timestamp()	timestamp with time zone	获得恢复过程中被重放的最后一个事务的时间戳。这是在主机上产生的事务的提交或中止 WAL 记录的时间。如果在恢复过程中没有事务被重放，这个函数返回 NULL。否则，如果恢复仍在进行这将单调增加。如果恢复已经完成，则这个值会保持静止在恢复过程中最后一个被应用的事务。如果服务器被正常启动而没有恢复，该函数返回 NULL。

恢复控制函数：

名称	返回类型	描述
pg_is_wal_replay_paused()	bool	如果恢复被暂停，为真。
pg_wal_replay_pause()	void	立即暂停恢复（仅限于超级用户）。
pg_wal_replay_resume()	void	如果恢复被暂停，重启之（仅限于超级用户）。

这些函数只能在恢复过程中被执行。

1. 1. 1. 快照同步函数

名称	返回类型	描述
pg_export_snapshot()	text	保存当前快照并返回它的标识符

1. 1. 1. 复制函数（Replication Functions）

函数	返回类型	描述
`pg_create_physical_replication_slot(slot_name name [`, `immediately_reserve` `boolean`, `temporary` `boolean])`	(`slot_name` `name`, `lsn` `pg_lsn`)	创建一个名为`slot_name`的新物理复制槽。只有用流复制协议才能从一个物理槽流式传送变化 - 见第 52.4 节。可选的第三个参数`temporary`设置为true时，该参数指定该插槽不应永久存储到磁盘，仅供当前会话使用。临时插槽在发生任何错误时也会被释放。该函数对应于复制协议命令 `CREATE_REPLICATION_SLOT ... PHYSICAL`。
`pg_drop_replication_slot(slot_name name)`	`void`	丢弃名为`slot_name`的物理或逻辑复制槽。和复制协议命令`DROP_REPLICATION_SLOT`相同。对于逻辑插槽，必须在连接到创建插槽的同一数据库时调用。
`pg_create_logical_replication_slot(slot_name name, plugin name [`, `temporary` `boolean])`	(`slot_name` `name`, `lsn` `pg_lsn`)	使用输出插件`plugin`创建一个名为 `slot_name`的新逻辑（解码）复制槽。可选的第三个参数`temporary`设置为true时，该参数指定该插槽不应永久存储到磁盘，仅供当前会话使用。临时插槽在发生任何错误时也会被释放。对这个函数的调用与复制协议命令 `CREATE_REPLICATION_SLOT ... LOGICAL`具有相同的效果。
`pg_logical_slot_get_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges int, VARIADIC options text[])`	(`lsn` `pg_lsn`, `xid` `xid`, `data` `text`)	返回槽`slot_name`中的改变，从上一次已经被消费的点开始返回。如果`upto_lsn`和`upto_nchanges`为 NULL，逻辑解码将一直继续到 WAL 的末尾。如果`upto_lsn`为非 NULL，解码将只包括那些在指定 LSN 之前提交的事务。如果`upto_nchanges`为非 NULL，解码将在其产生的行数超过指定值后停止。不过要注意，被返回的实际行数可能更大，因为对这个限制的检查只会在增加了解码每个新的提交事务产生的行之后进行。
`pg_logical_slot_peek_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges int, VARIADIC options text[])`	(`lsn` `pg_lsn`, `xid` `xid`, `data` `text`)	行为就像`pg_logical_slot_get_changes()`函数，不过改变不会被消费，即在未来的调用中还会返回这些改变。
`pg_logical_slot_get_binary_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges int, VARIADIC options text[])`	(`lsn` `pg_lsn`, `xid` `xid`, `data` `bytea`)	行为就像`pg_logical_slot_get_changes()`函数，不过改变会以`bytea`返回。
`pg_logical_slot_peek_binary_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges int, VARIADIC options text[])`	(`lsn` `pg_lsn`, `xid` `xid`, `data` `bytea`)	行为就像`pg_logical_slot_get_changes()`函数，不过改变会以`bytea`返回并且这些改变不会被消费，即在未来的调用中还会返回这些改变。
`pg_replication_origin_create(node_name text)`	`oid`	创建具有给定外部名称的复制源，并返回分配给它的内部标识。
`pg_replication_origin_drop(node_name text)`	`void`	删除之前创建的复制源，包含任何相关的回放进程。
`pg_replication_origin_oid(node_name text)`	`oid`	通过名称查找复制源并返回内部标识。如果没有发现相应的复制源，则抛出一个错误。
`pg_replication_origin_session_setup(node_name text)`	`void`	标记当前会话从给定源开始回放，允许跟踪重播进度。如果没有配置之前的源，使用`pg_replication_origin_session_reset`恢复。
`pg_replication_origin_session_reset()`	`void`	取消`pg_replication_origin_session_setup()`的影响。
`pg_replication_origin_session_is_setup()`	`bool`	在当前会话中已经配置复制源吗？
`pg_replication_origin_session_progress(flush bool)`	`pg_lsn`	返回当前会话中配置的复制源的重播位置。参数`flush`决定是否相应的本地事务将被刷新到磁盘或者不刷新。
`pg_replication_origin_xact_setup(origin_lsn pg_lsn, origin_timestamp timestamptz)`	`void`	标记当前事务为回放给定LSN和时间戳点提交的事务。当使用`pg_replication_origin_session_setup()`配置复制源时，调用它。
`pg_replication_origin_xact_reset()`	`void`	取消`pg_replication_origin_xact_setup()`的影响。
`pg_replication_origin_advance(node_name text, lsn pg_lsn)`	`void`	为给定节点到给定位置设置复制进度。这主要是用于设置配置更改后的初始位置或新位置。要知道这个函数使用不当会导致不一致的复制数据。
`pg_replication_origin_progress(node_name text, flush bool)`	`pg_lsn`	返回给定复制源的重放位置。参数`flush`确定是否相应的本地事务将被保证刷新到磁盘或不刷新。
`pg_logical_emit_message(transactional bool, prefix text, content text)`	`pg_lsn`	发出文本形式的逻辑解码消息。这可以被用来通过 WAL 向逻辑解码插件传递一般消息。参数`transactional` 指定该消息是否应该是当前事务的一部分或者当逻辑解码读到该记录时该消息是否应该被立刻写入并且解码。`prefix` 是逻辑解码插件用来识别它们感兴趣的消息的文本前缀。 `content`是消息的文本。
`pg_logical_emit_message(transactional bool, prefix text, content bytea)`	`pg_lsn`	发出二进制逻辑解码消息。这可以被用来通过WAL向逻辑解码插件传递一般消息。参数`transactional` 指定该消息是否应该是当前事务的一部分或者当逻辑解码读到该记录时该消息是否应该被立刻写入并且解码。`prefix` 是逻辑解码插件用来识别它们感兴趣的消息的文本前缀。 `content`是消息的二进制文本。

1. 1. 1. 数据库对象管理函数

数据库对象尺寸函数：

名称	返回类型	描述
pg_column_size(any)	int	存储一个特定值（可能压缩过）所需的字节数
pg_database_size(oid)	bigint	指定 OID 的数据库使用的磁盘空间
pg_database_size(name)	bigint	指定名称的数据库使用的磁盘空间
pg_indexes_size(regclass)	bigint	附加到指定表的索引所占的总磁盘空间
pg_relation_size(relation regclass, fork text)	bigint	指定表或索引的指定分叉（'main'、'fsm'、'vm'或'init'）使用的磁盘空间
pg_relation_size(relation regclass)	bigint	pg_relation_size(..., 'main')的简写
pg_size_bytes(text)	bigint	把人类可读格式的带有单位的尺寸转换成字节数
pg_size_pretty(bigint)	text	将表示成一个 64位整数的字节尺寸转换为带尺寸单位的人类可读格式
pg_size_pretty(numeric)	text	将表示成一个数字值的字节尺寸转换为带尺寸单位的人类可读格式
pg_table_size(regclass)	bigint	被指定表使用的磁盘空间，排除索引（但包括 TOAST、空闲空间映射和可见性映射）
pg_tablespace_size(oid)	bigint	指定 OID 的表空间使用的磁盘空间
pg_tablespace_size(name)	bigint	指定名称的表空间使用的磁盘空间
pg_total_relation_size(regclass)	bigint	指定表所用的总磁盘空间，包括所有的索引和TOAST数据

数据库对象定位函数：

名称	返回类型	描述
pg_relation_filenode(relation regclass)	oid	指定关系的文件结点号
pg_relation_filepath(relation regclass)	text	指定关系的文件路径名
pg_filenode_relation(tablespace oid, filenode oid)	regclass	查找与给定的表空间和文件节点相关的关系

排序规则管理函数：

名称	返回类型	描述
pg_collation_actual_version(oid)	text	返回操作系统的排序规则的实际版本
pg_import_system_collations(schema regnamespace)	integer	导入操作系统排序规则

索引维护函数

名称	返回类型	描述
brin_summarize_new_values(index_oid regclass)	integer	总结尚未汇总的页面范围
brin_summarize_range(index regclass, blockNumber bigint)	integer	总结涵盖给定块的页面范围（如果尚未总结的话）
brin_desummarize_range(index regclass, blockNumber bigint)	integer	如果已经总结了，则反总结涵盖给定块的页面范围
gin_clean_pending_list(index regclass)	bigint	把 GIN 待处理列表项移动到主索引结构中

通用文件访问函数

名称	返回类型	描述
pg_ls_dir(dirname text [, missing_ok boolean, include_dot_dirs boolean])	setof text	列出目录内容。
pg_ls_logdir()	setof record	列出日志目录中文件的名称、大小和最后修改时间。访问权限授予pg_monitor角色的成员，并且可以授予其他非超级用户角色。
pg_ls_waldir()	setof record	列出WAL目录中文件的名称、大小和最后修改时间。访问权限授予pg_monitor角色的成员，并且可以授予其他非超级用户角色。
pg_read_file(filename text [, offset bigint, length bigint [, missing_ok boolean] ])	text	返回文本文件的内容。
pg_read_binary_file(filename text [, offset bigint, length bigint [, missing_ok boolean] ])	bytea	返回一个文件的内容。
pg_stat_file(filename text[, missing_ok boolean])	record	返回文件信息。

咨询锁函数

名称	返回类型	描述
pg_advisory_lock(key bigint)	void	获得排他会话级别咨询锁
pg_advisory_lock(key1 int, key2 int)	void	获得排他会话级别咨询锁
pg_advisory_lock_shared(key bigint)	void	获得共享会话级别咨询锁
pg_advisory_lock_shared(key1 int, key2 int)	void	获得共享会话级别咨询锁
pg_advisory_unlock(key bigint)	boolean	释放一个排他会话级别咨询锁
pg_advisory_unlock(key1 int, key2 int)	boolean	释放一个排他会话级别咨询锁
pg_advisory_unlock_all()	void	释放当前会话持有的所有会话级别咨询锁
pg_advisory_unlock_shared(key bigint)	boolean	释放一个共享会话级别咨询锁
pg_advisory_unlock_shared(key1 int, key2 int)	boolean	释放一个共享会话级别咨询锁
pg_advisory_xact_lock(key bigint)	void	获得排他事务级别咨询锁
pg_advisory_xact_lock(key1 int, key2 int)	void	获得排他事务级别咨询锁
pg_advisory_xact_lock_shared(key bigint)	void	获得共享事务级别咨询锁
pg_advisory_xact_lock_shared(key1 int, key2 int)	void	获得共享事务级别咨询锁
pg_try_advisory_lock(key bigint)	boolean	如果可能，获得排他会话级别咨询锁
pg_try_advisory_lock(key1 int, key2 int)	boolean	如果可能，获得排他会话级别咨询锁
pg_try_advisory_lock_shared(key bigint)	boolean	如果可能，获得共享会话级别咨询锁
pg_try_advisory_lock_shared(key1 int, key2 int)	boolean	如果可能，获得共享会话级别咨询锁
pg_try_advisory_xact_lock(key bigint)	boolean	如果可能，获得排他事务级别咨询锁
pg_try_advisory_xact_lock(key1 int, key2 int)	boolean	如果可能，获得排他事务级别咨询锁
pg_try_advisory_xact_lock_shared(key bigint)	boolean	如果可能，获得共享事务级别咨询锁
pg_try_advisory_xact_lock_shared(key1 int, key2 int)	boolean	如果可能，获得共享事务级别咨询锁

其他函数

连接池函数：

名称	返回类型	描述
pgxc_pool_check()	boolean	检查连接池中缓存的连接数据是否与pgxc_node一致
pgxc_pool_reload()	boolean	更新连接池中缓存的连接信息

管理新添加节点：

名称	返回类型	描述
pgxc_lock_for_backup()	boolean	为备份操作给集群加锁，这些备份是为在新增节点上做恢复

集群锁定备份时允许的语句：

EXECUTE
CREATE NODE
START TRANSACTION
BEGIN
COMMIT
ROLLBACK
PREPARE TRANSACTION
COMMIT PREPARED
ROLLBACK PREPARED
DECLARE CURSOR
CLOSE CURSOR
FETCH
TRUNCATE
COPY
PREPARE
DEALLOCATE
DO
NOTIFY
LISTEN
UNLISTEN
LOAD
CLUSTER
VACUUM
EXPLAIN
SET
SHOW
DISCARD
LOCK
SET CONSTRAINTS
CHECKPOINT
CREATE BARRIER
REINDEX
CLEAN CONNECTIO

gbase 8c

「喜欢这篇文章，您的关注和赞赏是给作者最好的鼓励」

关注作者

GBASE 8C——SQL参考 2 函数和操作符

评论