SQL 函数

特殊的语法形式

语法	相当于	描述
`AT TIME ZONE`	`timezone()`	时区
`CURRENT_CATALOG`	`current_catalog()`	现在使用的catalog
`COLLATION FOR`	`pg_collation_for()`	排序
`CURRENT_DATE`	`current_date()`	现在的日期(年,月,日)
`CURRENT_ROLE`	`current_user()`	现在的用户
`CURRENT_SCHEMA`	`current_schema()`	现在使用的schema
`CURRENT_TIMESTAMP`	`current_timestamp()`	现在的时间戳
`CURRENT_USER`	`current_user()`	现在的用户
`EXTRACT(<part> FROM <value>)`	`extract("<part>", <value>)`	从..中抽取部分内容
`OVERLAY(<text1> PLACING <text2> FROM <int1> FOR <int2>)`	`overlay(<text1>, <text2>, <int1>, <int2>)`	替换
`OVERLAY(<text1> PLACING <text2> FROM <int>)`	`overlay(<text1>, <text2>, <int>)`	替换
`SESSION_USER`	`current_user()`	session用户
`SUBSTRING(<text> FOR <int1> FROM <int2>))`	`substring(<text>, <int2>, <int1>)`	截取
`SUBSTRING(<text> FOR <int>)`	`substring(<text>, 1, <int>))`
`SUBSTRING(<text> FROM <int1> FOR <int2>)`	`substring(<text>, <int1>, <int2>)`
`SUBSTRING(<text> FROM <int>)`	`substring(<text>, <int>)`
`TRIM(<text1> FROM <text2>)`	`btrim(<text2>, <text1>)`	祛除字符或字符串。
`TRIM(<text2>, <text1>)`	`btrim(<text2>, <text1>)`
`TRIM(FROM <text>)`	`btrim(<text>)`
`TRIM(LEADING <text1> FROM <text2>)`	`ltrim(<text2>, <text1>)`
`TRIM(LEADING FROM <text> )`	`ltrim(<text>)`
`TRIM(TRAILING <text1> FROM <text2>)`	`rtrim(<text2>, <text1>)`
`TRIM(TRAILING FROM<text> )`	`rtrim(<text>)`
`USER`	`current_user()`	查询使用用户

条件运算符和类函数运算符

语法	描述
`ANNOTATE_TYPE(...)`	显式输入表达式
`ARRAY(...)`	子查询结果转换为数组
`ARRAY[...]`	将标量表达式转换为数组
`CAST(...)`	类型转换
`COALESCE(...)`	第一个非NULL短路表达式
`EXISTS(...)`	子查询结果的存在性检验
IF(...)	条件评估
`IFNULL(...)`	`COALESCE`限制为两个操作数的别名
`NULLIF(...)`	`NULL`有条件地返回
`ROW(...)`	元组构造函数

语法:

ANNOTATE_TYPE()

<expr>:::<type>
ANNOTATE_TYPE(<expr>, <type>)

计算给定的表达式，要求表达式具有给定的类型。如果表达式没有给定的类型，则返回错误。

类型注释对于指导数值的算术特别有用。

例如：

SELECT (1 / 0):::FLOAT;
pq: division by zero

句法：

ARRAY( ... subquery ... )

计算子查询并将其结果转换为数组。任何选择查询都可以用作子查询。

语法：

ARRAY[ <expr>, <expr>, ... ]

评估为包含指定值的数组。

例如：

SELECT ARRAY[1,2,3] AS a;
+---------+
|    a    |
+---------+
| {1,2,3} |
+---------+

语法：

<expr> :: <type>
CAST (<expr> AS <type>)

计算表达式并将结果值转换为指定的类型。如果转换无效，将报告错误。

例如：

CAST(now() AS DATE)

语法：

<expr> COLLATE <collation>

计算表达式并将其结果转换为具有指定归类的归类字符串。

例如：

'a' COLLATE de

语法：

EXISTS ( ... subquery ... )
NOT EXISTS ( ... subquery ... )

评估子查询，然后返回TRUE或FALSE取决于子查询是否返回任何行（用于EXISTS）或不返回任何行（用于NOT EXISTS）。任何选择查询都可以用作子查询。

语法：

NULLIF ( <expr1>, <expr2> )

相当于：IF ( <expr1> = <expr2>, NULL, <expr1> )

语法：

IFNULL ( <expr1>, <expr2> )
COALESCE ( <expr1> [, <expr2> [, <expr3> ] ...] )

COALESCE首先计算第一个表达式。如果其值不是 NULL，则直接返回其值。否则，它将返回COALESCE对其余表达式应用的结果。如果所有表达式均为NULL，NULL则返回。

不评估第一个非空参数右边的参数。

IFNULL(a, b)等同于COALESCE(a, b)

语法：

(<expr>, <expr>, ...)
ROW (<expr>, <expr>, ...)

评估为包含提供的表达式值的元组。

例如：

SELECT ('x', 123, 12.3) AS a;
+----------------+
|       a        |
+----------------+
| ('x',123,12.3) |
+----------------+

从值推断结果元组的数据类型。元组中的每个位置可以具有不同的数据类型。

数组函数

