关系数据函数
数据库函数是一组预定义的操作，用于对数据执行特定的计算或转换。
特殊语法形式
为了兼容 SQL 标准和 PostgreSQL，KWDB 支持以下函数，这些函数与常规的内置函数具有等效功能。
| 特殊形式 | 等价于 |
|---|---|
AT TIME ZONE | timezone() |
CURRENT_CATALOG | current_database() |
COLLATION FOR | pg_collation_for() |
CURRENT_DATE | current_date() |
CURRENT_ROLE | current_user() |
CURRENT_SCHEMA | current_schema() |
CURRENT_TIMESTAMP | current_timestamp() |
CURRENT_TIME | current_time() |
CURRENT_USER | current_user() |
EXTRACT(<part> FROM <value>) | extract("<part>", <value>) |
EXTRACT_DURATION(<part>FROM <value>) | extract_duration("<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>) |
POSITION(<text1> IN <text2>) | strpos(<text2>, <text1>) |
SESSION_USER | current_user() |
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(<text1>, <text2>) | btrim(<text1>, <text2>) |
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(...) | 元组构造函数 |
内置函数
数组函数
| 函数 → 返回值 | 描述 |
|---|---|
| array_append(array: bool[], elem: bool) → bool[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: bytes[], elem: bytes) → bytes[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: date[], elem: date) → date[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: decimal[], elem: decimal) → decimal[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: float4[], elem: float4) → float4[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: float8[], elem: float8) → float8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: inet[], elem: inet) → inet[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: int2[], elem: int2) → int8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: int2[], elem: int4) → int8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: int2[], elem: int8) → int8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: int4[], elem: int2) → int8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: int4[], elem: int4) → int8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: int4[], elem: int8) → int8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: int8[], elem: int2) → int8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: int8[], elem: int4) → int8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: int8[], elem: int8) → int8[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: interval[], elem: interval) → interval[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: string[], elem: string) → string[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: time[], elem: time) → time[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: timestamp[], elem: timestamp) → timestamp[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: timestamptz[], elem: timestamptz) → timestamptz[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: uuid[], elem: uuid) → uuid[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: oid[], elem: oid) → oid[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: timetz[], elem: timetz) → timetz[] | 向数组增加新的元素，返回其结果。 |
| array_append(array: varbit[], elem: varbit) → 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: float4[], right: float4[]) → float8[] | 连接两个数组。 |
| array_cat(left: float4[], right: float8[]) → float8[] | 连接两个数组。 |
| array_cat(left: float8[], right: float4[]) → float8[] | 连接两个数组。 |
| array_cat(left: float8[], right: float8[]) → float8[] | 连接两个数组。 |
| array_cat(left: inet[], right: inet[]) → inet[] | 连接两个数组。 |
| array_cat(left: int2[], right: int2[]) → int8[] | 连接两个数组。 |
| array_cat(left: int2[], right: int4[]) → int8[] | 连接两个数组。 |
| array_cat(left: int2[], right: int8[]) → int8[] | 连接两个数组。 |
| array_cat(left: int4[], right: int2[]) → int8[] | 连接两个数组。 |
| array_cat(left: int4[], right: int4[]) → int8[] | 连接两个数组。 |
| array_cat(left: int4[], right: int8[]) → int8[] | 连接两个数组。 |
| array_cat(left: int8[], right: int2[]) → int8[] | 连接两个数组。 |
| array_cat(left: int8[], right: int4[]) → int8[] | 连接两个数组。 |
| array_cat(left: int8[], right: int8[]) → int8[] | 连接两个数组。 |
| 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: oid[], right: oid[]) → oid[] | 连接两个数组。 |
| array_cat(left: timetz[], right: timetz[]) → timetz[] | 连接两个数组。 |
| array_cat(left: varbit[], right: varbit[]) → varbit[] | 连接两个数组。 |
| array_length(input:anyelement[],array_dimension: int8) → int8 | 以 array_dimension 维度计算 input 的长度。但是，KWDB 尚不支持多维数组，因此唯一支持的 array_dimension 为 1。 |
| array_lower(input:anyelement[],array_dimension: int8) → int8 | 以 array_dimension 维度计算 input 的最小值。但是，KWDB 尚不支持多维数组，因此唯一支持的 array_dimension 为 1。 |
| array_position(array: bool[], elem: bool) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: bytes[], elem: bytes) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: date[], elem: date) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: decimal[], elem: decimal) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: float4[], elem: float4) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: float8[], elem: float8) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: inet[], elem: inet) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: int2[], elem: int2) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: int4[], elem: int4) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: int8[], elem: int8) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: interval[], elem: interval) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: string[], elem: string) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: time[], elem: time) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array:timestamp[],elem:timestamp) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array:timestamptz[],elem:timestamptz) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: uuid[], elem: uuid) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: oid[], elem: oid) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: timetz[], elem: timetz) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_position(array: varbit[], elem: varbit) → int8 | 返回数组中第一次出现 elem 元素的索引。 |
| array_positions(array: bool[], elem: bool) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: bytes[], elem: bytes) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: date[], elem: date) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: decimal[], elem: decimal) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: float4[], elem: float4) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: float8[], elem: float8) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: inet[], elem: inet) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: int2[], elem: int2) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: int4[], elem: int4) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: int8[], elem: int8) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: interval[], elem: interval) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: string[], elem: string) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: time[], elem: time) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array:timestamp[],elem:timestamp) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array:timestamptz[],elem:timestamptz) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: uuid[], elem: uuid) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: oid[], elem: oid) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: timetz[], elem: timetz) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_positions(array: varbit[], elem: varbit) → int8[] | 返回数组中出现 elem 元素的所有索引。 |
| array_prepend(elem: bool, array: bool[]) → bool[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: bytes, array: bytes[]) → bytes[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: date, array: date[]) → date[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: decimal, array: decimal[]) → decimal[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: float4, array: float4[]) → float4[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: float8, array: float8[]) → float8[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: inet, array: inet[]) → inet[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: int2, array: int2[]) → int2[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: int4, array: int4[]) → int4[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: int8, array: int8[]) → int8[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: interval, array: interval[]) → interval[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: string, array: string[]) → string[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: time, array: time[]) → time[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem:timestamp,array:timestamp[]) → timestamp[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem:timestamptz,array:timestamptz[]) → timestamptz[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: uuid, array: uuid[]) → uuid[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: oid, array: oid[]) → oid[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: timetz, array: timetz[]) → timetz[] | 将元素放到数组前，返回结果。 |
| array_prepend(elem: varbit, array: varbit[]) → varbit[] | 将元素放到数组前，返回结果。 |
| array_remove(array: bool[], elem: bool) → bool[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: bytes[], elem: bytes) → bytes[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: date[], elem: date) → date[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: decimal[], elem: decimal) → decimal[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: float4[], elem: float4) → float4[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: float8[], elem: float8) → float8[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: inet[], elem: inet) → inet[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: int2[], elem: int2) → int2[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: int4[], elem: int4) → int4[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: int8[], elem: int8) → int8[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: interval[], elem: interval) → interval[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: string[], elem: string) → string[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: time[], elem: time) → time[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array:timestamp[],elem:timestamp) → timestamp[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array:timestamptz[],elem:timestamptz) → timestamptz[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: uuid[], elem: uuid) → uuid[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: oid[], elem: oid) → oid[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: timetz[], elem: timetz) → timetz[] | 从数组中删除所有等于 elem 的元素。 |
| array_remove(array: varbit[], elem: varbit) → varbit[] | 从数组中删除所有等于 elem 的元素。 |
| array_replace(array: bool[], toreplace: bool, replacewith: bool) → bool[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: bytes[], toreplace: bytes, replacewith: bytes) → bytes[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: date[], toreplace: date, replacewith: date) → date[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: decimal[], toreplace: decimal, replacewith: decimal) → decimal[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: float4[], toreplace: float4, replacewith: float4) → float4[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: float8[], toreplace: float8, replacewith: float8) → float8[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: inet[], toreplace: inet, replacewith: inet) → inet[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: int2[], toreplace: int2, replacewith: int2) → int2[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: int4[], toreplace: int4, replacewith: int4) → int4[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: int8[], toreplace: int8, replacewith: int8) → int8[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: interval[], toreplace: interval, replacewith: interval) → interval[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: string[], toreplace: string, replacewith: string) → string[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: time[], toreplace: time, replacewith: time) → time[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: timestamp[], toreplace: timestamp, replacewith: timestamp) → timestamp[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: timestamptz[], toreplace: timestamptz, replacewith: timestamptz) → timestamptz[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: uuid[], toreplace: uuid, replacewith: uuid) → uuid[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: oid[], toreplace: oid, replacewith: oid) → oid[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: timetz[], toreplace: timetz, replacewith: timetz) → timetz[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_replace(array: varbit[], toreplace: varbit, replacewith: varbit) → varbit[] | 用 replacewith 替换数组中所有出现的 toreplace。 |
| array_to_string(input: anyelement[], delim: string) → string | 用定界符 delimiter 将数组元素连接为一个字符串。 |
| array_to_string(input: anyelement[], delimiter: string, null: string) → string | 用定界符 delimiter 将数组元素连接为一个字符串，把 NULL 替换为 NULL 参数代表的字符串。 |
| array_upper(input: anyelement[], array_dimension: int8) → int8 | 以 array_dimension 维度计算 input 中的最大值。KWDB 尚不支持多维数组，因此唯一支持的 array_dimension 为 1。 |
| string_to_array(str: string, delimiter: string) → string[] | 用定界符 delimiter 将字符串进行拆分。 |
| string_to_array(str: string, delimiter: string, null: string) → string[] | 用定界符 delimiter 将字符串进行拆分，把 NULL 替换为 NULL 参数代表的字符串。 |
布尔函数
| 函数 → 返回值 | 描述 |
|---|---|
| ilike_escape(unescaped: string, pattern: string, escape: string) → bool | pattern 使用 escape 作为转义标记来匹配不区分大小写的 unescaped。 |
| inet_contained_by_or_equals(val: inet, container: inet) → bool | 仅使用地址的网络部分测试子网是否包含或相等。地址的主机部分被忽略。 |
| inet_contains_or_equals(container: inet, val: inet) → bool | 仅使用地址的网络部分测试子网是否包含或相等。地址的主机部分被忽略。 |
| inet_same_family(val: inet, val: inet) → bool | 检查两个 IP 是否属于同一个 IP 地址族。 |
| like_escape(unescaped: string, pattern: string, escape: string) → bool | pattern 使用 escape 作为转义标记来匹配 unescaped。 |
| not_ilike_escape(unescaped: string, pattern: string, escape: string) → bool | 检查 pattern 使用 escape 作为转义标记是否不匹配不区分大小写的 unescaped。 |
| not_like_escape(unescaped: string, pattern: string, escape: string) → bool | 检查 pattern 使用 escape 作为转义标记是否不匹配 unescaped。 |
| not_similar_to_escape(unescaped: string, pattern: string, escape: string) → bool | 检查 pattern 使用 escape 作为转义标记是否不匹配 unescaped。 |
| similar_to_escape(unescaped: string, pattern: string, escape: string) → bool | pattern 使用 escape 作为转义标记来匹配 unescaped。 |
比较函数
| 函数 → 返回值 | 描述 |
|---|---|
| greatest(anyelement...) → anyelement | 返回值最大的元素。 |
| least(anyelement...) → anyelement | 返回值最小的元素。 |
日期和时间函数
| 函数 → 返回值 | 描述 |
|---|---|
| age(end: timestamptz, begin: timestamptz) → interval | 计算 begin 和 end 之间的时间间隔。 |
| age(val: timestamptz) → interval | 计算 val 与当前时间之间的间隔。 |
| current_date() → date | 返回当前事务的日期。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| current_timestamp() → date | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| current_timestamp() → timestamp | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| current_timestamp() → timestamptz | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| current_timestamp(precision: int8) → date | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| current_timestamp(precision: int8) → timestamp | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| current_timestamp(precision: int8) → timestamptz | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| date_trunc(element: string, input: date) → timestamptz | 将输入截断成精度为 element，将所有无意义的字段设为 0（或对于日期和月份则设为 1）。兼容元素：millennium、century、decade、year、quarter、month、week、day、hour、minute、second、millisecond、microsecond。 |
| date_trunc(element: string, input: time) → interval | 将输入截断成精度为 element，将所有无意义的字段设为 0。兼容元素: hour、minute、second、millisecond、microsecond。 |
| date_trunc(element: string, input: timestamp) → timestamp | 将输入截断成精度为 element，将所有无意义的字段设为 0（或对于日期和月份则设为 1）。兼容元素：millennium、century、decade、year、quarter、month、week、day、hour、minute、second、millisecond、microsecond。 |
| date_trunc(element: string, input: timestamptz) → timestamptz | 将输入截断成精度为 element，将所有无意义的字段设为 0（或对于日期和月份则设为 1）。兼容元素：millennium、century、decade、year、quarter、month、week、day、hour、minute、second、millisecond、microsecond。 |
| experimental_strftime(input: date, extract_format: string) → string | 从输入中提取并格式化成 extract_format 标识的时间，extract_format 使用标准的 strftime 表示法（尽管不支持所有格式）。 |
| experimental_strftime(input: timestamp, extract_format: string) → string | 从输入中提取并格式化成 extract_format 标识的时间，extract_format 使用标准的 strftime 表示法（尽管不支持所有格式）。 |
| experimental_strftime(input: timestamptz, extract_format: string) → string | 从输入中提取并格式化成 extract_format 标识的时间，extract_format 使用标准的 strftime 表示法（尽管不支持所有格式）。 |
| extract(element: string, input: date) → float8 | 从输入中提取 element。兼容元素：millennium、century、decade、year、isoyear、quarter、month、week、dayofweek、isodow、dayofyear、julian、hour、minute、second、millisecond、microsecond、epoch。 |
| extract(element: string, input: interval) → float8 | 从输入中提取 element。兼容元素: millennium、century、decade、year、month、day、hour、minute、second、millisecond、microsecond、epoch。 |
| extract(element: string, input: time) → float8 | 从输入中提取 element。兼容元素：millennium、century、decade、year、month、day、hour、minute、second、millisecond、microsecond、epoch。 |
| extract(element: string, input: timestamp) → float8 | 从输入中提取 element。兼容元素：millennium、century、decade、year、isoyear、quarter、month、week、dayofweek、isodow、dayofyear、julian、hour、minute、second、millisecond、microsecond、epoch。 |
| extract(element: string, input: timestamptz) → float8 | 从输入中提取 element。兼容元素：millennium、century、decade、year、isoyear、quarter、month、week、dayofweek、isodow、dayofyear、julian、hour、minute、second、millisecond、microsecond、epoch、timezone、timezone_hour、timezone_minute。 |
| extract(element: string, input: timetz) → float8 | 从输入中提取 element。兼容元素：hour、minute、second、millisecond、microsecond、epoch、timezone、timezone_hour、timezone_minute。 |
| extract(element: string, input: int2) → float8 | 从输入中提取 element。兼容元素：hour、minute、second、millisecond、microsecond、epoch、timezone、timezone_hour、timezone_minute。 |
| extract(element: string, input: int4) → float8 | 从输入中提取 element。兼容元素：hour、minute、second、millisecond、microsecond、epoch、timezone、timezone_hour、timezone_minute。 |
| extract(element: string, input: int8) → float8 | 从输入中提取 element。兼容元素：hour、minute、second、millisecond、microsecond、epoch、timezone、timezone_hour、timezone_minute。 |
| extract_duration(element: string, input: interval) → int8 | 从输入中提取 element。兼容元素: hour、minute、second、millisecond、microsecond。 |
| localtimestamp() → date | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| localtimestamp() → timestamp | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| localtimestamp() → timestamptz | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| localtimestamp(precision: int8) → date | 根据指定精度返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关，其中 precision 表示精度，指定了保留秒后的小数点后的位数。 |
| localtimestamp(precision: int8) → timestamp | 根据指定精度返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关，其中 precision 表示精度，指定了保留秒后的小数点后的位数。 |
| localtimestamp(precision: int8) → timestamptz | 根据指定精度返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关，其中 precision 表示精度，指定了保留秒后的小数点后的位数。 |
| now() → date | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| now() → timestamp | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| now() → timestamptz | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| statement_timestamp() → timestamp | 返回当前语句的开始时间戳。 |
| statement_timestamp() → timestamptz | 返回当前语句的开始时间戳。 |
| timeofday() → string | 返回某个集群节点的当前系统时间。 |
| timezone(time: time, timezone: string) → timetz | 将 time 转换为指定时区的 timetz 类型。 |
| timezone(timestamp: timestamp, timezone: string) → timestamptz | 将 timestamp 转换为指定时区的 timestamptz 类型。 |
| timezone(timestamptz: timestamptz, timezone: string) → timestamp | 将 timestamptz 转换到指定时区，返回不带时区的 timestamp 类型。 |
| timezone(timetz: timetz, timezone: string) → timetz | 将 timetz 转换到指定时区，返回新时区的 timetz 类型。 |
| timezone(timezone: string, time: time) → timetz | 将 time 转换为指定时区的 timetz 类型。 |
| timezone(timezone: string, timestamp: timestamp) → timestamptz | 将 timestamp 转换为指定时区的 timestamptz 类型。 |
| timezone(timezone: string, timestamptz: timestamptz) → timestamp | 将 timestamptz 转换到指定时区，返回不带时区的 timestamp 类型。 |
| timezone(timezone: string, timestamptz_string: string) → timestamp | 将 timestamptz 转换到指定时区，返回不带时区的 timestamp 类型。 |
| timezone(timezone: string, timetz: timetz) → timetz | 将 timetz 转换到指定时区，返回新时区的 timetz 类型。 |
| transaction_timestamp() → date | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| transaction_timestamp() → timestamp | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
| transaction_timestamp() → timestamptz | 返回当前事务的时间。该值基于事务开始时选择的时间戳，并且在整个事务中保持不变。此时间戳与并发事务的提交顺序无关。 |
ID 生成函数
| 函数 → 返回值 | 描述 |
|---|---|
| experimental_uuid_v4() → bytes | 返回一个 UUID。 |
| gen_random_uuid() → uuid | 生成随机 UUID 并将其作为 UUID 类型的值返回。 |
| unique_rowid() → int8 | 如果表未定义主键，则返回一个唯一 ID，该 ID 被 KWDB 用于生成唯一的行 ID。该值是写入时间戳和执行语句的节点的 ID 的组合，这保证了此组合是全局唯一的。 |
| uuid_v4() → bytes | 返回一个 UUID。 |
网络函数
| 函数 → 返回值 | 描述 |
|---|---|
| abbrev(val: inet) → string | 将 IP 地址和前缀长度转换为文本类型的缩写显示格式。对于 INET 类型，如果不是默认值（IPv4 为 32，IPv6 为 128），将省略前缀长度。例如，abbrev('192.168.1.2/24') 返回 '192.168.1.2/24'。 |
| broadcast(val: inet) → inet | 获取 val 表示的网络地址的广播地址。例如，broadcast('192.168.1.2/24') 返回 '192.168.1.255/24'。 |
| family(val: inet) → int8 | 提取 val 的 IP 地址族; IPv4 为 4，IPv6 为 6。例如，family('::1') 返回 6。 |
| host(val: inet) → string | 将组合地址/前缀值的地址部分提取为文本。例如，host('192.168.1.2/16') 返回'192.168.1.2'。 |
| hostmask(val: inet) → inet | 创建与 val 中的前缀长度对应的 IP 主机掩码。例如，hostmask('192.168.1.2/16') 返回'0.0.255.255'。 |
| masklen(val: inet) → int8 | 检索存储在 val 中的前缀长度。例如，masklen('192.168.1.2/16') 返回 16。 |
| netmask(val: inet) → inet | 创建与 val 中的前缀长度对应的 IP 网络掩码。例如，netmask('192.168.1.2/16') 返回'255.255.0.0'。 |
| set_masklen(val: inet, prefixlen: int8) → inet | 将 val 的前缀长度设置为 prefixlen。例如，set_masklen('192.168.1.2',16) 返回'192.168.1.2/16'。 |
| text(val: inet) → string | 将 IP 地址和前缀长度转换为文本格式。 |
JSONB 函数
| 函数 → 返回值 | 描述 |
|---|---|
| array_to_json(array: anyelement[]) → jsonb | 将数组返回为 JSON 或 JSONB。 |
| array_to_json(array: anyelement[], pretty_bool: bool) → jsonb | 将数组返回为 JSON 或 JSONB。 |
| json_array_length(json: jsonb) → int8 | 返回 JSON 或 JSONB 数组中最外层元素的数量。 |
| json_build_array(anyelement...) → jsonb | 从可变参数列表构建可能异构类型（Possibly-Heterogeneously-Typed）的 JSON 或 JSONB 数组。 |
| json_build_object(anyelement...) → jsonb | 从可变参数列表构建 JSON 对象。 |
| json_extract_path(jsonb, string...) → jsonb | 返回可变参数指向的 JSON 值。 |
| json_object(keys: string[], values: string[]) → jsonb | 从两个独立的数组中成对获取键和值。在所有其他方面，与单参数形式相同。 |
| json_object(texts: string[]) → jsonb | 从文本数组中构建 JSON 或 JSONB 对象。数组必须是一个具有偶数个成员的一维数组，数组成员被视为交替的键/值对。 |
| json_remove_path(val: jsonb, path: string[]) → jsonb | 从 JSON 对象中删除指定的路径。 |
| json_set(val: jsonb, path: string[], to: jsonb) → jsonb | 返回可变参数指向的 JSON 值。 |
| json_set(val: jsonb, path: string[], to: jsonb, create_missing: bool) → jsonb | 返回可变参数指向的 JSON 值。如果 create_missing 为 false，则不会将新 key 写入到对象中，并且值也不会被添加到数组 |
| json_strip_nulls(from_json: jsonb) → jsonb | 返回 from_json，其中包含省略空值的所有对象字段。其他空值不受影响。 |
| json_typeof(val: jsonb) → string | 以文本字符串形式返回最外层 JSON 值的类型。 |
| jsonb_array_length(json: jsonb) → int8 | 返回最外层 JSON 或 JSONB 数组中的元素的数量。 |
| jsonb_build_array(anyelement...) → jsonb | 从可变参数列表构建可能异构类型（Possibly-Heterogeneously-Typed）的 JSON 或 JSONB 数组。 |
| jsonb_build_object(anyelement...) → jsonb | 从可变参数列表构建 JSON 对象。 |
| jsonb_extract_path(jsonb, string...) → jsonb | 返回可变参数指向的 JSON 值。 |
| jsonb_insert(target: jsonb, path: string[], new_val: jsonb) → jsonb | 返回可变参数所指向的 JSON 值。new_val 将在路径目标之前写入。 |
| jsonb_insert(target: jsonb, path: string[], new_val: jsonb, insert_after: bool) → jsonb | 返回可变参数所指向的 JSON 值。如果 insert_after 为 true（默认为 false），则将 new_val 写入到路径目标之后。 |
| jsonb_object(keys: string[], values: string[]) → jsonb | 从两个独立的数组中成对获取键和值。在所有其他方面，与单参数形式相同。 |
| jsonb_object(texts: string[]) → jsonb | 从文本数组中构建 JSON 或 JSONB 对象。数组必须是一个具有偶数个成员的一维数组，数组成员被视为交替的键/值对。 |
| jsonb_pretty(val: jsonb) → string | 返回给定的 JSON 值，作为缩进的 STRING 和换行符。 |
| jsonb_set(val: jsonb, path: string[], to: jsonb) → jsonb | 返回可变参数指向的 JSON 值。 |
| jsonb_set(val: jsonb, path: string[], to: jsonb, create_missing: bool) → jsonb | 返回可变参数指向的 JSON 值。如果 create_missing 为 false，则不会将新 key 写入到对象中，并且值也不会被添加到数组 |
| jsonb_strip_nulls(from_json: jsonb) → jsonb | 返回 from_json，其中包含省略空值的所有对象字段。其他空值不受影响。 |
| jsonb_typeof(val: jsonb) → string | 以文本字符串形式返回最外层 JSON 值的类型。 |
| to_json(val: anyelement) → jsonb | 将 val 返回为 JSON 或 JSONB。 |
| to_jsonb(val: anyelement) → jsonb | 将 val 返回为 JSON 或 JSONB。 |
数学和数值函数
| 函数 → 返回值 | 描述 |
|---|---|
| abs(val: decimal) → decimal | 计算 val 的绝对值。 |
| abs(val: float4) → float4 | 计算 val 的绝对值。 |
| abs(val: float8) → float8 | 计算 val 的绝对值。 |
| abs(val: int2) → int2 | 计算 val 的绝对值。 |
| abs(val: int4) → int4 | 计算 val 的绝对值。 |
| abs(val: int8) → int8 | 计算 val 的绝对值。 |
| acos(val: float4) → float8 | 计算 val 的反余弦值。 |
| acos(val: float8) → float8 | 计算 val 的反余弦值。 |
| asin(val: float4) → float8 | 计算 val 的反正弦值。 |
| asin(val: float8) → float8 | 计算 val 的反正弦值。 |
| atan(val: float4) → float8 | 计算 val 的反正切值。 |
| atan(val: float8) → float8 | 计算 val 的反正切值。 |
| atan2(x: float4, y: float4) → float8 | 计算 x / y 的反正切。 |
| atan2(x: float4, y: float8) → float8 | 计算 x / y 的反正切。 |
| atan2(x: float8, y: float4) → float8 | 计算 x / y 的反正切。 |
| atan2(x: float8, y: float8) → float8 | 计算 x / y 的反正切。 |
| cbrt(val: decimal) → decimal | 计算 val 的立方根(∛)。 |
| cbrt(val: float4) → float8 | 计算 val 的立方根(∛)。 |
| cbrt(val: float8) → float8 | 计算 val 的立方根(∛)。 |
| ceil(val: decimal) → decimal | 计算大于等于 val 的最小整数。 |
| ceil(val: float4) → float8 | 计算大于等于 val 的最小整数。 |
| ceil(val: float8) → float8 | 计算大于等于 val 的最小整数。 |
| ceil(val: int2) → float8 | 计算大于等于 val 的最小整数。 |
| ceil(val: int4) → float8 | 计算大于等于 val 的最小整数。 |
| ceil(val: int8) → float8 | 计算大于等于 val 的最小整数。 |
| ceiling(val: decimal) → decimal | 计算大于等于 val 的最小整数。 |
| ceiling(val: float4) → float8 | 计算大于等于 val 的最小整数。 |
| ceiling(val: float8) → float8 | 计算大于等于 val 的最小整数。 |
| ceiling(val: int2) → float8 | 计算大于等于 val 的最小整数。 |
| ceiling(val: int4) → float8 | 计算大于等于 val 的最小整数。 |
| ceiling(val: int8) → float8 | 计算大于等于 val 的最小整数。 |
| cos(val: float4) → float8 | 计算 val 的余弦值。 |
| cos(val: float8) → float8 | 计算 val 的余弦值。 |
| cot(val: float4) → float8 | 计算 val 的余切值。 |
| cot(val: float8) → float8 | 计算 val 的余切值。 |
| crc32c(bytes...) → int8 | 使用 Castagnoli 多项式计算 CRC-32 哈希值。 |
| crc32c(string...) → int8 | 使用 Castagnoli 多项式计算 CRC-32 哈希值。 |
| crc32ieee(bytes...) → int8 | 使用 IEEE 多项式计算 CRC-32 哈希值。 |
| crc32ieee(string...) → int8 | 使用 IEEE 多项式计算 CRC-32 哈希值。 |
| degrees(val: float4) → float8 | 将 val 作为弧度值转换为度数值。 |
| degrees(val: float8) → float8 | 将 val 作为弧度值转换为度数值。 |
| div(x: decimal, y: decimal) → decimal | 计算 x / y 的整数商。 |
| div(x: float4, y: float4) → float8 | 计算 x / y 的整数商。 |
| div(x: float4, y: float8) → float8 | 计算 x / y 的整数商。 |
| div(x: float8, y: float4) → float8 | 计算 x / y 的整数商。 |
| div(x: float8, y: float8) → float8 | 计算 x / y 的整数商。 |
| div(x: int2, y: int2) → int8 | 计算 x / y 的整数商。 |
| div(x: int2, y: int4) → int8 | 计算 x / y 的整数商。 |
| div(x: int2, y: int8) → int8 | 计算 x / y 的整数商。 |
| div(x: int4, y: int2) → int8 | 计算 x / y 的整数商。 |
| div(x: int4, y: int4) → int8 | 计算 x / y 的整数商。 |
| div(x: int4, y: int8) → int8 | 计算 x / y 的整数商。 |
| div(x: int8, y: int2) → int8 | 计算 x / y 的整数商。 |
| div(x: int8, y: int4) → int8 | 计算 x / y 的整数商。 |
| div(x: int8, y: int8) → int8 | 计算 x / y 的整数商。 |
| exp(val: decimal) → decimal | 计算 e ^ val。 |
| exp(val: float4) → float8 | 计算 e ^ val。 |
| exp(val: float8) → float8 | 计算 e ^ val。 |
| floor(val: decimal) → decimal | 计算不大于 val 的最大整数。 |
| floor(val: float4) → float8 | 计算不大于 val 的最大整数。 |
| floor(val: float8) → float8 | 计算不大于 val 的最大整数。 |
| floor(val: int2) → float8 | 计算不大于 val 的最大整数。 |
| floor(val: int4) → float8 | 计算不大于 val 的最大整数。 |
| floor(val: int8) → float8 | 计算不大于 val 的最大整数。 |
| fnv32(bytes...) → int8 | 计算一组值的 32 位 FNV-1 哈希值。 |
| fnv32(string...) → int8 | 计算一组值的 32 位 FNV-1 哈希值。 |
| fnv32a(bytes...) → int8 | 计算一组值的 32 位 FNV-1a 哈希值。 |
| fnv32a(string...) → int8 | 计算一组值的 32 位 FNV-1a 哈希值。 |
| fnv64(bytes...) → int8 | 计算一组值的 64 位 FNV-1 哈希值。 |
| fnv64(string...) → int8 | 计算一组值的 64 位 FNV-1 哈希值。 |
| fnv64a(bytes...) → int8 | 计算一组值的 64 位 FNV-1a 哈希值。 |
| fnv64a(string...) → int8 | 计算一组值的 64 位 FNV-1a 哈希值。 |
| isnan(val: decimal) → bool | 如果 val 是 NaN，则返回 true，否则返回 false。 |
| isnan(val: float4) → bool | 如果 val 是 NaN，则返回 true，否则返回 false。 |
| isnan(val: float8) → bool | 如果 val 是 NaN，则返回 true，否则返回 false。 |
| ln(val: decimal) → decimal | 计算 val 的自然对数。 |
| ln(val: float4) → float8 | 计算 val 的自然对数。 |
| ln(val: float8) → float8 | 计算 val 的自然对数。 |
| log(b: decimal, x: decimal) → decimal | 计算 val 的指定基数的 log。 |
| log(b: float4, x: float4) → float8 | 计算 val 的指定基数的 log。 |
| log(b: float4, x: float8) → float8 | 计算 val 的指定基数的 log。 |
| log(b: float8, x: float4) → float8 | 计算 val 的指定基数的 log。 |
| log(b: float8, x: float8) → float8 | 计算 val 的指定基数的 log。 |
| log(val: decimal) → decimal | 计算 val 的基数为 10 的 log。 |
| log(val: float4) → float8 | 计算 val 的基数为 10 的 log。 |
| log(val: float8) → float8 | 计算 val 的基数为 10 的 log。 |
| mod(x: decimal, y: decimal) → decimal | 计算 x％y。 |
| mod(x: float4, y: float4) → float8 | 计算 x％y。 |
| mod(x: float4, y: float8) → float8 | 计算 x％y。 |
| mod(x: float8, y: float4) → float8 | 计算 x％y。 |
| mod(x: float8, y: float8) → float8 | 计算 x％y。 |
| mod(x: int2, y: int2) → int8 | 计算 x％y。 |
| mod(x: int2, y: int4) → int8 | 计算 x％y。 |
| mod(x: int2, y: int8) → int8 | 计算 x％y。 |
| mod(x: int4, y: int2) → int8 | 计算 x％y。 |
| mod(x: int4, y: int4) → int8 | 计算 x％y。 |
| mod(x: int4, y: int8) → int8 | 计算 x％y。 |
| mod(x: int8, y: int2) → int8 | 计算 x％y。 |
| mod(x: int8, y: int4) → int8 | 计算 x％y。 |
| mod(x: int8, y: int8) → int8 | 计算 x％y。 |
| pi() → float8 | 返回 pi 的值（3.141592653589793）。 |
| pow(x: decimal, y: decimal) → decimal | 计算 x^y。 |
| pow(x: float4, y: float4) → float8 | 计算 x^y。 |
| pow(x: float4, y: float8) → float8 | 计算 x^y。 |
| pow(x: float8, y: float4) → float8 | 计算 x^y。 |
| pow(x: float8, y: float8) → float8 | 计算 x^y。 |
| pow(x: int2, y: int2) → int8 | 计算 x^y。 |
| pow(x: int2, y: int4) → int8 | 计算 x^y。 |
| pow(x: int2, y: int8) → int8 | 计算 x^y。 |
| pow(x: int4, y: int2) → int8 | 计算 x^y。 |
| pow(x: int4, y: int4) → int8 | 计算 x^y。 |
| pow(x: int4, y: int8) → int8 | 计算 x^y。 |
| pow(x: int8, y: int2) → int8 | 计算 x^y。 |
| pow(x: int8, y: int4) → int8 | 计算 x^y。 |
| pow(x: int8, y: int8) → int8 | 计算 x^y。 |
| power(x: decimal, y: decimal) → decimal | 计算 x^y。 |
| power(x: float4, y: float4) → float8 | 计算 x^y。 |
| power(x: float4, y: float8) → float8 | 计算 x^y。 |
| power(x: float8, y: float4) → float8 | 计算 x^y。 |
| power(x: float8, y: float8) → float8 | 计算 x^y。 |
| power(x: int2, y: int2) → int8 | 计算 x^y。 |
| power(x: int2, y: int4) → int8 | 计算 x^y。 |
| power(x: int2, y: int8) → int8 | 计算 x^y。 |
| power(x: int4, y: int2) → int8 | 计算 x^y。 |
| power(x: int4, y: int4) → int8 | 计算 x^y。 |
| power(x: int4, y: int8) → int8 | 计算 x^y。 |
| power(x: int8, y: int2) → int8 | 计算 x^y。 |
| power(x: int8, y: int4) → int8 | 计算 x^y。 |
| power(x: int8, y: int8) → int8 | 计算 x^y。 |
| radians(val: float4) → float8 | 将 val 作为度数值转换为弧度值。 |
| radians(val: float8) → float8 | 将 val 作为度数值转换为弧度值。 |
| random() → float8 | 返回 0 到 1 之间的随机浮点数。 |
| round(input: decimal, decimal_accuracy: int8) → decimal | 使用四舍六入五远零（half away from zero）规则保留 input 中零右侧 decimal_accuracy 位数字。如果 decimal_accuracy 不在 -2^31…(2^31-1) 范围内，则结果是未定义的。 |
| round(input: float4, decimal_accuracy: int8) → float8 | 使用四舍六入五成双（half to even）（即银行家）规则保留 input 中零右侧 decimal_accuracy 位数字。 |
| round(input: float8, decimal_accuracy: int8) → float8 | 使用四舍六入五成双（half to even）（即银行家）规则保留 input 中零右侧 decimal_accuracy 位数字。 |
| round(val: decimal) → decimal | 使用四舍六入五远零（half away from zero）规则将 val 舍入到最接近的整数：ROUND(+/- 2.4)= +/- 2、ROUND(+/- 2.5)= +/- 3。 |
| round(val: float4) → float8 | 使用“四舍六入五成双（half to even）（即银行家）规则将 val 舍入到最接近的整数。 |
| round(val: float8) → float8 | 使用四舍六入五成双（half to even）（即银行家）规则将 val 舍入到最接近的整数。 |
| sign(val: decimal) → decimal | 确定 val 的符号： - 1 表示正。 - 0 表示值 0。 - -1 表示负。 |
| sign(val: float4) → float8 | 确定 val 的符号： - 1 表示正。 - 0 表示值 0。 - -1 表示负。 |
| sign(val: float8) → float8 | 确定 val 的符号： - 1 表示正。 - 0 表示值 0。 - -1 表示负。 |
| sign(val: int2) → int8 | 确定 val 的符号： - 1 表示正。 - 0 表示值 0。 - -1 表示负。 |
| sign(val: int4) → int8 | 确定 val 的符号： - 1 表示正。 - 0 表示值 0。 - -1 表示负。 |
| sign(val: int8) → int8 | 确定 val 的符号： - 1 表示正。 - 0 表示值 0。 - -1 表示负。 |
| sin(val: float4) → float8 | 计算 val 的正弦值。 |
| sin(val: float8) → float8 | 计算 val 的正弦值。 |
| sqrt(val: decimal) → decimal | 计算 val 的平方根。 |
| sqrt(val: float4) → float8 | 计算 val 的平方根。 |
| sqrt(val: float8) → float8 | 计算 val 的平方根。 |
| tan(val: float4) → float8 | 计算 val 的正切值。 |
| tan(val: float8) → float8 | 计算 val 的正切值。 |
| trunc(val: decimal) → decimal | 截断 val 的十进制值。 |
| trunc(val: float4) → float8 | 截断 val 的十进制值。 |
| trunc(val: float8) → float8 | 截断 val 的十进制值。 |
| width_bucket(operand: decimal, b1: decimal, b2: decimal, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: int8, b1: int2, b2: int2, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: int8, b1: int2, b2: int4, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: int8, b1: int2, b2: int8, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: int8, b1: int4, b2: int2, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: int8, b1: int4, b2: int4, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: int8, b1: int4, b2: int8, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: int8, b1: int8, b2: int2, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: int8, b1: int8, b2: int4, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: int8, b1: int8, b2: int8, count: int8) → int8 | 返回在直方图中为其分配操作数的存储桶编号，直方图具有跨越 B1 到 B2 的等宽存储桶计数。 |
| width_bucket(operand: anyelement, thresholds: anyelement[]) → int8 | 返回为存储桶下限的数组分配操作数的存储桶编号，对于小于第一个下限的输入，返回 0。阈值数组必须排序，最小值优先，否则将返回非预期结果。 |
序列函数
| 函数 → 返回值 | 描述 |
|---|---|
| currval(sequence_name: string) → int8 | 返回此会话中此序列的 nextval 获取的最新值。 |
| lastval() → int8 | 在此会话中使用 nextval 最近获得的返回值。 |
| nextval(sequence_name: string) → int8 | 推进给定的序列并返回其新值。 |
| setval(sequence_name: string, value: int8) → int8 | 设置给定序列的当前值。nextval 的下一次调用将返回 value + Increment。 |
| setval(sequence_name: string, value: int8, is_called: bool) → int8 | 设置给定序列的当前值。如果 is_called 为 false，则对 nextval 的下一次调用将返回 value; 否则返回 value + Increment。 |
设定-返回函数
| 函数 → 返回值 | 描述 |
|---|---|
| aclexplode(aclitems: string[]) → tuple{oid AS grantor, oid AS grantee, string AS privilege_type, bool AS is_grantable} | 生成一个包含 aclitem 内容的虚拟表。 |
| kwdb_internal.testing_callback(name: string) → int8 | 仅适用于内部 KWDB 测试。该函数会调用由测试在服务器注册的标识为 name 的回调函数。 |
| kwdb_internal.unary_table() → tuple | 生成不包含任何值的单行的虚拟表。仅供 KWDB 的开发人员测试使用。 |
| generate_series(start: int8, end: int8) → int8 | 生成一个虚拟表，其中包含从 start 到 end 的整数值。 |
| generate_series(start: int8, end: int8, step: int8) → int8 | 生成一个虚拟表，其中包含从 start 到 end，并以 step 为步长的整型值。 |
| generate_series(start: timestamp, end: timestamp, step: interval) → timestamp | 生成一个虚拟表，其中包含从 start 到 end，并以 step 为间隔的时间戳值。 |
| generate_subscripts(array: anyelement[]) → int8 | 返回一个包含给定数组下标的系列。 |
| generate_subscripts(array: anyelement[], dim: int8) → int8 | 返回一个包含给定数组下标的系列。 |
| generate_subscripts(array: anyelement[], dim: int8, reverse: bool) → int8 | 返回一个包含给定数组下标的系列。当 reverse 为 true 时，将以相反的顺序返回系列。 |
| information_schema._pg_expandarray(input: anyelement[]) → anyelement | 将输入数组作为带有索引的行集合返回。 |
| json_array_elements(input: jsonb) → jsonb | 将 JSON 数组扩展为 JSON 值集合。 |
| json_array_elements_text(input: jsonb) → string | 将 JSON 数组扩展为文本值集合。 |
| json_each(input: jsonb) → tuple{string AS key, jsonb AS value} | 将最外层的 JSON 或 JSONB 对象扩展为键/值对集合。 |
| json_each_text(input: jsonb) → tuple{string AS key, string AS value} | 将最外层的 JSON 或 JSONB 对象扩展为键/值对集合。返回的值是 text 类型。 |
| json_object_keys(input: jsonb) → string | 返回最外层 JSON 对象中的有序键集。 |
| jsonb_array_elements(input: jsonb) → jsonb | 将 JSON 数组扩展为一组 JSON 值。 |
| jsonb_array_elements_text(input: jsonb) → string | 将 JSON 数组扩展为一组文本值。 |
| jsonb_each(input: jsonb) → tuple{string AS key, jsonb AS value} | 将最外层的 JSON 或 JSONB 对象扩展为一组键/值对。 |
| jsonb_each_text(input: jsonb) → tuple{string AS key, string AS value} | 将最外层的 JSON 或 JSONB 对象扩展为一组键/值对。返回的值是 text 类型。 |
| jsonb_object_keys(input: jsonb) → string | 返回最外层 JSON 对象中的有序键集。 |
| pg_get_keywords() → tuple{string AS word, string AS catcode, string AS catdesc} | 生成包含 SQL 解析器能识别的关键字的虚拟表。 |
| unnest(anyelement[], anyelement[], anyelement[]...) → tuple{anyelement AS unnest, anyelement AS unnest, anyelement AS unnest} | 以行集合的形式返回输入数组。 |
| unnest(input: anyelement[]) → anyelement | 以行集合的形式返回输入数组。 |
字符串和字节函数
| 函数 → 返回值 | 描述 |
|---|---|
| ascii(val: string) → int8 | 返回 val 中第一个字符的字符代码。虽然函数名称叫 ascii，该函数也支持 Unicode 字符。 |
| bit_length(val: bytes) → int8 | 计算 val 中的位数。 |
| bit_length(val: string) → int8 | 计算用于表示 val 的位数。 |
| bit_length(val: varbit) → int8 | 计算用于表示 val 的位数。 |
| btrim(input: string, trim_chars: string) → string | 从输入的开头或结尾删除 trim_chars 中包含的任何字符(递归应用)。例如，btrim('doggie','od') 返回 ggi。 |
| btrim(val: string) → string | 删除 val 的开头和结尾的所有空格。 |
| char_length(val: bytes) → int8 | 计算 val 中的字节数。 |
| char_length(val: string) → int8 | 计算 val 中的字符数。 |
| character_length(val: bytes) → int8 | 计算 val 中的字节数。 |
| character_length(val: string) → int8 | 计算 val 中的字符数。 |
| chr(val: int2) → string | 返回带有 val 中给出的代码的字符。ascii() 的反函数。 |
| chr(val: int4) → string | 返回带有 val 中给出的代码的字符。ascii() 的反函数。 |
| chr(val: int8) → string | 返回带有 val 中给出的代码的字符。ascii() 的反函数。 |
| concat(string...) → string | 连接使用逗号（,）隔开的字符串列表。 |
| concat_ws(string...) → string | 使用第一个参数作为后续参数的串联分隔符。例如，concat_ws('！','wow','great') 返回 wow!great。 |
| convert_from(str: bytes, enc: string) → string | str 使用 encoding 将字节解码为字符串 enc。支持 UTF8 和 LATIN1 编码。 |
| convert_to(str: string, enc: string) → bytes | str 使用 encoding 将字符串编码为字节数组 enc。支持 UTF8 和 LATIN1 编码。 |
| decode(text: string, format: string) → bytes | 以 format 指定的格式解码数据（仅支持 hex 和 escape）。 |
| encode(data: bytes, format: string) → string | 以 format 指定的文本格式对数据进行编码（仅支持 hex 和 escape）。 |
| from_ip(val: bytes) → string | 将 IP 的字节字符串表示形式转换为其字符串表示形式。 |
| from_uuid(val: bytes) → string | 将 UUID 的字节字符串表示形式转换为其字符串表示形式。 |
| get_bit(bit_string: varbit, index: int8) → int8 | 提取位数组中的指定位。 |
| get_bit(byte_string: bytes, index: int8) → int8 | 提取位数组中的指定位。 |
| initcap(val: string) → string | 将 val 的第一个字母大写。 |
| left(input: bytes, return_set: int8) → bytes | 从 input 返回前 return_set 个字节。 |
| left(input: string, return_set: int8) → string | 从 input 返回前 return_set 个字符。 |
| length(val: bytes) → int8 | 计算 val 中的字节数。 |
| length(val: string) → int8 | 计算 val 中的字符数。 |
| length(val: varbit) → int8 | 计算 val 中的字符数。 |
| lower(val: string) → string | 将 val 中的所有字符转换为小写。 |
| lpad(string: string, length: int8) → string | 在字符串的左侧添加双引号（""），以填充字符串的长度。如果字符串的长度超过长度，则会被截断。 |
| lpad(string: string, length: int8, fill: string) → string | 在字符串的左侧添加 fill，以填充字符串的长度。如果字符串的长度超过长度，则会被截断。 |
| ltrim(input: string, trim_chars: string) → string | 从输入的开头（左侧）删除 trim_chars 中包含的任何字符（递归应用）。例如，ltrim('doggie','od') 返回 ggie。 |
| ltrim(val: string) → string | 删除 val 开头（左侧）的所有空格。 |
| md5(bytes...) → string | 计算一组值的 MD5 哈希值。 |
| md5(string...) → string | 计算一组值的 MD5 哈希值。 |
| octet_length(val: bytes) → int8 | 计算 val 中的字节数。 |
| octet_length(val: string) → int8 | 计算用于表示 val 的字节数。 |
| octet_length(val: varbit) → int8 | 计算用于表示 val 的字节数。 |
| overlay(input:string,overlay_val: string, start_pos: int8) → string | 使用 overlay_val 替换 input 中的字符，从 start_pos 开始（从 1 开始）。例如，overlay('doggie','CAT',2) 返回 dCATie。 |
| overlay(input:string,overlay_val: string, start_pos: int8, end_pos: int8) → string | 删除 start_pos 和 end_pos 之间 input 中的字符（count 从 1 开始），然后在 start_pos 中写入 overlay_val。 |
| pg_collation_for(str: anyelement) → string | 返回参数的排序规则。 |
| quote_ident(val: string) → string | 返回一个适当的 val 引用值，使其作为 SQL 语句中的标识符。 |
| quote_literal(val: string) → string | 返回一个适当的 val 引用值，使其作为 SQL 语句中的字符串文本。 |
| quote_literal(val: anyelement) → string | 将 val 转换为字符串，然后将其作为文本引用。 |
| quote_nullable(val: string) → string | 将 val 转换为字符串，然后将其作为文本引用。如果 val 为 NULL，则返回 NULL。 |
| quote_nullable(val: anyelement) → string | 将 val 转换为字符串，然后将其作为文本引用。如果 val 为 NULL，则返回 NULL。 |
| regexp_extract(input: string, regex: string) → string | 返回 input 中正则表达式 regex 的第一个匹配项。 |
| regexp_replace(input: string, regex: string, replace: string) → string | 使用 replace 来替换 input 中正则表达式的匹配项。 |
| regexp_replace(input:string, regex: string, replace: string, flags: string) → string | 修改 input 字符串，将其中正则表达式 regex 的匹配项，替换为正则表达式 replace。匹配模式由 flag 参数控制。KWDB 支持以下参数： - -c：区分大小写的匹配 - -g：全局匹配（匹配每个子字符串而不是仅匹配第一个）- -i：不区分大小写的匹配 - -m/n：换行敏感（. 和 ... 匹配换行符：no，\^ 和 $ 匹配线边界：yes）- -p：部分对换行符敏感的匹配（. 和 ... 匹配换行符：no，\^ 和 $ 匹配线边界：yes）- -s：换行不敏感（默认选项，. 和 ... 匹配换行符：no，\^ 和 $ 匹配线边界：yes）- -w：反向部分对换行符敏感的匹配（. 和 ... 匹配换行符：no，\^ 和 $ 匹配线边界：yes） |
| repeat(input: string, repeat_counter: int8) → string | 将 input 进行 repeat_counter 次连接。例如，repeat('dog',2) 返回 dogdog。 |
| replace(input: string, find: string, replace: string) → string | 用 replace 替换 input 中的所有出现的 find。 |
| reverse(val: string) → string | 反转字符串字符的顺序。 |
| right(input: bytes, return_set: int8) → bytes | 从 input 返回最后 return_set 个字节。 |
| right(input: string, return_set: int8) → string | 返回 input 中最后 return_set 个字符。 |
| rpad(string: string, length: int8) → string | 在字符串的右侧添加双引号（""），以填充字符串的长度。如果字符串的长度超过长度，则会被截断。 |
| rpad(string: string, length: int8, fill: string) → string | 在字符串的右侧添加 fill，以填充字符串的长度。如果字符串的长度超过长度，则会被截断。 |
| rtrim(input: string, trim_chars: string) → string | 从输入的末尾（右侧）删除 trim_chars 中包含的任何字符（递归应用）。例如，rtrim('doggie'，'ei') 返回 dogg。 |
| rtrim(val: string) → string | 从 val 的末端（右侧）移除所有空格。 |
| set_bit(bit_string: varbit, index: int8, to_set: int8) → varbit | 设置位数组中的指定位。 |
| set_bit(byte_string: bytes, index: int8, to_set: int8) → bytes | 设置位数组中的指定位。 |
| sha1(bytes...) → string | 计算一组值的 SHA1 哈希值。 |
| sha1(string...) → string | 计算一组值的 SHA1 哈希值。 |
| sha256(bytes...) → string | 计算一组值的 SHA256 哈希值。 |
| sha256(string...) → string | 计算一组值的 SHA256 哈希值。 |
| sha512(bytes...) → string | 计算一组值的 SHA512 哈希值。 |
| sha512(string...) → string | 计算一组值的 SHA512 哈希值。 |
| split_part(input: string, delimiter: string, return_index_pos: int8) → string | 使用 delimiter 分隔符拆分 input 并返回 return_index_pos 位置的值（从 1 开始）。例如，split_part('123.456.789.0','.',3) 返回 789。 |
| strpos(input: string, find: string) → int8 | 计算字符串 find 在输入中开始的位置。例如，strpos('doggie','gie') 返回 4。 |
| substr(input: string, regex: string) → string | 返回与正则表达式 regex 匹配的 input 子字符串。 |
| substr(input: string, regex: string, escape_char: string) → string | 返回与正则表达式 regex 匹配的 input 子字符串，使用 escape_char 作为转义字符而不是作为正则表达式的特殊符号。 |
| substr(input: string, start_pos: int8) → string | 返回 start_pos 和 end_pos 之间的 input 子字符串（从 1 开始计数）。 |
| substr(input: string, start_pos: int8, length: int8) → string | 返回从 substr_pos 开始的 input 子字符串（从 1 开始计数）。 |
| substring(input: string, regex: string) → string | 返回与正则表达式匹配 regex 的 input 子字符串。 |
| substring(input: string, regex: string, escape_char: string) → string | 返回与正则表达式匹配 regex 的 input 子字符串，使用 escape_char 作为转义字符而不是作为正则表达式的特殊符号。 |
| substring(input: string, start_pos: int8) → string | 返回 start_pos 和 end_pos 之间的 input 子字符串（从 1 开始计数）。 |
| substring(input: string, start_pos: int8, length: int8) → string | 返回从 substr_pos 开始的 input 子字符串（从 1 开始计数）。 |
| to_english(val: int8) → string | 用英文表示整数参数的值。 |
| to_hex(val: bytes) → string | 将 val 转换为十六进制表示形式。 |
| to_hex(val: int8) → string | 将 val 转换为十六进制表示形式。 |
| to_hex(val: string) → string | 将 val 转换为十六进制表示形式。 |
| to_ip(val: string) → bytes | 将 IP 的字符串表示形式转换为字节字符串表示形式。 |
| to_uuid(val: string) → bytes | 将 UUID 的字符串表示形式转换为字节字符串表示形式。 |
| translate(input: string, find: string, replace: string) → string | 在输入中，将 find 中的第一个字符替换为 replace 的第一个字符。对查找中的每个字符重复进行。例如，translate('doggie','dog','123'); 返回 1233ie。 |
| upper(val: string) → string | 将 val 中的所有字符转换为大写字母。 |
系统信息函数
| 函数 → 返回值 | 描述 |
|---|---|
| kwdb_internal.encode_key(table_id: int8, index_id: int8, row_tuple: tuple) → bytes | 为特定表和索引上的一行生成键。 |
| kwdb_internal.force_assertion_error(msg: string) → int8 | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.force_error(errorCode: string, msg: string) → int8 | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.force_log_fatal(msg: string) → int8 | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.force_panic(msg: string) → int8 | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.force_retry(val: interval) → int8 | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.get_namespace_id(parent_id: int8, name: string) → int8 | 获取命名空间 ID。 |
| kwdb_internal.get_zone_config(namespace_id: int8) → bytes | 获取区域配置。 |
| kwdb_internal.is_admin() → bool | 获取当前用户的 admin 状态。 |
| kwdb_internal.lease_holder(key: bytes) → int8 | 用于获取与请求密钥相对应的租约持有人。 |
| kwdb_internal.locality_value(key: string) → string | 返回指定位置键的值。 |
| kwdb_internal.no_constant_folding(input: anyelement) → anyelement | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.node_executable_version() → string | 返回此节点正在运行的 KWDB 的版本。 |
| kwdb_internal.notice(msg: string) → int8 | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.num_inverted_index_entries(val: anyelement[]) → int8 | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.num_inverted_index_entries(val: jsonb) → int8 | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.pretty_key(raw_key: bytes, skip_fields: int8) → string | 仅供 KWDB 的开发人员测试使用。 |
| kwdb_internal.range_stats(key: bytes) → jsonb | 用于将范围统计信息作为 JSON 对象检索。 |
| kwdb_internal.round_decimal_values(val: decimal, scale: int8) → decimal | 在内部用于在突变期间舍入十进制值。 |
| kwdb_internal.round_decimal_values(val: decimal[], scale: int8) → decimal[] | 在内部用于在突变期间舍入十进制数组的值。 |
| kwdb_internal.set_vmodule(vmodule_string: string) → int8 | 在处理此请求的网关节点上设置 --vmodule 标志的等效项。它可以控制不同文件的日志记录详细程度。语法范例：kwdb_internal.set_vmodule('recordio = 2,file = 1,gfs * = 3')。重置为：kwdb_internal.set_vmodule（''）。提高详细程度可能会严重影响性能。 |
| current_database() → string | 返回当前数据库。 |
| current_schema() → string | 返回当前 schema。 |
| current_schemas(include_pg_catalog: bool) → string[] | 返回搜索路径中的有效 schema。 |
| current_user() → string | 返回当前用户。该功能为了与 PostgreSQL 兼容。 |
| version() → string | 返回节点的 KWDB 版本。 |
时间函数
| 函数 → 返回值 | 描述 |
|---|---|
| current_time() → time | 返回不带时区的当前事务的时间。 |
| current_time() → timetz | 返回带有时区的当前事务的时间。 |
| current_time(precision: INT8) → time | 返回不带时区的当前事务的时间。 |
| current_time(precision: INT8) → timetz | 返回带有时区的当前事务的时间。 |
| localtime() → time | 返回不带时区的当前事务的时间。 |
| localtime() → timetz | 返回带有时区的当前事务的时间。 |
| localtime(precision: INT8) → time | 返回不带时区的当前事务的时间。 |
| localtime(precision: INT8) → timetz | 返回带有时区的当前事务的时间。 |
元组函数
| 函数 → 返回值 | 描述 |
|---|---|
| row_to_JSON(row: tuple) → jsonb | 以 JSON 对象的形式返回该行。 |
兼容性函数
| 函数 → 返回值 | 描述 |
|---|---|
| format_type(type_oid: oid, typemod: INT8) → STRING | 返回由其类型 OID 和可能的类型修饰符标识的数据类型的 SQL 名称。目前，类型修饰符会被忽略。 |
| getdatabaseencoding() → STRING | 返回数据库使用的编码名称。 |
| has_any_column_privilege(table:STRING, privilege: STRING) → BOOL | 当前用户是否对表的所有列具有权限。 |
| has_any_column_privilege(table: oid, privilege: STRING) → BOOL | 当前用户是否对表的所有列具有权限。 |
| has_any_column_privilege(user: STRING, table: STRING, privilege: STRING) → BOOL | 用户是否对表的所有列具有权限。 |
| has_any_column_privilege(user: STRING, table: oid, privilege: STRING) → BOOL | 用户是否对表的所有列具有权限。 |
| has_any_column_privilege(user: oid, table: STRING, privilege: STRING) → BOOL | 用户是否对表的所有列具有权限。 |
| has_any_column_privilege(user: oid, table: oid, privilege: STRING) → BOOL | 用户是否对表的所有列具有权限。 |
| has_column_privilege(table: STRING, column: INT8, privilege: STRING) → BOOL | 当前用户是否具有列权限。 |
| has_column_privilege(table: STRING, column: STRING, privilege: STRING) → BOOL | 当前用户是否具有列权限。 |
| has_column_privilege(table: oid, column: INT8, privilege: STRING) → BOOL | 当前用户是否具有列权限。 |
| has_column_privilege(table: oid, column: STRING, privilege: STRING) → BOOL | 当前用户是否具有列权限。 |
| has_column_privilege(user: STRING, table: STRING, column: INT8, privilege: STRING) → BOOL | 用户是否具有列权限。 |
| has_column_privilege(user: STRING, table: STRING, column: STRING, privilege: STRING) → BOOL | 用户是否具有列权限。 |
| has_column_privilege(user: STRING, table: oid, column: INT8, privilege: STRING) → BOOL | 用户是否具有列权限。 |
| has_column_privilege(user: STRING, table: oid, column: STRING, privilege: STRING) → BOOL | 用户是否具有列权限。 |
| has_column_privilege(user: oid, table: STRING, column: INT8, privilege: STRING) → BOOL | 用户是否具有列权限。 |
| has_column_privilege(user: oid, table: STRING, column: STRING, privilege: STRING) → BOOL | 用户是否具有列权限。 |
| has_column_privilege(user: oid, table: oid, column: INT8, privilege: STRING) → BOOL | 用户是否具有列权限。 |
| has_column_privilege(user: oid,table:oid, column: STRING, privilege: STRING) → BOOL | 用户是否具有列权限。 |
| has_database_privilege(database:STRING, privilege: STRING) → BOOL | 当前用户是否拥有数据库权限。 |
| has_database_privilege(database: oid, privilege: STRING) → BOOL | 当前用户是否拥有数据库权限。 |
| has_database_privilege(user: STRING, database: STRING, privilege: STRING) → BOOL | 用户是否拥有数据库权限。 |
| has_database_privilege(user: STRING, database: oid, privilege: STRING) → BOOL | 用户是否拥有数据库权限。 |
| has_database_privilege(user: oid, database: STRING, privilege: STRING) → BOOL | 用户是否拥有数据库权限。 |
| has_database_privilege(user: oid, database: oid, privilege: STRING) → BOOL | 用户是否拥有数据库权限。 |
| has_foreign_data_wrapper_privilege(fdw: STRING, privilege: STRING) → BOOL | 当前用户是否拥有外部数据包装程序权限。 |
| has_foreign_data_wrapper_privilege(fdw: oid, privilege: STRING) → BOOL | 当前用户是否拥有外部数据包装程序权限。 |
| has_foreign_data_wrapper_privilege(user: STRING, fdw: STRING, privilege: STRING) → BOOL | 用户是否拥有外部数据包装程序权限。 |
| has_foreign_data_wrapper_privilege(user: STRING, fdw: oid, privilege: STRING) → BOOL | 用户是否拥有外部数据包装程序权限。 |
| has_foreign_data_wrapper_privilege(user: oid, fdw: STRING, privilege: STRING) → BOOL | 用户是否拥有外部数据包装程序权限。 |
| has_foreign_data_wrapper_privilege(user: oid, fdw: oid, privilege: STRING) → BOOL | 用户是否拥有外部数据包装程序权限。 |
| has_function_privilege(function: STRING, privilege: STRING) → BOOL | 当前用户是否拥有函数权限。 |
| has_function_privilege(function: oid, privilege: STRING) → BOOL | 当前用户是否拥有函数权限。 |
| has_function_privilege(user: STRING, function: STRING, privilege: STRING) → BOOL | 用户是否拥有函数权限。 |
| has_function_privilege(user: STRING, function: oid, privilege: STRING) → BOOL | 用户是否拥有函数权限。 |
| has_function_privilege(user: oid, function: STRING, privilege: STRING) → BOOL | 用户是否拥有函数权限。 |
| has_function_privilege(user: oid, function: oid, privilege: STRING) → BOOL | 用户是否拥有函数权限。 |
| has_language_privilege(language: STRING, privilege: STRING) → BOOL | 当前用户是否拥有语言权限。 |
| has_language_privilege(language: oid, privilege: STRING) → BOOL | 当前用户是否拥有语言权限。 |
| has_language_privilege(user: STRING, language: STRING, privilege: STRING) → BOOL | 用户是否拥有语言权限。 |
| has_language_privilege(user: STRING, language: oid, privilege: STRING) → BOOL | 用户是否拥有语言权限。 |
| has_language_privilege(user: oid, language: STRING, privilege: STRING) → BOOL | 用户是否拥有语言权限。 |
| has_language_privilege(user: oid, language: oid, privilege: STRING) → BOOL | 用户是否拥有语言权限。 |
| has_schema_privilege(schema: STRING, privilege: STRING) → BOOL | 当前用户是否拥有 schema 权限。 |
| has_schema_privilege(schema: oid, privilege: STRING) → BOOL | 当前用户是否拥有 schema 权限。 |
| has_schema_privilege(user: STRING, schema: STRING, privilege: STRING) → BOOL | 用户是否拥有 schema 权限。 |
| has_schema_privilege(user: STRING, schema: oid, privilege: STRING) → BOOL | 用户是否拥有 schema 权限。 |
| has_schema_privilege(user: oid, schema: STRING, privilege: STRING) → BOOL | 用户是否拥有 schema 权限。 |
| has_schema_privilege(user: oid, schema: oid, privilege: STRING) → BOOL | 用户是否拥有 schema 权限。 |
| has_sequence_privilege(sequence: STRING, privilege: STRING) → BOOL | 当前用户是否拥有序列权限。 |
| has_sequence_privilege(sequence: oid, privilege: STRING) → BOOL | 当前用户是否拥有序列权限。 |
| has_sequence_privilege(user: STRING, sequence: STRING, privilege: STRING) → BOOL | 用户是否拥有序列权限。 |
| has_sequence_privilege(user: STRING, sequence: oid, privilege: STRING) → BOOL | 用户是否拥有序列权限。 |
| has_sequence_privilege(user: oid, sequence: STRING, privilege: STRING) → BOOL | 用户是否拥有序列权限。 |
| has_sequence_privilege(user: oid, sequence: oid, privilege: STRING) → BOOL | 用户是否拥有序列权限。 |
| has_server_privilege(server: STRING, privilege: STRING) → BOOL | 当前用户是否拥有外部服务器的权限。 |
| has_server_privilege(server: oid, privilege: STRING) → BOOL | 当前用户是否拥有外部服务器的权限。 |
| has_server_privilege(user: STRING, server: STRING, privilege: STRING) → BOOL | 用户是否拥有外部服务器的权限。 |
| has_server_privilege(user: STRING, server: oid, privilege: STRING) → BOOL | 用户是否拥有外部服务器的权限。 |
| has_server_privilege(user: oid, server: STRING, privilege: STRING) → BOOL | 用户是否拥有外部服务器的权限。 |
| has_server_privilege(user: oid, server: oid, privilege: STRING) → BOOL | 用户是否拥有外部服务器的权限。 |
| has_table_privilege(table: STRING, privilege: STRING) → BOOL | 当前用户是否拥有表的权限。 |
| has_table_privilege(table: oid, privilege: STRING) → BOOL | 当前用户是否拥有表的权限。 |
| has_table_privilege(user:STRING,table:STRING,privilege: STRING) → BOOL | 用户是否拥有表的权限。 |
| has_table_privilege(user: STRING, table: oid, privilege: STRING) → BOOL | 用户是否拥有表的权限。 |
| has_table_privilege(user: oid, table: STRING, privilege: STRING) → BOOL | 用户是否拥有表的权限。 |
| has_table_privilege(user: oid, table: oid, privilege: STRING) → BOOL | 用户是否拥有表的权限。 |
| has_tablespace_privilege(tablespace:STRING,privilege: STRING) → BOOL | 当前用户是否拥有表空间的权限。 |
| has_tablespace_privilege(tablespace: oid, privilege: STRING) → BOOL | 当前用户是否拥有表空间的权限。 |
| has_tablespace_privilege(user: STRING, tablespace: STRING, privilege: STRING) → BOOL | 用户是否拥有表空间的权限。 |
| has_tablespace_privilege(user: STRING, tablespace: oid, privilege: STRING) → BOOL | 用户是否拥有表空间的权限。 |
| has_tablespace_privilege(user: oid, tablespace: STRING, privilege: STRING) → BOOL | 用户是否拥有表空间的权限。 |
| has_tablespace_privilege(user: oid, tablespace: oid, privilege: STRING) → BOOL | 用户是否拥有表空间的权限。 |
| has_type_privilege(type: STRING, privilege: STRING) → BOOL | 当前用户是否拥有类型的权限。 |
| has_type_privilege(type: oid, privilege: STRING) → BOOL | 当前用户是否拥有类型的权限。 |
| has_type_privilege(user:STRING,type: STRING, privilege: STRING) → BOOL | 用户是否拥有类型的权限。 |
| has_type_privilege(user: STRING, type: oid, privilege: STRING) → BOOL | 用户是否拥有类型的权限。 |
| has_type_privilege(user: oid, type: STRING, privilege: STRING) → BOOL | 用户是否拥有类型的权限。 |
| has_type_privilege(user: oid, type: oid, privilege: STRING) → BOOL | 用户是否拥有类型的权限。 |
| oid(arg1: INT2) → oid | 将整数转换为 OID。 |
| oid(arg1: INT4) → oid | 将整数转换为 OID。 |
| oid(arg1: INT8) → oid | 将整数转换为 OID。 |
| pg_sleep(seconds: FLOAT4) → BOOL | 使当前会话的进程在接下来指定的秒数内进入休眠状态。参数 seconds 是双精度浮点数，允许指定小数级别的秒数延迟。 |
| pg_sleep(seconds: FLOAT8) → BOOL | 使当前会话的进程在接下来指定的秒数内进入休眠状态。参数 seconds 是双精度浮点数，允许指定小数级别的秒数延迟。 |
聚合函数
说明
- 避免
AVG、SUM函数的计算结果超过函数支持的最大范围。 - 聚合查询与
GROUP BY连用时，避免GROUP BY后的结果集行数过大。
| 函数 → 返回值 | 描述 |
|---|---|
| array_agg(arg1: BOOL) → BOOL[] | 将选定值聚合到数组中。 |
| array_agg(arg1: bytes) → bytes[] | 将选定值聚合到数组中。 |
| array_agg(arg1: date) → date[] | 将选定值聚合到数组中。 |
| array_agg(arg1: decimal) →decimal[] | 将选定值聚合到数组中。 |
| array_agg(arg1: FLOAT4) → FLOAT4[] | 将选定值聚合到数组中。 |
| array_agg(arg1: FLOAT8) → FLOAT8[] | 将选定值聚合到数组中。 |
| array_agg(arg1: INET) → INET[] | 将选定值聚合到数组中。 |
| array_agg(arg1: INT2) → INT2[] | 将选定值聚合到数组中。 |
| array_agg(arg1: INT4) → INT4[] | 将选定值聚合到数组中。 |
| array_agg(arg1: INT8) → INT8[] | 将选定值聚合到数组中。 |
| array_agg(arg1: interval) → interval[] | 将选定值聚合到数组中。 |
| array_agg(arg1: STRING) → STRING[] | 将选定值聚合到数组中。 |
| array_agg(arg1: time) → time[] | 将选定值聚合到数组中。 |
| array_agg(arg1: timestamp) → timestamp[] | 将选定值聚合到数组中。 |
| array_agg(arg1: timestamptz) → timestamptz[] | 将选定值聚合到数组中。 |
| array_agg(arg1: UUID) → UUID[] | 将选定值聚合到数组中。 |
| array_agg(arg1: oid) → oid[] | 将选定值聚合到数组中。 |
| array_agg(arg1: timetz) → timetz[] | 将选定值聚合到数组中。 |
| array_agg(arg1: varbit) → varbit[] | 将选定值聚合到数组中。 |
| avg(arg1: decimal) → decimal | 计算选定值的平均值。 |
| avg(arg1: float4) → float8 | 计算选定值的平均值。 |
| avg(arg1: float8) → float8 | 计算选定值的平均值。 |
| avg(arg1: INT2) → DECIMAL | 计算选定值的平均值。 |
| avg(arg1: INT4) → DECIMAL | 计算选定值的平均值。 |
| avg(arg1: INT8) → DECIMAL | 计算选定值的平均值。 |
| avg(arg1: interval) → interval | 计算选定值的平均值。 |
| bit_and(arg1: int2) → int8 | 计算所有非空输入值的按位“与”操作结果，如果没有，则为 null。 |
| bit_and(arg1: int4) → int8 | 计算所有非空输入值的按位“与”操作结果，如果没有，则为 null。 |
| bit_and(arg1: int8) → int8 | 计算所有非空输入值的按位“与”操作结果，如果没有，则为 null。 |
| bit_or(arg1: int2) → int8 | 计算所有非空输入值的按位“或”操作结果，如果没有，则为 null。 |
| bit_or(arg1: int4) → int8 | 计算所有非空输入值的按位“或”操作结果，如果没有，则为 null。 |
| bit_or(arg1: int8) → int8 | 计算所有非空输入值的按位“或”操作结果，如果没有，则为 null。 |
| BOOL_and(arg1: BOOL) → BOOL | 计算集合中所有 BOOL 值的“与”操作的结果。 |
| BOOL_or(arg1: BOOL) → BOOL | 计算集合中所有 BOOL 值的“或”操作的结果。 |
| concat_agg(arg1: bytes) → bytes | 连接所有选定值。 |
| concat_agg(arg1: STRING) → STRING | 连接所有选定值。 |
| corr(arg1: FLOAT4, arg2: FLOAT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: FLOAT4, arg2: FLOAT8) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: FLOAT8, arg2: FLOAT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: FLOAT8, arg2: FLOAT8) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: FLOAT4, arg2: INT2) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: FLOAT4, arg2: INT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: FLOAT4, arg2: INT8) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: FLOAT8, arg2: INT2) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: FLOAT8, arg2: INT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: FLOAT8, arg2: INT8) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT2, arg2: FLOAT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT2, arg2: FLOAT8) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT4, arg2: FLOAT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT4, arg2: FLOAT8) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT8, arg2: FLOAT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT8, arg2: FLOAT8) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT2, arg2: INT2) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT2, arg2: INT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT2, arg2: INT8) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT4, arg2: INT2) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT4, arg2: INT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT4, arg2: INT8) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT8, arg2: INT2) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT8, arg2: INT4) → FLOAT8 | 计算所选值的相关系数。 |
| corr(arg1: INT8, arg2: INT8) → FLOAT8 | 计算所选值的相关系数。 |
| count(arg1: anyelement) → INT8 | 计算选定元素的数目。 |
| count_rows() → INT8 | 计算行数。 |
| every(arg1: BOOL) → BOOL | 计算所有选定值的“与”操作的布尔值结果。 |
| JSON_agg(arg1: anyelement) → jsonb | 将值聚合为 JSON 或 jsonb 数组。 |
| jsonb_agg(arg1: anyelement) → jsonb | 将值聚合为 JSON 或 jsonb 数组。 |
| MAX(arg1: BOOL) → BOOL | 标识选定的最大值。 |
| MAX(arg1: bytes) → bytes | 标识选定的最大值。 |
| MAX(arg1: date) → date | 标识选定的最大值。 |
| MAX(arg1: decimal) → decimal | 标识选定的最大值。 |
| MAX(arg1: FLOAT4) → FLOAT4 | 标识选定的最大值。 |
| MAX(arg1: FLOAT8) → FLOAT8 | 标识选定的最大值。 |
| MAX(arg1: INET) → INET | 标识选定的最大值。 |
| MAX(arg1: INT2) → INT2 | 标识选定的最大值。 |
| MAX(arg1: INT4) → INT4 | 标识选定的最大值。 |
| MAX(arg1: INT8) → INT8 | 标识选定的最大值。 |
| MAX(arg1: interval) → interval | 标识选定的最大值。 |
| MAX(arg1: STRING) → STRING | 标识选定的最大值。 |
| MAX(arg1: time) → time | 标识选定的最大值。 |
| MAX(arg1: timestamp) → timestamp | 标识选定的最大值。 |
| MAX(arg1: timestamptz) → timestamptz | 标识选定的最大值。 |
| MAX(arg1: UUID) → UUID | 标识选定的最大值。 |
| MAX(arg1: jsonb) → jsonb | 标识选定的最大值。 |
| MAX(arg1: oid) → oid | 标识选定的最大值。 |
| MAX(arg1: timetz) → timetz | 标识选定的最大值。 |
| MAX(arg1: varbit) → varbit | 标识选定的最大值。 |
| min(arg1: BOOL) → BOOL | 标识选定的最小值。 |
| min(arg1: bytes) → bytes | 标识选定的最小值。 |
| min(arg1: date) → date | 标识选定的最小值。 |
| min(arg1: decimal) → decimal | 标识选定的最小值。 |
| min(arg1: FLOAT4) → FLOAT4 | 标识选定的最小值。 |
| min(arg1: FLOAT8) → FLOAT8 | 标识选定的最小值。 |
| min(arg1: INET) → INET | 标识选定的最小值。 |
| min(arg1: INT2) → INT2 | 标识选定的最小值。 |
| min(arg1: INT4) → INT4 | 标识选定的最小值。 |
| min(arg1: INT8) → INT8 | 标识选定的最小值。 |
| min(arg1: interval) → interval | 标识选定的最小值。 |
| min(arg1: STRING) → STRING | 标识选定的最小值。 |
| min(arg1: time) → time | 标识选定的最小值。 |
| min(arg1: timestamp) → timestamp | 标识选定的最小值。 |
| min(arg1: timestamptz) → timestamptz | 标识选定的最小值。 |
| min(arg1: UUID) → UUID | 标识选定的最小值。 |
| min(arg1: jsonb) → jsonb | 标识选定的最小值。 |
| min(arg1: oid) → oid | 标识选定的最小值。 |
| min(arg1: timetz) → timetz | 标识选定的最小值。 |
| min(arg1: varbit) → varbit | 标识选定的最小值。 |
| sqrdiff(arg1: decimal) → decimal | 计算所选值平均值的平方差之和。 |
| sqrdiff(arg1: FLOAT4) → FLOAT8 | 计算所选值平均值的平方差之和。 |
| sqrdiff(arg1: FLOAT8) → FLOAT8 | 计算所选值平均值的平方差之和。 |
| sqrdiff(arg1: INT2) → decimal | 计算所选值平均值的平方差之和。 |
| sqrdiff(arg1: INT4) → decimal | 计算所选值平均值的平方差之和。 |
| sqrdiff(arg1: INT8) → decimal | 计算所选值平均值的平方差之和。 |
| stddev(arg1: decimal) → decimal | 计算选定值的标准偏差。 |
| stddev(arg1: FLOAT4) → FLOAT8 | 计算选定值的标准偏差。 |
| stddev(arg1: FLOAT8) → FLOAT8 | 计算选定值的标准偏差。 |
| stddev(arg1: INT2) → decimal | 计算选定值的标准偏差。 |
| stddev(arg1: INT4) → decimal | 计算选定值的标准偏差。 |
| stddev(arg1: INT8) → decimal | 计算选定值的标准偏差。 |
| stddev_samp(arg1: decimal) → decimal | 计算所选值的标准偏差。 |
| stddev_samp(arg1: FLOAT4) → FLOAT8 | 计算所选值的标准偏差。 |
| stddev_samp(arg1: FLOAT8) → FLOAT8 | 计算所选值的标准偏差。 |
| stddev_samp(arg1: INT2) → decimal | 计算所选值的标准偏差。 |
| stddev_samp(arg1: INT4) → decimal | 计算所选值的标准偏差。 |
| stddev_samp(arg1: INT8) → decimal | 计算所选值的标准偏差。 |
| STRING_agg(arg1: bytes, arg2: bytes) → bytes | 使用提供的分隔符连接所有选定值。 |
| STRING_agg(arg1: STRING, arg2: STRING) → STRING | 使用提供的分隔符连接所有选定值。 |
| SUM(arg1: decimal) → decimal | 计算选定值的总和。 |
| SUM(arg1: FLOAT4) → FLOAT8 | 计算选定值的总和。 |
| SUM(arg1: FLOAT8) → FLOAT8 | 计算选定值的总和。 |
| SUM(arg1: INT2) → decimal | 计算选定值的总和。 |
| SUM(arg1: INT4) → decimal | 计算选定值的总和。 |
| SUM(arg1: INT8) → decimal | 计算选定值的总和。 |
| SUM(arg1: interval) → interval | 计算选定值的总和。 |
| SUM_INT(arg1: INT2) → INT8 | 计算选定值的总和。 |
| SUM_INT(arg1: INT4) → INT8 | 计算选定值的总和。 |
| SUM_INT(arg1: INT8) → INT8 | 计算选定值的总和。 |
| variance(arg1: decimal) → decimal | 计算选定值的方差。 |
| variance(arg1: FLOAT4) → FLOAT8 | 计算选定值的方差。 |
| variance(arg1: FLOAT8) → FLOAT8 | 计算选定值的方差。 |
| variance(arg1: INT2) → decimal | 计算选定值的方差。 |
| variance(arg1: INT4) → decimal | 计算选定值的方差。 |
| variance(arg1: INT8) → decimal | 计算选定值的方差。 |
| xor_agg(arg1: bytes) → bytes | 计算选定值的按位异或。 |
| xor_agg(arg1: INT2) → INT8 | 计算选定值的按位异或。 |
| xor_agg(arg1: INT4) → INT8 | 计算选定值的按位异或。 |
| xor_agg(arg1: INT8) → INT8 | 计算选定值的按位异或。 |
| matching(val: INT2, excludeRule: INT8, lowerBound: decimal, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。参数说明：- excludeRule：条件判断时是否包含上限、下限。取值 0（均包含）、1（只包含上限）、2（只包含下限）、3（均不包含） - percentage：百分比。若预设百分比为 90%，则该项填入 90。 |
| matching(val: INT4, excludeRule: INT8, lowerBound: decimal, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。参数说明：- excludeRule：条件判断时是否包含上限、下限。取值 0（均包含）、1（只包含上限）、2（只包含下限）、3（均不包含） - percentage：百分比。若预设百分比为 90%，则该项填入 90。 |
| matching(val: INT8, excludeRule: INT8, lowerBound: decimal, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。参数说明：- excludeRule：条件判断时是否包含上限、下限。取值 0（均包含）、1（只包含上限）、2（只包含下限）、3（均不包含） - percentage：百分比。若预设百分比为 90%，则该项填入 90。 |
| matching(val: FLOAT4, excludeRule: INT8, lowerBound: decimal, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: FLOAT8, excludeRule: INT8, lowerBound: decimal, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: decimal, excludeRule: INT8, lowerBound: decimal, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: INT2, excludeRule: INT8, lowerBound: STRING, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: INT4, excludeRule: INT8, lowerBound: STRING, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: INT8, excludeRule: INT8, lowerBound: STRING, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: FLOAT4, excludeRule: INT8, lowerBound: STRING, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: FLOAT8, excludeRule: INT8, lowerBound: STRING, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: decimal, excludeRule: INT8, lowerBound: STRING, upperBound: decimal, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: INT2, excludeRule: INT8, lowerBound: decimal, upperBound: STRING, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: INT4, excludeRule: INT8, lowerBound: decimal, upperBound: STRING, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: INT8, excludeRule: INT8, lowerBound: decimal, upperBound: STRING, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: FLOAT4, excludeRule: INT8, lowerBound: decimal, upperBound: STRING, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: FLOAT8, excludeRule: INT8, lowerBound: decimal, upperBound: STRING, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| matching(val: decimal, excludeRule: INT8, lowerBound: decimal, upperBound: STRING, percentage: INT8) → BOOL | 满足条件的值的数量与总数量的比值大于预先设定的百分比，返回 true，否则返回 false。 |
| interpolate(method, mode) | 补值函数，需要与 time_bucket_gapfill() 配合使用，补值结果类型与原始值类型一致。参数说明：- method：补值算法，只支持聚合函数，且数据类型为数字。 - mode：补值模式，取值包括 constant（常量值）、prev（前值）、next（后值）、linear（线性）、null（null）。 |
窗口函数
| 函数 → 返回值 | 描述 |
|---|---|
| cume_dist() → FLOAT8 | 计算当前行的相对秩：（当前行前面或与当前行对等的行数）/（总行数）。 |
| dense_rank() → INT8 | 计算当前行的秩（不带间隙）。此函数计算对等组。 |
| first_value(val: BOOL) → BOOL | 返回在窗口的第一行处计算的值。 |
| first_value(val: bytes) → bytes | 返回在窗口的第一行处计算的值。 |
| first_value(val: date) → date | 返回在窗口的第一行处计算的值。 |
| first_value(val: decimal) → decimal | 返回在窗口的第一行处计算的值。 |
| first_value(val: FLOAT4) → FLOAT4 | 返回在窗口的第一行处计算的值。 |
| first_value(val: FLOAT8) → FLOAT8 | 返回在窗口的第一行处计算的值。 |
| first_value(val: INET) → INET | 返回在窗口的第一行处计算的值。 |
| first_value(val: INT2) → INT2 | 返回在窗口的第一行处计算的值。 |
| first_value(val: INT4) → INT4 | 返回在窗口的第一行处计算的值。 |
| first_value(val: INT8) → INT8 | 返回在窗口的第一行处计算的值。 |
| first_value(val: interval) → interval | 返回在窗口的第一行处计算的值。 |
| first_value(val: STRING) → STRING | 返回在窗口的第一行处计算的值。 |
| first_value(val: time) → time | 返回在窗口的第一行处计算的值。 |
| first_value(val: timestamp) → timestamp | 返回在窗口的第一行处计算的值。 |
| first_value(val: timestamptz) → timestamptz | 返回在窗口的第一行处计算的值。 |
| first_value(val: UUID) → UUID | 返回在窗口的第一行处计算的值。 |
| first_value(val: jsonb) → jsonb | 返回在窗口的第一行处计算的值。 |
| first_value(val: oid) → oid | 返回在窗口的第一行处计算的值。 |
| first_value(val: timetz) → timetz | 返回在窗口的第一行处计算的值。 |
| first_value(val: varbit) → varbit | 返回在窗口的第一行处计算的值。 |
| lag(val: BOOL) → BOOL | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: BOOL, n: INT8) → BOOL | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: BOOL, n: INT8, default: BOOL) → BOOL | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: bytes) → bytes | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: bytes, n: INT8) → bytes | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: bytes, n: INT8, default: bytes) → bytes | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: date) → date | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: date, n: INT8) → date | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: date, n: INT8, default: date) → date | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: decimal) → decimal | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: decimal, n: INT8) → decimal | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: decimal, n: INT8, default: decimal) → decimal | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: FLOAT4) → FLOAT8 | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: FLOAT8) → FLOAT8 | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: FLOAT4, n: INT8) → FLOAT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: FLOAT8, n: INT8) → FLOAT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: FLOAT4, n: INT8, default: FLOAT4) → FLOAT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: FLOAT8, n: INT8, default: FLOAT8) → FLOAT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: INET) → INET | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: INET, n: INT8) → INET | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: INET, n: INT8, default: INET) → INET | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: INT2) → INT8 | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: INT4) → INT8 | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: INT8) → INT8 | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: INT2, n: INT8) → INT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: INT4, n: INT8) → INT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: INT8, n: INT8) → INT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: INT2, n: INT8, default: INT2) → INT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: INT4, n: INT8, default: INT4) → INT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: INT8, n: INT8, default: INT8) → INT8 | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: interval) → interval | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: interval, n: INT8) → interval | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: interval, n: INT8, default: interval) → interval | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: STRING) → STRING | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: STRING, n: INT8) → STRING | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: STRING, n: INT8, default: STRING) → STRING | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: time) → time | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: time, n: INT8) → time | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: time, n: INT8, default: time) → time | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: timestamp) → timestamp | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: timestamp, n: INT8) → timestamp | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: timestamp, n: INT8, default: timestamp) → timestamp | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: timestamptz) → timestamptz | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: timestamptz, n: INT8) → timestamptz | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: timestamptz, n: INT8, default: timestamptz) → timestamptz | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: UUID) → UUID | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: UUID, n: INT8) → UUID | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: UUID, n: INT8, default: UUID) → UUID | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: jsonb) → jsonb | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: jsonb, n: INT8) → jsonb | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: jsonb, n: INT8, default: jsonb) → jsonb | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: oid) → oid | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: oid, n: INT8) → oid | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: oid, n: INT8, default: oid) → oid | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: timetz) → timetz | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: timetz, n: INT8) → timetz | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: timetz, n: INT8, default: timetz) → timetz | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lag(val: varbit) → varbit | 返回在当前行的分区中的前一行计算的 val。如果没有这样的行，则返回 null。 |
| lag(val: varbit, n: INT8) → varbit | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lag(val: varbit, n: INT8, default: varbit) → varbit | 返回在其分区内当前行之前 n 行的行上计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| last_value(val: BOOL) → BOOL | 返回在窗口内的最后一行计算的值。 |
| last_value(val: bytes) → bytes | 返回在窗口内的最后一行计算的值。 |
| last_value(val: date) → date | 返回在窗口内的最后一行计算的值。 |
| last_value(val: decimal) → decimal | 返回在窗口内的最后一行计算的值。 |
| last_value(val: FLOAT4) → FLOAT4 | 返回在窗口内的最后一行计算的值。 |
| last_value(val: FLOAT8) → FLOAT8 | 返回在窗口内的最后一行计算的值。 |
| last_value(val: INET) → INET | 返回在窗口内的最后一行计算的值。 |
| last_value(val: INT2) → INT2 | 返回在窗口内的最后一行计算的值。 |
| last_value(val: INT4) → INT4 | 返回在窗口内的最后一行计算的值。 |
| last_value(val: INT8) → INT8 | 返回在窗口内的最后一行计算的值。 |
| last_value(val: interval) → interval | 返回在窗口内的最后一行计算的值。 |
| last_value(val: STRING) → STRING | 返回在窗口内的最后一行计算的值。 |
| last_value(val: time) → time | 返回在窗口内的最后一行计算的值。 |
| last_value(val: timestamp) → timestamp | 返回在窗口内的最后一行计算的值。 |
| last_value(val: timestamptz) → timestamptz | 返回在窗口内的最后一行计算的值。 |
| last_value(val: UUID) → UUID | 返回在窗口内的最后一行计算的值。 |
| last_value(val: jsonb) → jsonb | 返回在窗口内的最后一行计算的值。 |
| last_value(val: oid) → oid | 返回在窗口内的最后一行计算的值。 |
| last_value(val: timetz) → timetz | 返回在窗口内的最后一行计算的值。 |
| last_value(val: varbit) → varbit | 返回在窗口内的最后一行计算的值。 |
| lead(val: BOOL) → BOOL | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: BOOL, n: INT8) → BOOL | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: BOOL, n: INT8, default: BOOL) → BOOL | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: bytes) → bytes | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: bytes, n: INT8) → bytes | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: bytes, n: INT8, default: bytes) → bytes | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: date) → date | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: date, n: INT8) → date | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: date, n: INT8, default: date) → date | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: decimal) → decimal | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: decimal, n: INT8) → decimal | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: decimal, n: INT8, default: decimal) → decimal | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: FLOAT4) → FLOAT8 | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: FLOAT8) → FLOAT8 | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: FLOAT4, n: INT8) → FLOAT8 | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: FLOAT8, n: INT8) → FLOAT8 | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: FLOAT4, n: INT8, default: FLOAT4) → FLOAT8 | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: FLOAT8, n: INT8, default: FLOAT8) → FLOAT8 | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: INET) → INET | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: INET, n: INT8) → INET | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: INET, n: INT8, default: INET) → INET | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: INT2) → INT8 | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: INT4) → INT8 | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: INT8) → INT8 | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: INT2, n: INT8) → INT8 | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: INT4, n: INT8) → INT8 | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: INT8, n: INT8) → INT8 | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: INT2, n: INT8, default: INT2) → INT8 | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: INT4, n: INT8, default: INT4) → INT8 | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: INT8, n: INT8, default: INT8) → INT8 | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: interval) → interval | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: interval, n: INT8) → interval | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: interval, n: INT8, default: interval) → interval | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: STRING) → STRING | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: STRING, n: INT8) → STRING | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: STRING, n: INT8, default: STRING) → STRING | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: time) → time | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: time, n: INT8) → time | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: time, n: INT8, default: time) → time | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: timestamp) → timestamp | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: timestamp, n: INT8) → timestamp | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: timestamp, n: INT8, default: timestamp) → timestamp | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: timestamptz) → timestamptz | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: timestamptz, n: INT8) → timestamptz | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: timestamptz, n: INT8, default: timestamptz) → timestamptz | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: UUID) → UUID | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: UUID, n: INT8) → UUID | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: UUID, n: INT8, default: UUID) → UUID | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: jsonb) → jsonb | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: jsonb, n: INT8) → jsonb | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: jsonb, n: INT8, default: jsonb) → jsonb | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: oid) → oid | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: oid, n: INT8) → oid | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: oid, n: INT8, default: oid) → oid | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: timetz) → timetz | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: timetz, n: INT8) → timetz | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: timetz, n: INT8, default: timetz) → timetz | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| lead(val: varbit) → varbit | 返回在当前行分区内的下一行计算的 val。如果没有这样的行，则返回 null。 |
| lead(val: varbit, n: INT8) → varbit | 返回在其分区内当前行后面 n 行的行上计算的 val。如果没有这样的行，则返回空值。n 是针对当前行计算的。 |
| lead(val: varbit, n: INT8, default: varbit) → varbit | 返回在其分区内当前行后面 n 行处计算的 val。如果没有，则返回默认值（必须与 val 类型相同）。n 和 default 都是根据当前行计算的。 |
| nth_value(val: BOOL, n: INT8) → BOOL | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: bytes, n: INT8) → bytes | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: date, n: INT8) → date | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: decimal, n: INT8) → decimal | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: FLOAT4, n: INT8) → FLOAT8 | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: FLOAT8, n: INT8) → FLOAT8 | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: INET, n: INT8) → INET | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: INT2, n: INT8) → INT8 | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: INT4, n: INT8) → INT8 | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: INT8, n: INT8) → INT8 | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: interval, n: INT8) → interval | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: STRING, n: INT8) → STRING | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: time, n: INT8) → time | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: timestamp, n: INT8) → timestamp | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: timestamptz, n: INT8) → timestamptz | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: UUID, n: INT8) → UUID | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: jsonb, n: INT8) → jsonb | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: oid, n: INT8) → oid | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: timetz, n: INT8) → timetz | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| nth_value(val: varbit, n: INT8) → varbit | 返回在窗口内的第 n 行（从 1 开始计算）处计算的 val。如果没有这样的行，则返回 null。 |
| ntile(n: INT2) → INT8 | 计算一个从 1 到 n 的整数，将分区尽可能等分。 |
| ntile(n: INT4) → INT8 | 计算一个从 1 到 n 的整数，将分区尽可能等分。 |
| ntile(n: INT8) → INT8 | 计算一个从 1 到 n 的整数，将分区尽可能等分。 |
| percent_rank() → FLOAT8 | 计算当前行的相对秩：（秩 -1）/（总行数 -1）。 |
| rank() → INT8 | 计算具有间隙的当前行的秩与第一个对等行的行数相同。 |
| row_number() → INT8 | 计算其分区内当前行的数目，从 1 开始计算。 |