函数	说明	返回值类型
`array_append(array: bool[], elem: bool)`	将elem附加到数组中，返回结果。	bool[]
`array_append(array: bytes[], elem: bytes)`	将elem附加到数组中，返回结果。	bytes[]
`array_append(array: date[], elem: date)`	将elem附加到数组中，返回结果。	date[]
`array_append(array: decimal[], elem: decimal)`	将elem附加到数组中，返回结果。	decimal[]
`array_append(array: float[], elem: float)`	将elem附加到数组中，返回结果。	float[]
`array_append(array: inet[], elem: inet)`	将elem附加到数组中，返回结果。	inet[]
`array_append(array: int[], elem: int)`	将elem附加到数组中，返回结果。	int[]
`array_append(array: interval[], elem: interval)`	将elem附加到数组中，返回结果。	interval[]
`array_append(array: string[], elem: string)`	将elem附加到数组中，返回结果。	string[]
`array_append(array: time[], elem: time)`	将elem附加到数组中，返回结果。	time[]
`array_append(array: timestamp[], elem: timestamp)`	将elem附加到数组中，返回结果。	timestamp[]
`array_append(array: timestamptz[], elem: timestamptz)`	将elem附加到数组中，返回结果。	timestamptz[]
`array_append(array: uuid[], elem: uuid)`	将elem附加到数组中，返回结果。	uuid[]
`array_append(array: varbit[], elem: varbit)`	将elem附加到数组中，返回结果。	varbit[]
`array_cat(left: bool[], right: bool[])`	追加两个数组。	bool[]
`array_cat(left: bytes[], right: bytes[])`	追加两个数组。	bytes[]
`array_cat(left: date[], right: date[])`	追加两个数组。	date[]
`array_cat(left: decimal[], right: decimal[])`	追加两个数组。	decimal[]
`array_cat(left: float[], right: float[])`	追加两个数组。	float[]
`array_cat(left: inet[], right: inet[])`	追加两个数组。	inet[]
`array_cat(left: int[], right: int[])`	追加两个数组。	int[]
`array_cat(left: interval[], right: interval[])`	追加两个数组。	interval[]
`array_cat(left: string[], right: string[])`	追加两个数组。	string[]
`array_cat(left: time[], right: time[])`	追加两个数组。	time[]
`array_cat(left: timestamp[], right: timestamp[])`	追加两个数组。	timestamp[]
`array_cat(left: timestamptz[], right: timestamptz[])`	追加两个数组。	timestamptz[]
`array_cat(left: uuid[], right: uuid[])`	追加两个数组。	uuid[]
`array_cat(left: varbit[], right: varbit[])`	追加两个数组。	varbit[]
`array_length(input: anyelement[], array_dimension: int)`	计算`input`提供的上的长度`array_dimension`。但是，由于目前尚不支持多维数组，因此唯一支持的`array_dimension`是1。	int
`array_lower(input: anyelement[], array_dimension: int)`	计算`input`提供的上的最小值`array_dimension`。但是，由于目前尚不支持多维数组，因此唯一支持的`array_dimension`是1。	int
`array_position(array: bool[], elem: bool)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: bytes[], elem: bytes)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: date[], elem: date)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: decimal[], elem: decimal)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: float[], elem: float)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: inet[], elem: inet)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: int[], elem: int)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: interval[], elem: interval)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: string[], elem: string)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: time[], elem: time)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: timestamp[], elem: timestamp)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: timestamptz[], elem: timestamptz)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: uuid[], elem: uuid)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: oid[], elem: oid)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: varbit[], elem: varbit)`	返回数组中`elem` 第一次出现的索引。	int
`array_positions(array: bool[], elem: bool)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: bytes[], elem: bytes)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: date[], elem: date)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: decimal[], elem: decimal)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: float[], elem: float)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: inet[], elem: inet)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: int[], elem: int)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: interval[], elem: interval)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: string[], elem: string)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: time[], elem: time)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: timestamp[], elem: timestamp)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: timestamptz[], elem: timestamptz)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: uuid[], elem: uuid)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: oid[], elem: oid)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: varbit[], elem: varbit)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_prepend(elem: bool, array: bool[])`	将`elem` 加入数组，返回结果。	bool[]
`array_prepend(elem: bytes, array: bytes[])`	将`elem` 加入数组，返回结果。	bytes[]
`array_prepend(elem: date, array: date[])`	将`elem` 加入数组，返回结果。	date[]
`array_prepend(elem: decimal, array: decimal[])`	将`elem` 加入数组，返回结果。	decimal[]
`array_prepend(elem: float, array: float[])`	将`elem` 加入数组，返回结果。	float[]
`array_prepend(elem: inet, array: inet[])`	将`elem` 加入数组，返回结果。	inet[]
`array_prepend(elem: int, array: int[])`	将`elem` 加入数组，返回结果。	int[]
`array_prepend(elem: interval, array: interval[])`	将`elem` 加入数组，返回结果。	interval[]
`array_prepend(elem: string, array: string[])`	将`elem` 加入数组，返回结果。	string[]
`array_prepend(elem: time, array: time[])`	将`elem` 加入数组，返回结果。	time[]
`array_prepend(elem: timestamp, array: timestamp[])`	将`elem` 加入数组，返回结果。	timestamp[]
`array_prepend(elem: timestamptz, array: timestamptz[])`	将`elem` 加入数组，返回结果。	timestamptz[]
`array_prepend(elem: uuid, array: uuid[])`	将`elem` 加入数组，返回结果。	uuid[]
`array_prepend(elem: varbit, array: varbit[])`	将`elem` 加入数组，返回结果。	varbit[]
`array_remove(array: bool[], elem: bool)`	从数组中删除所有等于`elem`的元素。	bool[]
`array_remove(array: bytes[], elem: bytes)`	从数组中删除所有等于`elem`的元素。	bytes[]
`array_remove(array: date[], elem: date)`	从数组中删除所有等于`elem`的元素。	date[]
`array_remove(array: decimal[], elem: decimal)`	从数组中删除所有等于`elem`的元素。	decimal[]
`array_remove(array: float[], elem: float)`	从数组中删除所有等于`elem`的元素。	float[]
`array_remove(array: inet[], elem: inet)`	从数组中删除所有等于`elem`的元素。	inet[]
`array_remove(array: int[], elem: int) → int[]`	从数组中删除所有等于`elem`的元素。	int[]
`array_remove(array: interval[], elem: interval)`	从数组中删除所有等于`elem`的元素。	interval[]
`array_remove(array: string[], elem: string)`	从数组中删除所有等于`elem`的元素。	string[]
`array_remove(array: time[], elem: time)`	从数组中删除所有等于`elem`的元素。	time[]
`array_remove(array: timestamp[], elem: timestamp)`	从数组中删除所有等于`elem`的元素。	timestamp[]
`array_remove(array: timestamptz[], elem: timestamptz)`	从数组中删除所有等于`elem`的元素。	timestamptz[]
`array_remove(array: uuid[], elem: uuid)`	从数组中删除所有等于`elem`的元素。	uuid[]
`array_remove(array: varbit[], elem: varbit)`	从数组中删除所有等于`elem`的元素。	varbit[]
`array_replace(array: bool[], toreplace: bool, replacewith: bool)`	用replacewith替换数组中出现的所有toreplace。	bool[]
`array_replace(array: bytes[], toreplace: bytes, replacewith: bytes)`	用replacewith替换数组中出现的所有toreplace。	bytes[]
`array_replace(array: date[], toreplace: date, replacewith: date)`	用replacewith替换数组中出现的所有toreplace。	date[]
`array_replace(array: decimal[], toreplace: decimal, replacewith: decimal)`	用replacewith替换数组中出现的所有toreplace。	decimal[]
`array_replace(array: float[], toreplace: float, replacewith: float)`	用replacewith替换数组中出现的所有toreplace。	float[]
`array_replace(array: inet[], toreplace: inet, replacewith: inet)`	用replacewith替换数组中出现的所有toreplace。	inet[]
`array_replace(array: int[], toreplace: int, replacewith: int)`	用replacewith替换数组中出现的所有toreplace。	int[]
`array_replace(array: interval[], toreplace: interval, replacewith: interval)`	用replacewith替换数组中出现的所有toreplace。	interval[]
`array_replace(array: string[], toreplace: string, replacewith: string)`	用replacewith替换数组中出现的所有toreplace。	string[]
`array_replace(array: time[], toreplace: time, replacewith: time)`	用replacewith替换数组中出现的所有toreplace。	time[]
`array_replace(array: timestamp[], toreplace: timestamp, replacewith: timestamp)`	用replacewith替换数组中出现的所有toreplace。	timestamp[]
`array_replace(array: timestamptz[], toreplace: timestamptz, replacewith: timestamptz)`	用replacewith替换数组中出现的所有toreplace。	timestamptz[]
`array_replace(array: uuid[], toreplace: uuid, replacewith: uuid)`	用replacewith替换数组中出现的所有toreplace。	uuid[]
`array_replace(array: varbit[], toreplace: varbit, replacewith: varbit)`	用replacewith替换数组中出现的所有toreplace。	varbit[]
`array_to_string(input: anyelement[], delim: string)`	用定界符将数组连接到字符串中。	string`
`array_to_string(input: anyelement[], delimiter: string, null: string)`	用分隔符将数组连接到字符串中，用空字符串替换NULL。	string
`array_upper(input: anyelement[], array_dimension: int)`	计算`input`提供的上的最大值`array_dimension`。但是，由于目前尚不支持多维数组，因此唯一支持的`array_dimension`是1。	int
`string_to_array(str: string, delimiter: string)`	将字符串拆分为分隔符上的组件。	string[]
`string_to_array(str: string, delimiter: string, null: string)`	使用指定的字符串将字符串拆分为定界符上的组件，以将其视为NULL。	string[]

案例:

数据示例

CREATE TABLE test_array (a STRING[]);
INSERT INTO test_array VALUES (ARRAY['Monday', 'Tuesday', 'Wednesday']);
select * from test_array;
              a               
+----------------------------+
  {Monday,Tuesday,Wednesday}

append(array: x[], elem: y) → bool[]

数组拼接单个元素

select array_append(a,'Thursday') from test_array;
             array_append              
+-------------------------------------+

  {Monday,Tuesday,Wednesday,Thursday}

array_cat(array: x[], array y[])

两个数组拼接

select array_cat(a,ARRAY['Thursday', 'Friday', 'Saturday']) from test_array;

                       array_cat                       
+-----------------------------------------------------+
  {Monday,Tuesday,Wednesday,Thursday,Friday,Saturday}

array_length(array:x[],1)

数组大小，第二个参数暂时只支持1个间隔计算。

select array_length(a,1) from test_array;

  array_length  
+--------------+
             3

array_lower(array:x[],1)

返回指定的数组维数的下界，第二个参数暂时只支持1个间隔计算。

select array_lower(a,1) from test_array;

  array_lower  
+-------------+
            1

array_upper(array:x[],1)

返回指定数组维数的上界，第二个参数暂时只支持1个间隔计算。

select array_upper(a,1) from test_array;

  array_upper  
+-------------+
            3

array_position(array:x[],y)

返回元素的位置

select array_position(a,'Tuesday') from test_array;

  array_position  
+----------------+
               2

array_prepend(y,array:x[])

数组之前插入元素

select array_prepend('Thursday',a) from test_array;

             array_prepend             
+-------------------------------------+
  {Thursday,Monday,Tuesday,Wednesday}

array_remove(array:x[],y)

数组中删除元素

select array_remove(a,'Tuesday') from test_array;

     array_remove     
+--------------------+
  {Monday,Wednesday}

array_replace(array:x[],y,z)

替换数组中的元素y为z

select array_replace(a,'Tuesday','Thursday') from test_array;

         array_replace         
+-----------------------------+
  {Monday,Thursday,Wednesday}

array_to_string(array:x[],delim)

数组转字符串，按delim分隔

select array_to_string(a,',') from test_array;

      array_to_string       
+--------------------------+
  Monday,Tuesday,Wednesday

array_to_string(array:x[],delim,y)

数组转字符串，按delim分隔，y代替null,即保留null在字符串中的位置。

select array_to_string(ARRAY['Thursday', 'Friday', 'Saturday',null,'Friday'],',');

          array_to_string          
+---------------------------------+
  Thursday,Friday,Saturday,Friday


select array_to_string(ARRAY['Thursday', 'Friday', 'Saturday',null,'Friday'],',','y');

          array_to_string           
+----------------------------------+
  Thursday,Friday,Saturday,y,Friday

string_to_array(str:string,delim)

字符串转数组，按分隔符拆分

select string_to_array('Thursday,Friday,Saturday,Friday',',');

           string_to_array           
+-----------------------------------+
  {Thursday,Friday,Saturday,Friday}

string_to_array(str:string,delim,y)

字符串转数组，按分隔符拆分，将y视为null

select string_to_array('Thursday,Friday,Saturday,y,Friday',',','y');

             string_to_array              
+----------------------------------------+
  {Thursday,Friday,Saturday,NULL,Friday}

比较函数

函数	说明	返回值类型
`greatest(anyelement...)`	返回具有最大值的元素。	anyelement
`least(anyelement...)`	返回具有最小值的元素。	anyelement
`ltrim('m','n')`	返回具有最左边的元素。	string

案例:

greatest(anyelement...)

取元素中的最大值

select greatest(1,4,6,9,12,5,7);

  greatest  
+----------+
        12

least(anyelement...)

取元素中的最小值

select least(8,1,4,6,9,12,5,7);

  least  
+-------+
      1

取值取左边的字符串

select ltrim('m','n');
  ltrim  
+-------+
  m

时间函数

函数	说明	返回值类型
`age(end: timestamptz, begin: timestamptz)`	计算`begin`和`end`之间的时间间隔。	interval
`age(val: timestamptz)`	计算`val`与当前时间之间的间隔。	interval
`clock_timestamp()`	返回一个集群节点上的当前系统时间。	timestamp
`current_date()`	返回当前事务的日期。该值基于事务开始时选择的时间戳记，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序没有关系。	date
`current_timestamp()`	返回当前事务的时间。该值基于事务开始时选择的时间戳记，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序没有关系。	date
`current_timestamp()`	返回当前事务的时间。该值基于事务开始时选择的时间戳记，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序没有关系。	timestamp
`date_trunc(element: string, input: time) → interval`	`input`精确到截断`element`。将所有不重要的字段设置`element`为零。兼容元素：时，分，秒，毫秒，微秒。	interval
`date_trunc(element: string, input: timestamp) → timestamp`	`input`精确到截断`element`。将所有不重要的字段设置`element`为零（对于日和月，则为一）兼容的元素：年，季，月，周，小时，分钟，秒，毫秒，微秒。	timestamp
`date_trunc(element: string, input: timestamptz)`	`input`精确到截断`element`。将所有不重要的字段设置`element`为零（对于日和月，则为一）兼容的元素：年，季，月，周，小时，分钟，秒，毫秒，微秒。	timestamptz
`experimental_follower_read_timestamp()`	返回一个时间戳，很可能可以安全地针对跟随者副本执行。此功能旨在与AS OF SYSTEM TIME子句一起使用，以对最近的时间执行历史读取，但时间要足够长，以便针对给定范围内的当前租户（相对于最近的租户）执行读取操作。请注意，此功能需要CCL发行版上的企业许可证才能无错误地返回。	timestamptz
`to_char(input: date, extract_format: string)`	从中`input`提取和格式化`extract_format`使用标准`strftime`符号标识的时间（尽管并非所有格式都受支持）。	string
`to_char(input: timestamp, extract_format: string)`	从中`input`提取和格式化`extract_format`使用标准`strftime`符号标识的时间（尽管并非所有格式都受支持）。	string
`to_char(input: timestamptz, extract_format: string)`	从中`input`提取和格式化`extract_format`使用标准`strftime`符号标识的时间（尽管并非所有格式都受支持）。	string
`to_date(input: string, format: string)`	`input`使用`format`（使用标准`strptime`格式）作为时间戳返回。	timestamp
`to_datetz(input: string, format: string)`	`input`使用`format`（使用标准`strptime`格式）作为时间戳返回。	timestamptz
`extract(element: string, input: date)`	`element`从中提取`input`。兼容的元素：年，季度，月，周，星期几，年日，小时，分钟，秒，毫秒，微秒	int
`extract(element: string, input: time)`	`element`从中提取`input`。兼容的元素：小时，分钟，秒，毫秒，微秒	int
`extract(element: string, input: timestamp)`	`element`从中提取`input`。兼容的元素：年，季度，月，周，星期几，年日，小时，分钟，秒，毫秒，微秒	int
`extract(element: string, input: timestamptz)`	`element`从中提取`input`。兼容的元素：年，季度，月，周，星期几，年日，小时，分钟，秒，毫秒，微秒	int
`now()`	返回当前交易的时间。该值基于事务开始时选择的时间戳记，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序没有关系。	date
`now()`	返回当前交易的时间。该值基于事务开始时选择的时间戳记，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序没有关系。	timestamp
`statement_timestamp()`	返回当前语句的开始时间。	timestamp
`timezone(timestamp: timestamp, timezone: string)`	将不带时区的给定时间戳视为位于指定时区中	timestamp
`transaction_timestamp()`	返回当前交易的时间。该值基于事务开始时选择的时间戳记，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序没有关系。	date
`transaction_timestamp()`	返回当前交易的时间。该值基于事务开始时选择的时间戳记，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序没有关系。	timestamp
`cast()`	返回当前交易的时间。将时间转换成字符串类型并截取出来。	string

案例:

age(end: timestamptz, begin: timestamptz)

计算end和begin之间的时间间隔

select age(TIMESTAMPTZ '2019-03-26 14:22:10+08:00',TIMESTAMPTZ '2019-03-26 10:10:10-05:00');

     age     
+-----------+
  -08:48:00

age(val: timestamptz)

与当前时间的间隔

select age(TIMESTAMPTZ '2019-03-26 14:22:10+08:00');

         age         
+-------------------+
  6531:32:02.512077

current_date()

当前日期

current_timestamp()

当前时间

date_trunc(x,input:date)

截断时间，后边清零，x(year, quarter, month, week, hour, minute, second, millisecond, microsecond)

select date_trunc('month',TIMESTAMPTZ '2019-03-26 14:22:10+08:00');

         date_trunc          
+---------------------------+
  2019-03-01 00:00:00+08:00  
(1 row)

extract(x,input:date)

input中提取x(year, quarter, month, week, hour, minute, second, millisecond, microsecond)

select extract('month',TIMESTAMPTZ '2019-03-26 14:22:10+08:00');

  extract  
+---------+
        3

timestamp类型怎么能转成字符串并截串

select cast('20220107' as string);
    text    
+----------+
  20210107

ID函数

函数	说明	返回值类型
`gen_random_uuid()`	生成随机UUID并将其作为UUID类型的值返回。	uuid
`unique_rowid()`	如果未为表定义主键，则返回用于生成唯一行ID的唯一ID。该值是插入时间戳记与执行该语句的节点的ID的组合，从而确保此组合在全局上是唯一的。但是，可能存在差距，不能完全保证顺序。	int

gen_random_uuid()

生成随机uuid

 select gen_random_uuid();
            gen_random_uuid             
+--------------------------------------+
  9c5b836c-486b-46ed-acb3-701c093f59fa  

(1 row)

unique_rowid()

 select unique_rowid();
     unique_rowid     
+--------------------+
  514553266254184454  
(1 row)

生成唯一键，保证全局唯一，可用作主键。但由于集群性质，不能完全保证排序。

数学类函数

函数	返回类型	参数类型	说明
abs	float	float	计算绝对值
abs	decimal	decimal	计算绝对值
abs	int	int	计算绝对值
acos	float	float	计算反余弦
asin	float	float	计算反正弦
atan	float	float	计算反正切
atan2	float	float，float	计算入参的相除的反正切
cbrt	decimal	decimal	计算立方根
cbrt	float	float	计算立方根
ceil	decimal	decimal	计算最小整数
ceil	float	float	计算最小整数
cos	float	float	计算余弦值
cot	float	float	计算余切
crc32c	int	bytes	compute CRC(Castagnoli polynomial.)
crc32c	int	string	compute CRC(Castagnoli polynomial.)
crc32ieee	int	bytes	compute CRC(IEEE polynomial)
crc32ieee	int	string	compute CRC(IEEE polynomial)
degrees	float	float	将弧度值转换为度值
div	decimal	decimal，decimal	计算x/y的整数商
div	float	float，float	计算x/y的整数商
div	int	int，int	计算x/y的整数商
exp	float	float	e的幂次方
floor	decimal	decimal	计算不大于入参的最大整数
floor	float	float	计算不大于入参的最大整数
fnv32	int	bytes	计算32位的 FNV-1 hash值
fnv32	int	string	计算32位的 FNV-1 hash值
fnv32a	int	bytes	计算32位的 FNV-1a hash值
fnv32a	int	string	计算32位的 FNV-1a hash值
fnv64	int	bytes	计算64位的 FNV-1 hash值
fnv64	int	string	计算64位的 FNV-1 hash值
fnv64a	int	bytes	计算64位的 FNV-1a hash值
fnv64a	int	string	计算64位的 FNV-1a hash值
isnan	bool	decimal	判断是否为NaN
isnan	bool	float	判断是否为NaN
ln	decimal	decimal	计算自然对数
ln	float	float	计算自然对数
log	decimal	decimal	计算以10为底的对数
log	float	float	计算以10为底的对数
mod	decimal	decimal，decimal	计算余数
mod	float	float，float	计算余数
mod	int	int，int	计算余数
pi	float		3.141592653589793
pow	decimal	decimal，decimal	`x`^`y`
pow	float	float，float	`x`^`y`
pow	int	int,int	`x`^`y`
radians	float	float	度值转换为弧度值
random()	float	float	0与1之间的随机数
round	decimal	decimal,int	四舍五入到给定的小数位数
round	float	float,int	四舍五入到给定的小数位数
round	decimal	decimal	四舍五入取整数
round	float	float	四舍五入取整数
sign	decimal	decimal	符号函数
sign	float	float	符号函数
sign	int	int	符号函数
sin	float	float	计算正弦
sqrt	decimal	decimal	计算平方根
sqrt	float	float	计算平方根
tan	float	float	计算正切
trunc	decimal	decimal	截断小数
trunc	float	float	截断小数

字符串函数

函数	返回类型	参数	说明
ascii	int	string	返回第一个字符的asc编码
bit_length	int	bytes	计算bits数
bit_length	int	string	计算bits数
btrim	string	string,string	删除匹配的字符
btrim	string	string	去除空格
char_length	int	bytes	计算字节长度
char_length	int	string	计算字符长度
chr	string	int	返回ascii值
concat	string	string...	拼接字符串
concat_ws	string	string...	使用第一个参数拼接字符串
convert_from	string	bytes，string	将字节转化为执行编码的字符串（支持UTF8与LATIN1）
convert_to	bytes	string，string	将字符串转化为指定编码的字节（支持UTF8与LATIN1）
decode	bytes	string，string	换化为字节码，支持hex，escape，base64
encode	string	bytes，string	换化为字符串，支持hex，escape，base64
from_ip	string	bytes	将IP的字节字符串表示形式转换为其字符串表示形式
from_uuid	string	bytes	将UUID的字节字符串表示形式转换为其字符串表示形式。
initcap	string	string	第一个字母大写。
left	bytes	bytes，int	获取头几位字节
left	string	string，int	获取头几位字符串
length	int	bytes	计算字节码的长度
length	int	string	计算字符串的长度
lower	string	string	将大写转化为小写
lpad	string	string，int	通过在字符串的左侧添加' '来增加长度。如果字符串比长度长，就被截断。
lpad	string	string，int ，string	通过在字符串的左侧添加传入参数来增加长度。如果字符串比长度长，就被截断。
ltrim	string	string，string	递归从输入的开始(左侧)删除包含的所有字符
ltrim	string	string	去除左边的空格
md5	string	bytes	计算MD5值
md5	string	string	计算MD5值
octet_length	int	bytes	计算字节数
octet_length	int	string	计算字节数
overlay	string	string，string，int	从指定下标开始替换字符
overlay	string	string，string，int，int	从指定下标开始替换字符
quote_ident	string	string	返回val作为SQL语句中的标识符。
quote_literal	string	string	返回val作为SQL语句中的字符串文字适当引用。
quote_nullable	string	string	将参数强制转换为字符串，然后将其作为文字引用。如果v参数为空，则返回“NULL”。
regexp_extract	string	string，string	返回输入中正则表达式的第一个匹配项。
regexp_replace	string	string，string，string	将输入中的正则表达式regex的匹配项替换为正则表达式替换。
repeat	string	string，int	返回输入指定重复次数的参数
replace	string	string，string，string	用replace替换输入的第三个参数替换匹配的第二个参数
reverse	string	string	反转字符串字符的顺序。
right	bytes	bytes，int	获取从右开始头几位字节
right	string	string，int	获取从右开始头几位字符
rpad	string	string，int	通过在字符串的右侧添加' '来增加长度。如果字符串比长度长，就被截断。
rpad	string	string，int，string	通过在字符串的右侧添加传入参数来增加长度。如果字符串比长度长，就被截断。
rtrim	string	string，string	递归从输入的开始(右侧)删除包含的所有字符
rtrim	string	string	去除右边的空格
sha1	string	bytes	计算SHA1值
sha1	string	string	计算SHA1值
sha256	string	bytes	计算SHA256值
sha256	string	string	计算SHA256值
sha512	string	bytes	计算SHA512值
sha512	string	string	计算SHA512值
split_part	string	string，string，int	分割分隔符上的输入并返回第几位
strpos	int	string，string	计算输入中字符串开始的位置。
substr	string	string，string	返回与正则表达式regex匹配的输入子字符串。
substr	string	string，string，string	返回与正则表达式regex匹配的输入子字符串，使用第三个参数作为转义字符
substr	string	string，int	从指定下标开始截取字符串
substr	string	string，int，int	从指定下标开始截取字符串，并指定截取字符串长度
to_english	string	int	此函数使用英语基数来声明其参数的值。
to_hex	string	bytes	将val转换为其十六进制表示形式。
to_hex	bytes	string	将val转换为其十六进制表示形式。
to_uuid	bytes	string	将UUID的字符串表示形式转换为其字节字符串表示形式。
translate	string	string，string，string	指定替代字符串内容
upper	string	string	将字符内容转为大写

聚合函数

函数	说明	返回值类型
`cume_dist()`	计算当前行的相对排名：（当前行之前或与之对等的行数）/（总行数）。	float
`dense_rank()`	计算当前行的排名，不留空格；此功能计算对等组。	int
`first_value(val: bool)`	返回`val`在窗口框第一行的那一行求值。	bool
`first_value(val: bytes)`	返回`val`在窗口框第一行的那一行求值。	bytes
`first_value(val: date)`	返回`val`在窗口框第一行的那一行求值。	date
`first_value(val:decimal)`	返回`val`在窗口框第一行的那一行求值。	decimal
`first_value(val: float)`	返回`val`在窗口框第一行的那一行求值。	float
`first_value(val: int)`	返回`val`在窗口框第一行的那一行求值。	int
`first_value(val: string)`	返回`val`在窗口框第一行的那一行求值。	string
`first_value(val: time)`	返回`val`在窗口框第一行的那一行求值。	time
`first_value(val: timestamp)`	返回`val`在窗口框第一行的那一行求值。	timestamp
`first_value(val: uuid)`	返回`val`在窗口框第一行的那一行求值。	uuid
`first_value(val: jsonb)`	返回`val`在窗口框第一行的那一行求值。	jsonb
`lag(val: bool)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	bool
`lag(val: bool, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	bool
`lag(val: bool, n: int, default: bool)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	bool
`lag(val: date, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	date
`lag(val: date, n: int, default: date)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	date
`lag(val: decimal)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	decimal
`lag(val: decimal, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	decimal
`lag(val: decimal, n: int, default: decimal)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	decimal
`lag(val: float)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	float
`lag(val: float, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	float
`lag(val: float, n: int, default: float)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	float
`lag(val: inet)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	inet
`lag(val: inet, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	inet
`lag(val: inet, n: int, default: inet)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	inet
`lag(val: int)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	int
`lag(val: int, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	int
`lag(val: int, n: int, default: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	int
`lag(val: interval)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	interval
`lag(val: interval, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	interval
`lag(val: interval, n: int, default: interval)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	interval
`lag(val: string)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	string
`lag(val: string, n: int) → string`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	string
`lag(val: string, n: int, default: string)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	string
`lag(val: time)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	time
`lag(val: time, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	time
`lag(val: time, n: int, default: time)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	time
`lag(val: timestamp)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	timestamp
`lag(val: timestamp, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	timestamp
`lag(val: timestamp, n: int, default: timestamp)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	timestamp
`lag(val: timestamptz)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	timestamptz
`lag(val: timestamptz, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	timestamptz
`lag(val: timestamptz, n: int, default: timestamptz)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	timestamptz
`lag(val: uuid)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	uuid
`lag(val: uuid, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	uuid
`lag(val: uuid, n: int, default: uuid)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	uuid
`lag(val: jsonb)`	返回`val`在当前行分区内的前一行求值的结果；如果没有这样的行，则返回null。	jsonb
`lag(val: jsonb, n: int)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	jsonb
`lag(val: jsonb, n: int, default: jsonb)`	返回在其分区中当前行之前的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	jsonb
`last_value(val: bool)`	返回`val`在窗框的最后一行的那一行求值。	bool
`last_value(val: bytes)`	返回`val`在窗框的最后一行的那一行求值。	bytes
`last_value(val: date)`	返回`val`在窗框的最后一行的那一行求值。	date
`last_value(val: decimal)`	返回`val`在窗框的最后一行的那一行求值。	decimal
`last_value(val: float)`	返回`val`在窗框的最后一行的那一行求值。	float
`last_value(val: inet)`	返回`val`在窗框的最后一行的那一行求值。	inet
`last_value(val: int)`	返回`val`在窗框的最后一行的那一行求值。	int
`last_value(val: interval)`	返回`val`在窗框的最后一行的那一行求值。	interval
`last_value(val: string)`	返回`val`在窗框的最后一行的那一行求值。	string
`last_value(val: time)`	返回`val`在窗框的最后一行的那一行求值。	time
`last_value(val: timestamp)`	返回`val`在窗框的最后一行的那一行求值。	timestamp
`last_value(val: timestamptz)`	返回`val`在窗框的最后一行的那一行求值。	timestamptz
`last_value(val: uuid)`	返回`val`在窗框的最后一行的那一行求值。	uuid
`last_value(val: jsonb)`	返回`val`在窗框的最后一行的那一行求值。	jsonb
`lead(val: bool)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	bool
`lead(val: bool, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	bool
`lead(val: bool, n: int, default: bool)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	bool
`lead(val: bytes)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	bytes
`lead(val: bytes, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	bytes
`lead(val: bytes, n: int, default: bytes)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	bytes
`lead(val: date)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	date
`lead(val: date, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	date
`lead(val: date, n: int, default: date)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	date
`lead(val: decimal)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	decimal
`lead(val: decimal, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	decimal
`lead(val: decimal, n: int, default: decimal)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	decimal
`lead(val: float)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	float
`lead(val: float, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	float
`lead(val: float, n: int, default: float)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	float
`lead(val: inet)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	inet
`lead(val: inet, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	int
`lead(val: inet, n: int, default: inet)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	inet
`lead(val: int)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	int
`lead(val: int, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	int
`lead(val: int, n: int, default: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	int
`lead(val: interval)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	interval
`lead(val: interval, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	interval
`lead(val: interval, n: int, default: interval)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	interval
`lead(val: string)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	string
`lead(val: string, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	string
`lead(val: string, n: int, default: string)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	string
`lead(val: time)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	time
`lead(val: time, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	time
`lead(val: time, n: int, default: time)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	time
`lead(val: timestamp)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	timestamp
`lead(val: timestamp, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	timestamp
`lead(val: timestamp, n: int, default: timestamp)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	timestamp
`lead(val: timestamptz) → timestamptz`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	timestamptz
`lead(val: timestamptz, n: int) → timestamptz`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	timestamptz
`lead(val: timestamptz, n: int, default: timestamptz)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	timestamptz
`lead(val: uuid)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	uuid
`lead(val: uuid, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	uuid
`lead(val: uuid, n: int, default: uuid)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	uuid
`lead(val: jsonb)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	jsonb
`lead(val: jsonb, n: int)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	jsonb
`lead(val: jsonb, n: int, default: jsonb)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	jsonb
`lead(val: varbit)`	返回`val`当前行分区中下一行的求值；如果没有这样的行，则返回null。	varbit
`lead(val: varbit, n: int) → varbit`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有这样的行，则返回null。`n`针对当前行进行评估。	varbit
`lead(val: varbit, n: int, default: varbit)`	返回在其分区中当前行之后的行`val`处求值`n`；如果没有，则返回行`default`（必须与类型相同`val`）。双方`n`并`default`相对于当前行评估。	varbit
`nth_value(val: bool, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	bool
`nth_value(val: bytes, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	bytes
`nth_value(val: date, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	date
`nth_value(val: decimal, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	decimal
`nth_value(val: float, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	float
`nth_value(val: inet, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	inet
`nth_value(val: int, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	int
`nth_value(val: interval, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	interval
`nth_value(val: string, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	string
`nth_value(val: time, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	time
`nth_value(val: timestamp, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	timestamp
`nth_value(val: timestamptz, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	timestamptz
`nth_value(val: uuid, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	uuid
`nth_value(val: jsonb, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	jsonb
`nth_value(val: varbit, n: int)`	返回`val`在`n`窗框第th行（从1开始）处求值的值；如果没有这样的行，则返回null。	varbit
`ntile(n: int)`	计算范围为1到的整数`n`，将分区尽可能平均地划分。	int
`percent_rank()`	计算当前行的相对等级：（等级-1）/（总行-1）。	float
`rank()`	计算带有间隙的当前行的排名；与第一个对等方的row_number相同。	int
`row_number()`	计算分区中当前行的数量，从1开始计算。	int

JSON函数

函数	说明	返回值类型
`array_to_json(array: anyelement[])`	将数组返回为JSON或JSONB。	json
`json_array_length(json: jsonb) → int`	返回最外面的JSON或JSONB数组中的元素数。	int
`json_build_array(anyelement...)`	从可变参数列表中构建一个可能是异构类型的JSON或JSONB数组。	json
`json_build_object(anyelement...)`	从可变参数列表中构建JSON对象。	json
`json_extract_path(jsonb, string...)`	返回可变参数所指向的JSON值。	json
`json_object(keys: string[], values: string[])`	这种形式的json_object从两个单独的数组中成对地获取键和值。在所有其他方面，它与单参数形式相同。	json
`json_object(texts: string[])`	从文本数组构建JSON或JSONB对象。数组必须具有一维且成员数为偶数，在这种情况下，它们被视为交替的键/值对。	json
`json_remove_path(val: jsonb, path: string[])`	从JSON对象中删除指定的路径。	json
`json_set(val: jsonb, path: string[], to: jsonb)`	返回可变参数所指向的JSON值。	json
`json_set(val: jsonb, path: string[], to: jsonb, create_missing: bool)`	返回可变参数所指向的JSON值。如果`create_missing`为false，则不会将新键插入对象，也不会在值之前或之后添加值。	json
`json_strip_nulls(from_json: jsonb)`	返回from_json，其中所有具有空值的对象字段都被省略。其他空值保持不变。	json
`json_typeof(val: jsonb)`	以文字字串传回最外层JSON值的类型。	string
`jsonb_array_length(json: jsonb)`	返回最外面的JSON或JSONB数组中的元素数。	int
`jsonb_build_array(anyelement...)`	从可变参数列表中构建一个可能是异构类型的JSON或JSONB数组。	int
`jsonb_build_object(anyelement...)`	从可变参数列表中构建JSON对象。	json
`jsonb_extract_path(jsonb, string...)`	返回可变参数所指向的JSON值。	json
`jsonb_insert(target: jsonb, path: string[], new_val: jsonb)`	返回可变参数所指向的JSON值。`new_val`将在路径目标之前插入。	jsonb
`jsonb_insert(target: jsonb, path: string[], new_val: jsonb, insert_after: bool)`	返回可变参数所指向的JSON值。如果`insert_after`为true（默认为false），`new_val`则将在路径目标之后插入。	jsonb
`jsonb_object(keys: string[], values: string[])`	这种形式的json_object从两个单独的数组中成对地获取键和值。在所有其他方面，它与单参数形式相同。	jsonb
`jsonb_object(texts: string[])`	从文本数组构建JSON或JSONB对象。数组必须具有一维且成员数为偶数，在这种情况下，它们被视为交替的键/值对。	jsonb
`jsonb_pretty(val: jsonb)`	以缩进和换行符的形式返回给定的JSON值。	string
`jsonb_set(val: jsonb, path: string[], to: jsonb)`	返回可变参数所指向的JSON值。	jsonb
`jsonb_set(val: jsonb, path: string[], to: jsonb, create_missing: bool)`	返回可变参数所指向的JSON值。如果`create_missing`为false，则不会将新键插入对象，也不会在值之前或之后添加值。	jsonb
`jsonb_strip_nulls(from_json: jsonb)`	返回from_json，其中所有具有空值的对象字段都被省略。其他空值保持不变。	jsonb
`jsonb_typeof(val: jsonb)`	以文字字串传回最外层JSON值的类型。	string
`to_json(val: anyelement)`	以JSON或JSONB的形式返回值。	json
`to_jsonb(val: anyelement)`	以JSON或JSONB的形式返回值。	jsonb

下载PDF

本页导航

特殊的语法形式
条件运算符和类函数运算符
数组函数
比较函数
时间函数
ID函数
数学类函数
字符串函数
聚合函数
JSON函数