函数
AIR 数据虚拟化引擎支持以下内置函数。本文按函数类别列出全部支持的函数签名、返回类型、功能说明和使用示例。
阅读说明
- 函数名称不区分大小写，本文统一以小写名称展示。
- 同名函数可能列出多行，分别表示不同的参数重载。
- 示例中
--后的内容表示预期结果。 same as input表示返回类型与输入类型相同，any表示可接受任意适用类型。
函数分类
| 分类 | 函数数量 | 签名数量 |
|---|---|---|
| 聚合函数 | 19 | 19 |
| 字符串函数 | 47 | 54 |
| 日期与时间函数 | 38 | 40 |
| 数组函数 | 19 | 19 |
| 数学函数 | 32 | 35 |
| 窗口函数 | 9 | 13 |
| 近似计算函数 | 1 | 1 |
| 位运算函数 | 8 | 8 |
| 条件函数 | 6 | 6 |
| JSON 函数 | 9 | 9 |
| 正则表达式函数 | 4 | 4 |
| 类型转换函数 | 2 | 2 |
| 系统函数 | 2 | 2 |
共收录 196 个函数、212 个函数签名。
聚合函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
arbitrary |
ARBITRARY(x) |
same as input |
返回 x 的任意非空值（如果存在）。 | SELECT ARBITRARY(10) -- 10 |
avg |
AVG(x) |
double |
返回所有非 NULL 输入值的算术平均值；NULL 不参与总和与计数。 | SELECT AVG(x) FROM (VALUES 1, 2, 3) AS t(x) -- 2.0 |
grouping |
GROUPING(column...) |
bigint |
为 GROUPING SETS、ROLLUP 或 CUBE 的参数生成位掩码；当前分组中保留的列对应 0，被汇总的列对应 1，最右侧参数是最低位。 | SELECT x, GROUPING(x) FROM (VALUES 1) AS t(x) GROUP BY ROLLUP(x) ORDER BY GROUPING(x) -- (1, 0), (NULL, 1) |
count |
COUNT(x) |
bigint |
返回 x 的非 NULL 输入值数量；COUNT(*) 才统计所有输入行。 | SELECT COUNT(x) FROM (VALUES 1, NULL, 3) AS t(x) -- 2 |
max |
MAX(x) |
same as input |
返回 x 中的最大值。 | SELECT MAX(12) -- 12 |
min |
MIN(x) |
same as input |
返回 x 中的最小值。 | SELECT MIN(10) -- 10 |
sum |
SUM(x) |
numeric |
返回所有非 NULL 输入值之和；没有输入行或全部为 NULL 时返回 NULL。 | SELECT SUM(x) FROM (VALUES 1, 2, 3) AS t(x) -- 6 |
stddev |
STDDEV(x) |
double |
返回所有非 NULL 输入值的样本标准差，等同于 STDDEV_SAMP；少于两个有效值时返回 NULL。 | SELECT STDDEV(x) FROM (VALUES 1, 2, 3) AS t(x) -- 1.0 |
stddev_pop |
STDDEV_POP(x) |
double |
返回所有非 NULL 输入值的总体标准差；没有有效值时返回 NULL。 | SELECT STDDEV_POP(x) FROM (VALUES 1, 2, 3) AS t(x) -- 0.816496580927726 |
variance |
VARIANCE(x) |
double |
返回所有非 NULL 输入值的样本方差，等同于 VAR_SAMP；少于两个有效值时返回 NULL。 | SELECT VARIANCE(x) FROM (VALUES 1, 2, 3) AS t(x) -- 1.0 |
var_pop |
VAR_POP(x) |
double |
返回所有非 NULL 输入值的总体方差；没有有效值时返回 NULL。 | SELECT VAR_POP(x) FROM (VALUES 1, 2, 3) AS t(x) -- 0.6666666666666666 |
stddev_samp |
STDDEV_SAMP(x) |
DOUBLE |
返回所有非 NULL 输入值的样本标准差，等同于 STDDEV。 | SELECT STDDEV_SAMP(x) FROM (VALUES 1, 2, 3) AS t(x) -- 1.0 |
differential_entropy |
DIFFERENTIAL_ENTROPY(bucket_count, x) |
double |
使用固定宽度直方图估算数值 x 的微分熵；bucket_count 控制直方图桶数，结果是近似值。 | SELECT DIFFERENTIAL_ENTROPY(2, x) IS NOT NULL FROM (VALUES 1.0, 2.0, 3.0, 4.0) AS t(x) -- true |
listagg |
LISTAGG(x, separator) WITHIN GROUP (ORDER BY sort_item) |
varchar |
按 WITHIN GROUP 中的顺序连接非 NULL 字符串，并在相邻值之间插入 separator。 | SELECT LISTAGG(x, ',') WITHIN GROUP (ORDER BY x) FROM (VALUES 'b', 'a', 'c') AS t(x) -- a,b,c |
max_by |
MAX_BY(value, sort_key) |
same as first arg |
返回 sort_key 最大的输入行所关联的 value。 | SELECT MAX_BY(value, sort_key) FROM (VALUES ('a', 1), ('b', 3), ('c', 2)) AS t(value, sort_key) -- b |
min_by |
MIN_BY(value, sort_key) |
same as first arg |
返回 sort_key 最小的输入行所关联的 value。 | SELECT MIN_BY(value, sort_key) FROM (VALUES ('a', 1), ('b', 3), ('c', 2)) AS t(value, sort_key) -- a |
regr_intercept |
REGR_INTERCEPT(y, x) |
double |
返回一元线性回归 y = slope * x + intercept 的截距，其中 y 是因变量，x 是自变量。 | SELECT REGR_INTERCEPT(y, x) FROM (VALUES (3, 1), (5, 2), (7, 3)) AS t(y, x) -- 1.0 |
string_agg |
STRING_AGG(x, separator) |
varchar |
把非 NULL 字符串输入聚合为一个字符串，并在相邻值之间插入 separator。 | SELECT STRING_AGG(x, ',') FROM (VALUES 'a', 'b', 'c') AS t(x) -- a,b,c |
var_samp |
VAR_SAMP(x) |
double |
返回所有非 NULL 输入值的样本方差，等同于 VARIANCE。 | SELECT VAR_SAMP(x) FROM (VALUES 1, 2, 3) AS t(x) -- 1.0 |
字符串函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
chr |
CHR(x) |
varchar |
返回 Unicode 码点 x 对应的单字符字符串。 | SELECT CHR(65) -- A |
char |
CHAR(codepoint...) |
varchar |
将一个或多个整数编码转换为对应字符并拼接为字符串。 | SELECT CHAR(65, 66, 67) -- ABC |
concat |
CONCAT(string1,...,stringN) |
varchar |
按参数顺序拼接字符串；任一参数为 NULL 时返回 NULL。 | SELECT CONCAT('a', 'b', 'c') -- abc |
concat_ws |
CONCAT_WS(separator, string1,...,stringN) |
varchar |
使用指定分隔符拼接多个字符串，字符串参数中的 null 值会被忽略。 | SELECT CONCAT_WS(',', 'a', NULL, 'c') -- a,c |
length |
LENGTH(string) |
bigint |
返回字符串包含的 Unicode 码点数量，而不是 UTF-8 字节数。 | SELECT LENGTH('ALOUDATA') -- 8 |
lower |
LOWER(string) |
varchar |
将字符串转换为小写形式。 | SELECT LOWER('ALOUDATA Lakehouse') -- aloudata lakehouse |
lpad |
LPAD(string, size, padstring) |
varchar |
用非空 padstring 从左侧重复填充到 size 个字符；size 小于原长度时截断原字符串。 | SELECT LPAD('aloudata', 10, 'X') -- XXaloudata |
ltrim |
LTRIM(string) |
varchar |
删除字符串开头的空白字符，保留结尾空白。 | SELECT LTRIM(' aloudata ') -- 'aloudata ' |
replace |
REPLACE(string, search) |
varchar |
删除字符串中所有与 search 完全匹配的子串。 | SELECT REPLACE('the catatonic cat', 'cat') -- 'the atonic ' |
replace |
REPLACE(string, search, replace) |
varchar |
将字符串中所有与 search 完全匹配的子串替换为 replace。 | SELECT REPLACE('the catatonic cat', 'cat', 'dog') -- the dogatonic dog |
reverse |
REVERSE(string) |
varchar |
返回反向顺序的字符串。 | SELECT REVERSE('Hello, world!') -- !dlrow ,olleH |
rtrim |
RTRIM(string) |
varchar |
删除字符串中结尾的空格。 | SELECT RTRIM(' aloudata ') -- ' aloudata' |
split |
SPLIT(string, delimiter) |
array(varchar) |
使用指定的分隔符拆分字符串，并返回子串集合。 | SELECT SPLIT('a,b,c', ',') -- ["a", "b", "c"] |
split |
SPLIT(string, delimiter, limit) |
array(varchar) |
使用指定的分隔符拆分字符串，并返回最多 limit 个子串。 | SELECT SPLIT('a,b,c,d,e,f', ',', 3) -- ["a","b","c,d,e,f"] |
split_part |
SPLIT_PART(string, delimiter, index) |
varchar |
按 delimiter 拆分字符串并返回从 1 开始的第 index 段；index 超出范围时返回空字符串。此行为与 Trino 返回 NULL 不同。 | SELECT SPLIT_PART('127.0.0.1', '.', 1) -- 127 |
substr |
SUBSTR(string, start) |
varchar |
返回从 start（从 1 开始；负值从末尾倒数）到字符串末尾的子串。 | SELECT SUBSTR('aloudata air engine', 10) -- air engine |
substr |
SUBSTR(string, start, length) |
varchar |
返回从 start（从 1 开始；负值从末尾倒数）开始、最多包含 length 个字符的子串。 | SELECT SUBSTR('aloudata air engine', 10, 3) -- air |
substring |
SUBSTRING(string, start) |
varchar |
返回字符串从起始位置 start 开始的其余部分。 | SELECT SUBSTRING('aloudata air engine', 10) -- air engine |
substring |
SUBSTRING(string, start, length) |
varchar |
返回字符串从起始位置 start 开始长度为 length 的子串。 | SELECT SUBSTRING('aloudata air engine', 10, 3) -- air |
trim |
TRIM(string) |
varchar |
删除字符串中开头和结尾的空格。 | SELECT TRIM(' pancake ') -- pancake |
upper |
UPPER(string) |
varchar |
将字符串转化为大写形式。 | SELECT UPPER('aloudata lakehouses') -- ALOUDATA LAKEHOUSES |
to_utf8 |
TO_UTF8(string) |
varbinary |
将字符串编码为 UTF-8 字节序列并返回 VARBINARY。 | SELECT TO_HEX(TO_UTF8('AIR')) -- 414952 |
sha256 |
SHA256(binary) |
varbinary |
计算二进制输入的 SHA-256 摘要并返回 32 字节 VARBINARY；这是一种哈希摘要，不是加密。 | SELECT LOWER(TO_HEX(SHA256(TO_UTF8('aloudata')))) -- 51284f4d2721400792bb17aa430ca88350592e20404fb7a3a8d5f35e8aab13f6 |
sha512 |
SHA512(binary) |
varbinary |
计算二进制输入的 SHA-512 摘要并返回 64 字节 VARBINARY；这是一种哈希摘要，不是加密。 | SELECT LOWER(TO_HEX(SHA512(TO_UTF8('aloudata')))) -- 8024b5f256d4f0508577c03b441b0f6e9d356a01700aba04096530dadd4e7a249cccb713ad23ba91bfa231d5a0967c757ac5a6a49e77909a28da96ec369c816d |
uuid |
UUID() |
uuid |
生成一个伪随机 UUID。每次调用通常返回不同的值。 | SELECT LENGTH(CAST(UUID() AS VARCHAR)) -- 36 |
current_user |
CURRENT_USER |
VARCHAR |
返回当前会话的用户名。 | SELECT CURRENT_USER IS NOT NULL -- true |
strpos |
STRPOS(string, substring) |
BIGINT |
在字符串 str 中查找子串 substr 第一次出现的位置，从 1 开始。 | SELECT STRPOS('aloudata air engine', 'air') -- 10 |
strpos |
STRPOS(string, substring, instance) |
BIGINT |
返回 substring 在 string 中第 instance 次出现的位置，位置从 1 开始；未找到时返回 0。 | SELECT STRPOS('abcabcabc', 'abc', 2) -- 4 |
position |
POSITION(substring IN string) |
bigint |
返回 substring 在 string 中第一次出现的起始位置，位置从 1 开始；未找到时返回 0。该函数使用 POSITION(substring IN string) 特殊语法。 | SELECT POSITION('bar' IN 'foobar') -- 4 |
codepoint |
CODEPOINT(string) |
integer |
返回仅含一个字符的 string 对应的 Unicode 码点；输入包含零个或多个字符时会报错。 | SELECT CODEPOINT('A') -- 65 |
ends_with |
ENDS_WITH(string, suffix) |
boolean |
判断 string 是否以 suffix 结尾。 | SELECT ENDS_WITH('aloudata', 'data') -- true |
format |
FORMAT(format, args...) |
varchar |
使用 Java Formatter 风格的 format 和后续参数生成格式化字符串。 | SELECT FORMAT('%s-%03d', 'AIR', 7) -- AIR-007 |
from_base64 |
FROM_BASE64(string) |
varbinary |
把 Base64 文本解码为 VARBINARY；输入不是合法 Base64 时查询失败。 | SELECT FROM_UTF8(FROM_BASE64('QUlS')) -- AIR |
from_hex |
FROM_HEX(string) |
varbinary |
把十六进制文本解码为 VARBINARY；输入必须包含偶数个合法十六进制字符。 | SELECT FROM_UTF8(FROM_HEX('414952')) -- AIR |
from_utf8 |
FROM_UTF8(binary) |
varchar |
把 VARBINARY 按 UTF-8 解码为 VARCHAR；非法字节序列会替换为 Unicode 替换字符。 | SELECT FROM_UTF8(FROM_HEX('414952')) -- AIR |
locate |
LOCATE(substring, string) |
bigint |
返回 substring 在 string 中第一次出现的位置，位置从 1 开始；未找到时返回 0。 | SELECT LOCATE('bar', 'foobar') -- 4 |
locate |
LOCATE(substring, string, start) |
bigint |
从 start（从 1 开始）位置起查找 substring，并返回它在完整 string 中的位置；未找到时返回 0。 | SELECT LOCATE('a', 'banana', 4) -- 4 |
md5 |
MD5(binary) |
varbinary |
计算二进制输入的 MD5 摘要并返回 16 字节 VARBINARY；这是一种哈希摘要，不是加密。 | SELECT LOWER(TO_HEX(MD5(TO_UTF8('AIR')))) -- 2582dd863c1c50525a267e1cbe656929 |
repeat |
REPEAT(string, count) |
varchar |
把 string 重复 count 次并拼接；count 为 0 时返回空字符串。 | SELECT REPEAT('ab', 3) -- ababab |
rpad |
RPAD(string, size, padstring) |
varchar |
用非空 padstring 从右侧重复填充到 size 个字符；size 小于原长度时截断原字符串。 | SELECT RPAD('AIR', 5, 'x') -- AIRxx |
split_to_map |
SPLIT_TO_MAP(string, entry_delimiter, key_value_delimiter) |
map(varchar, varchar) |
先用 entry_delimiter 拆分键值对，再用 key_value_delimiter 拆分每对的键和值并返回 MAP；重复键会报错。 | SELECT CARDINALITY(SPLIT_TO_MAP('a:1,b:2', ',', ':')) -- 2 |
starts_with |
STARTS_WITH(string, prefix) |
boolean |
判断 string 是否以 prefix 开头。 | SELECT STARTS_WITH('aloudata', 'alou') -- true |
strrpos |
STRRPOS(string, substring) |
bigint |
返回 substring 在 string 中最后一次出现的位置，位置从 1 开始；未找到时返回 0。 | SELECT STRRPOS('abcabcabc', 'abc') -- 7 |
strrpos |
STRRPOS(string, substring, instance) |
bigint |
从字符串末尾起返回 substring 第 instance 次出现的位置；instance 必须为正数，未找到时返回 0。 | SELECT STRRPOS('abcabcabc', 'abc', 2) -- 4 |
substring_index |
SUBSTRING_INDEX(string, delimiter, count) |
varchar |
按 delimiter 拆分 string；count 为正时返回左侧前 count 段，为负时返回右侧后 abs(count) 段。 | SELECT SUBSTRING_INDEX('a.b.c.d', '.', 2) -- a.b |
to_base64 |
TO_BASE64(binary) |
varchar |
把 VARBINARY 编码为 Base64 文本。 | SELECT TO_BASE64(TO_UTF8('AIR')) -- QUlS |
to_hex |
TO_HEX(binary) |
varchar |
把 VARBINARY 编码为十六进制文本。 | SELECT TO_HEX(TO_UTF8('AIR')) -- 414952 |
url_extract_fragment |
URL_EXTRACT_FRAGMENT(url) |
varchar |
返回 URL 中 # 之后的片段标识符，不包含 #；没有片段时返回 NULL。 | SELECT URL_EXTRACT_FRAGMENT('https://example.com:8443/a/b?q=air&x=1#top') -- top |
url_extract_host |
URL_EXTRACT_HOST(url) |
varchar |
返回 URL 的主机名，不包含端口。 | SELECT URL_EXTRACT_HOST('https://example.com:8443/a/b?q=air&x=1#top') -- example.com |
url_extract_parameter |
URL_EXTRACT_PARAMETER(url, parameter) |
varchar |
返回 URL 查询字符串中第一个指定名称参数的值；不存在时返回 NULL。 | SELECT URL_EXTRACT_PARAMETER('https://example.com/a?q=air&x=1', 'q') -- air |
url_extract_path |
URL_EXTRACT_PATH(url) |
varchar |
返回 URL 的路径部分。 | SELECT URL_EXTRACT_PATH('https://example.com:8443/a/b?q=air&x=1#top') -- /a/b |
url_extract_port |
URL_EXTRACT_PORT(url) |
integer |
返回 URL 中显式指定的端口号；没有端口时返回 NULL。 | SELECT URL_EXTRACT_PORT('https://example.com:8443/a/b') -- 8443 |
url_extract_protocol |
URL_EXTRACT_PROTOCOL(url) |
varchar |
返回 URL 的协议名，例如 http、https 或 ftp。 | SELECT URL_EXTRACT_PROTOCOL('https://example.com:8443/a/b') -- https |
url_extract_query |
URL_EXTRACT_QUERY(url) |
varchar |
返回 URL 的完整查询字符串，不包含 ?；没有查询字符串时返回 NULL。 | SELECT URL_EXTRACT_QUERY('https://example.com/a/b?q=air&x=1') -- q=air&x=1 |
日期与时间函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
current_date |
CURRENT_DATE |
date |
返回查询开始时会话时区中的当前日期；同一查询内保持不变。 | SELECT CURRENT_DATE = CAST(CURRENT_TIMESTAMP AS DATE) -- true |
current_timestamp |
CURRENT_TIMESTAMP |
timestamp with time zone |
返回查询开始时的当前时间戳；同一查询内保持不变。 | SELECT CURRENT_TIMESTAMP = CURRENT_TIMESTAMP -- true |
current_timestamp |
CURRENT_TIMESTAMP(precision) |
timestamp with time zone |
返回查询开始时的当前时间戳，并将小数秒精度设为 precision。 | SELECT CURRENT_TIMESTAMP(3) = CURRENT_TIMESTAMP(3) -- true |
localtimestamp |
LOCALTIMESTAMP |
timestamp |
返回查询开始时不含时区信息的本地时间戳；同一查询内保持不变。 | SELECT LOCALTIMESTAMP = LOCALTIMESTAMP -- true |
localtimestamp |
LOCALTIMESTAMP(precision) |
timestamp |
返回查询开始时不含时区信息的本地时间戳，并将小数秒精度设为 precision。 | SELECT LOCALTIMESTAMP(3) = LOCALTIMESTAMP(3) -- true |
date |
DATE(x) |
date |
把字符串、DATE 或 TIMESTAMP 转换为 DATE，只保留年、月、日。 | SELECT DATE('2024-04-01 8:00:00.000') -- 2024-04-01 |
last_day_of_month |
LAST_DAY_OF_MONTH(x) |
date |
返回 x 所在月份的最后一天。 | SELECT LAST_DAY_OF_MONTH(DATE '2024-04-01') -- 2024-04-30 |
from_unixtime |
FROM_UNIXTIME(unixtime) |
timestamp with time zone |
把自 1970-01-01 00:00:00 UTC 起的秒数转换为时间戳。 | SELECT TO_UNIXTIME(FROM_UNIXTIME(0)) -- 0.0 |
now |
NOW() |
timestamp with time zone |
返回查询开始时的当前时间戳，等同于 CURRENT_TIMESTAMP。 | SELECT NOW() = CURRENT_TIMESTAMP -- true |
to_unixtime |
TO_UNIXTIME(timestamp) |
double |
把时间戳转换为自 1970-01-01 00:00:00 UTC 起的秒数，结果为 DOUBLE。 | SELECT TO_UNIXTIME(FROM_UNIXTIME(0)) -- 0.0 |
date_trunc |
DATE_TRUNC(unit, x) |
same as input |
把日期或时间戳向下截断到 unit 的起点，例如 month 截断到当月第一天 00:00:00。 | SELECT DATE_TRUNC('MONTH', TIMESTAMP '2024-04-27') -- 2024-04-01 00:00:00.000 |
date_add |
DATE_ADD(unit, value, date/timestamp) |
same as third arg |
给日期或时间戳增加 value 个 unit；value 为负数时执行减法。 | SELECT DATE_ADD('DAY', 1, TIMESTAMP '2024-04-01') -- 2024-04-02 00:00:00.000 |
date_diff |
DATE_DIFF(unit, timestamp1, timestamp2) |
bigint |
返回 timestamp2 减 timestamp1 后按 unit 计量的完整单位数。 | SELECT DATE_DIFF('day', TIMESTAMP '2024-01-01', TIMESTAMP '2024-02-01') -- 31 |
date_format |
DATE_FORMAT(timestamp, format) |
varchar |
按 Tardis 支持的 Java 风格 format（如 yyyy-MM-dd HH ss）格式化时间戳。 |
SELECT DATE_FORMAT(TIMESTAMP '2024-04-01 08:20:30', 'yyyy-MM-dd HH:mm:ss') -- 2024-04-01 08:20:30 |
date_parse |
DATE_PARSE(string, format) |
timestamp |
按 Tardis 支持的 Java 风格 format（如 yyyy-MM-dd HHss）解析字符串并返回 TIMESTAMP；输入必须与格式匹配。 |
SELECT DATE_PARSE('2024-04-01 08:20:30', 'yyyy-MM-dd HH:mm:ss') -- 2024-04-01 08:20:30.000 |
format_datetime |
FORMAT_DATETIME(timestamp, format) |
varchar |
按 Java/Joda 风格 format 格式化时间戳。 | SELECT FORMAT_DATETIME(TIMESTAMP '2024-04-01 08:20:30', 'yyyy-MM-dd HH:mm:ss') -- 2024-04-01 08:20:30 |
parse_datetime |
PARSE_DATETIME(string, format) |
timestamp with time zone |
按 Java/Joda 风格 format 解析字符串并返回时间戳；未在字符串中指定时区时使用会话时区。 | SELECT DAY(PARSE_DATETIME('2024-04-01 08:20:30', 'yyyy-MM-dd HH:mm:ss')) -- 1 |
day |
DAY(x) |
bigint |
返回日期和时间表达式中的天数，按月计算。 | SELECT DAY(TIMESTAMP '2024-04-27') -- 27 |
day_of_week |
DAY_OF_WEEK(x) |
bigint |
返回 ISO 星期序号，星期一为 1，星期日为 7。 | SELECT DAY_OF_WEEK(TIMESTAMP '2024-04-27') -- 6 |
day_of_year |
DAY_OF_YEAR(x) |
bigint |
返回日期和时间表达式中的天数，按年计算。取值范围为 [1, 366]。 | SELECT DAY_OF_YEAR(TIMESTAMP '2024-04-27') -- 118 |
hour |
HOUR(x) |
bigint |
返回日期和时间表达式中的小时数。取值范围为 [0, 23]。 | SELECT HOUR(TIMESTAMP '2024-04-01 08:20:30') -- 8 |
minute |
MINUTE(x) |
bigint |
返回日期和时间表达式中的分钟数。 | SELECT MINUTE(TIMESTAMP '2024-04-01 08:20:30') -- 20 |
month |
MONTH(x) |
bigint |
返回日期和时间表达式中的月份。 | SELECT MONTH(TIMESTAMP '2024-04-01 08:20:30') -- 4 |
quarter |
QUARTER(x) |
bigint |
返回日期和时间表达式中的季度。取值范围为 [1, 4]。 | SELECT QUARTER(TIMESTAMP '2024-04-01 08:20:30') -- 2 |
second |
SECOND(x) |
bigint |
返回日期和时间表达式中的秒数。 | SELECT SECOND(TIMESTAMP '2024-04-01 08:20:30') -- 30 |
week |
WEEK(x) |
bigint |
返回 ISO 周序号，取值范围为 1 到 53。 | SELECT WEEK(TIMESTAMP '2024-04-01 08:00:00') -- 14 |
year |
YEAR(x) |
bigint |
返回日期和时间表达式中的年份。 | SELECT YEAR(TIMESTAMP '2024-04-01 08:00:00') -- 2024 |
year_of_week |
YEAR_OF_WEEK(x) |
bigint |
返回 x 所属 ISO 周对应的年份，该年份在年初或年末可能与日历年份不同。 | SELECT YEAR_OF_WEEK(TIMESTAMP '2024-04-01 08:00:00') -- 2024 |
day_of_month |
DAY_OF_MONTH(x) |
BIGINT |
返回日期中的天（按月计算）。 | SELECT DAY_OF_MONTH(TIMESTAMP '2024-04-27') -- 27 |
dow |
DOW(x) |
BIGINT |
返回 ISO 星期几（1=星期一, 7=星期日）。 | SELECT DOW(DATE '2024-04-27') -- 6 |
doy |
DOY(x) |
BIGINT |
返回一年中的第几天。 | SELECT DOY(DATE '2024-04-27') -- 118 |
yow |
YOW(x) |
BIGINT |
返回 ISO 周日历中的年份。 | SELECT YOW(TIMESTAMP '2024-04-01 08:00:00') -- 2024 |
week_of_year |
WEEK_OF_YEAR(x) |
BIGINT |
返回一年中的第几周（按周计算）。 | SELECT WEEK_OF_YEAR(TIMESTAMP '2024-04-01 08:00:00') -- 14 |
extract |
EXTRACT(unit FROM x) |
bigint |
从日期、时间戳或时间间隔 x 中提取指定字段，例如 YEAR、MONTH、DAY 或 HOUR。 | SELECT EXTRACT(HOUR FROM TIMESTAMP '2024-04-01 08:20:30') -- 8 |
curdate |
CURDATE |
date |
返回查询开始时的当前日期，是 CURRENT_DATE 的兼容别名。 | SELECT CURDATE = CURRENT_DATE -- true |
str_to_date |
STR_TO_DATE(string, format) |
timestamp |
按 MySQL 风格 format（如 %Y-%m-%d %H:%i:%s）解析字符串并返回 TIMESTAMP。 | SELECT STR_TO_DATE('2024-04-01 08:20:30', '%Y-%m-%d %H:%i:%s') -- 2024-04-01 08:20:30.000 |
to_char |
TO_CHAR(timestamp, format) |
varchar |
按 Teradata 风格 format（如 yyyy-mm-dd hh24:mi:ss）把时间戳格式化为字符串。 | SELECT TO_CHAR(TIMESTAMP '2024-04-01 08:20:30', 'yyyy-mm-dd hh24:mi:ss') -- 2024-04-01 08:20:30 |
to_date |
TO_DATE(string, format) |
date |
按 Teradata 风格 format（如 yyyy-mm-dd）解析字符串并返回 DATE。 | SELECT TO_DATE('2024-04-01', 'yyyy-mm-dd') -- 2024-04-01 |
to_iso8601 |
TO_ISO8601(x) |
varchar |
把 DATE、TIME 或 TIMESTAMP 格式化为 ISO 8601 文本。 | SELECT TO_ISO8601(DATE '2024-04-01') -- 2024-04-01 |
to_timestamp |
TO_TIMESTAMP(string, format) |
timestamp |
按 Teradata 风格 format（如 yyyy-mm-dd hh24:mi:ss）解析字符串并返回 TIMESTAMP。 | SELECT TO_TIMESTAMP('2024-04-01 08:20:30', 'yyyy-mm-dd hh24:mi:ss') -- 2024-04-01 08:20:30.000 |
date_format 兼容格式字符串
以下百分号格式用于 date_format 和 str_to_date：
| 函数 | format 的作用 |
|---|---|
date_format(timestamp, format) |
按 format 将日期或时间戳格式化为字符串。除 Java 风格格式外，兼容以下百分号格式。 |
str_to_date(string, format) |
按以下百分号格式解析字符串并返回 TIMESTAMP。 |
date_parse、format_datetime 和 parse_datetime 使用函数说明中所述的 Java/Joda 风格格式，例如 yyyy-MM-dd HH:mm:ss，不使用下表中的百分号格式。
| 格式 | 说明 |
|---|---|
%a |
工作日缩写名称 |
%b |
缩写月名 |
%c |
月，数字形式 |
%D |
带英文后缀的月份日期 |
%d |
日期，数字形式 |
%e |
日期，数字形式 |
%f |
秒的小数部分 |
%H |
小时，24 小时制 |
%h |
小时，12 小时制 |
%I |
小时，12 小时制 |
%i |
分钟 |
%j |
一年中的第几天，取值范围为 1 到 366 |
%k |
小时，24 小时制 |
%l |
小时，12 小时制 |
%M |
月份名称 |
%m |
月份，格式为 MM |
%p |
AM 或 PM 标志 |
%r |
12 小时制时间，格式为 hhss AM/PM |
%S |
秒，格式为 ss |
%s |
自 1970 年 1 月 1 日以来的秒数，常用于 Unix 时间戳 |
%T |
24 小时制时间，格式为 hhss |
%u |
一年中的第几周，星期一作为一周的开始 |
%w |
星期几，0 表示星期日，6 表示星期六 |
%Y |
完整的四位数年份，例如 2023 |
%y |
两位数年份，例如 23 |
兼容函数的格式字符串
以下格式字符串用于 to_char、to_timestamp 和 to_date：
| 函数 | format 的作用 |
|---|---|
to_char(timestamp, format) |
按 format 将时间戳格式化为字符串。 |
to_timestamp(string, format) |
按 format 解析字符串并返回 TIMESTAMP。 |
to_date(string, format) |
按 format 解析字符串并返回 DATE。 |
| 格式 | 说明 |
|---|---|
dd |
天，取值范围为 1 到 31 |
hh |
小时，12 小时制，取值范围为 1 到 12 |
hh24 |
小时，24 小时制，取值范围为 0 到 23 |
mi |
分钟，取值范围为 0 到 59 |
mm |
月份，格式为 MM |
ss |
秒，取值范围为 0 到 59 |
yyyy |
四位数年份 |
yy |
两位数年份 |
数组函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
array |
ARRAY[a, b, c...] |
array |
数组的构造方法。ARRAY[1,2,3,4]表示一个包含四个元素 (1,2,3,4) 的数组。 | SELECT ARRAY[1, 2, 3, 4] -- [1, 2, 3, 4] |
array_agg |
ARRAY_AGG(x) |
array(any) |
把每个输入值聚合成数组；可在函数参数内使用 ORDER BY 固定元素顺序。 | SELECT ARRAY_AGG(x ORDER BY x) FROM (VALUES 3, 1, 2) AS t(x) -- [1, 2, 3] |
array_max |
ARRAY_MAX(array[x]) |
any |
返回给定数组的最大值。 | SELECT ARRAY_MAX(array[1, 2, 3, 4]) -- 4 |
array_min |
ARRAY_MIN(array[x]) |
any |
返回给定数组的最小值。 | SELECT ARRAY_MIN(array[1, 2, 3, 4]) -- 1 |
array_average |
ARRAY_AVERAGE(x) |
double |
返回数组中非 NULL 数值元素的算术平均值；没有非 NULL 元素时返回 NULL。 | SELECT ARRAY_AVERAGE(array[1, 2, 3, 4]) -- 2.5 |
array_join |
ARRAY_JOIN(array[x], delimiter, null_replacement) |
varchar |
用 delimiter 连接数组元素；NULL 元素用 null_replacement 替换，未提供替换值时会被跳过。 | SELECT ARRAY_JOIN(array['1', '2', null, '5'], ';', '3') -- 1;2;3;5 |
array_position |
ARRAY_POSITION(array[x], element) |
bigint |
返回 element 第一次出现时从 1 开始的下标；不存在时返回 0。 | SELECT ARRAY_POSITION(array[1, 3, 5, 7], 5) -- 3 |
element_at |
ELEMENT_AT(array, index) |
any |
返回数组中指定 index 的元素；正索引从 1 开始，负索引从末尾倒数，越界返回 NULL。 | SELECT ELEMENT_AT(ARRAY['a', 'b', 'c'], -1) -- c |
map_keys |
MAP_KEYS(map) |
array |
返回 map 的所有键组成的数组；不要依赖键的返回顺序。假设 t.col 为 {a=1, b=2}，示例返回 [a, b]。 | SELECT MAP_KEYS(col) FROM t -- [a, b] |
map_values |
MAP_VALUES(map) |
array |
返回 map 的所有值组成的数组；每个值与 MAP_KEYS 返回的同位置键对应。假设 t.col 为 {a=1, b=2}，示例返回 [1, 2]。 | SELECT MAP_VALUES(col) FROM t -- [1, 2] |
slice |
SLICE(array, start, length) |
array |
返回数组从 start 开始、长度最多为 length 的切片；start 从 1 开始，负值从末尾倒数。 | SELECT SLICE(ARRAY[1, 2, 3, 4], 2, 2) -- [2, 3] |
array_contains |
ARRAY_CONTAINS(array, element) |
boolean |
判断数组是否包含与 element 相等的元素。 | SELECT ARRAY_CONTAINS(ARRAY[1, 2, 3], 2) -- true |
array_cum_sum |
ARRAY_CUM_SUM(array) |
array(numeric) |
返回数组的前缀累计和；遇到 NULL 元素后，该位置及后续位置的结果均为 NULL。 | SELECT ARRAY_CUM_SUM(ARRAY[1, 2, 3]) -- [1, 3, 6] |
array_distinct |
ARRAY_DISTINCT(array) |
array |
删除数组中的重复元素，每个不同值只保留一次。 | SELECT ARRAY_DISTINCT(ARRAY[1, 2, 1, 3]) -- [1, 2, 3] |
array_intersect |
ARRAY_INTERSECT(array1, array2) |
array |
返回两个数组共有的不同元素。 | SELECT ARRAY_INTERSECT(ARRAY[1, 2, 3], ARRAY[2, 3, 4]) -- [2, 3] |
array_remove |
ARRAY_REMOVE(array, element) |
array |
删除数组中所有与 element 相等的元素。 | SELECT ARRAY_REMOVE(ARRAY[1, 2, 2, 3], 2) -- [1, 3] |
array_sum |
ARRAY_SUM(array) |
numeric |
返回数组中所有非 NULL 数值元素之和；没有非 NULL 元素时返回 0。 | SELECT ARRAY_SUM(ARRAY[1, 2, 3]) -- 6 |
arrays_overlap |
ARRAYS_OVERLAP(array1, array2) |
boolean |
判断两个数组是否存在共同的非 NULL 元素；若不存在共同非 NULL 元素但任一数组含 NULL，则返回 NULL。 | SELECT ARRAYS_OVERLAP(ARRAY[1, 2, 3], ARRAY[3, 4]) -- true |
cardinality |
CARDINALITY(x) |
bigint |
返回数组的元素数量或 MAP 的键值对数量。 | SELECT CARDINALITY(ARRAY['a', 'b', 'c']) -- 3 |
数学函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
abs |
ABS(x) |
same as input |
返回 x 的绝对值。 | SELECT ABS(-2) -- 2 |
ceil |
CEIL(x) |
same as input |
返回大于或等于 x 的最小整数值，返回类型与输入数值类型相对应。 | SELECT CAST(CEIL(3.14159) AS BIGINT) -- 4 |
degrees |
DEGREES(x) |
double |
把以弧度表示的角度转换为度。 | SELECT DEGREES(PI()) -- 180.0 |
e |
E() |
double |
返回自然底数 e 的值。 | SELECT E() -- 2.718281828459045 |
exp |
EXP(x) |
double |
返回自然底数 e 的 x 次幂。 | SELECT EXP(2) -- 7.38905609893065 |
floor |
FLOOR(x) |
same as input |
返回小于或等于 x 的最大整数值，返回类型与输入数值类型相对应。 | SELECT CAST(FLOOR(45.76) AS BIGINT) -- 45 |
ln |
LN(x) |
double |
返回 x 的自然对数。 | SELECT LN(2) -- 0.6931471805599453 |
log2 |
LOG2(x) |
double |
返回以 2 为底的对数。 | SELECT LOG2(8) -- 3.0 |
log10 |
LOG10(x) |
double |
返回以 10 为底的对数。 | SELECT LOG10(100) -- 2.0 |
mod |
MOD(n, m) |
same as input |
返回 n 除以 m 的模（余数）。 | SELECT MOD(10, 3) -- 1 |
pi |
PI() |
double |
返回 π 值，精确到小数点后15位。 | SELECT PI() -- 3.141592653589793 |
power |
POWER(x, p) |
double |
返回 x 的 p 次幂，结果为 DOUBLE。 | SELECT POWER(2, 3) -- 8.0 |
radians |
RADIANS(x) |
double |
将度转换为弧度。 | SELECT RADIANS(180) -- 3.141592653589793 |
rand |
RAND() |
double |
返回 [0.0, 1.0) 范围内的伪随机 DOUBLE，等同于 RANDOM()。 | SELECT RAND() >= 0 AND RAND() < 1 -- true |
rand |
RAND(seed) |
double |
使用 seed 初始化伪随机数生成器，并返回 [0.0, 1.0) 范围内的 DOUBLE；相同执行引擎和 seed 下结果可复现。 | SELECT RAND(100) >= 0 AND RAND(100) < 1 -- true |
round |
ROUND(x) |
numeric |
把 x 四舍五入到最接近的整数；中点值向远离 0 的方向舍入。 | SELECT ROUND(12.5) = 13 -- true |
round |
ROUND(x, d) |
numeric |
把 x 四舍五入到小数点后 d 位；d 为负数时舍入到小数点左侧。 | SELECT ROUND(12.345, 2) = 12.35 -- true |
sign |
SIGN(x) |
same as input |
返回 x 的符号。若 x 为负数，返回 -1；若 x 为正数，返回 1；若 x 为 0，返回 0。 | SELECT SIGN(-45.67) -- -1 |
sqrt |
SQRT(x) |
double |
返回 x 的平方根。 | SELECT SQRT(25) -- 5.0 |
truncate |
TRUNCATE(x) |
double |
直接截去 x 的小数部分，不执行四舍五入。 | SELECT TRUNCATE(123.456) = 123 -- true |
truncate |
TRUNCATE(x, n) |
double |
直接截去 x 在小数点后 n 位以后的数字，不执行四舍五入；n 可为负数。 | SELECT TRUNCATE(123.456, 2) = 123.45 -- true |
acos |
ACOS(x) |
double |
返回 x 的反余弦值，结果单位为弧度。 | SELECT ACOS(1) -- 0.0 |
asin |
ASIN(x) |
double |
返回 x 的反正弦值，结果单位为弧度。 | SELECT ASIN(0) -- 0.0 |
atan |
ATAN(x) |
double |
返回 x 的反正切值，结果单位为弧度。 | SELECT ATAN(0) -- 0.0 |
atan2 |
ATAN2(y, x) |
double |
返回坐标 (x, y) 对应的反正切角，结果单位为弧度，并根据 x、y 的符号确定象限。 | SELECT ATAN2(0, 1) -- 0.0 |
cos |
COS(x) |
double |
返回弧度值 x 的余弦。 | SELECT COS(0) -- 1.0 |
cosh |
COSH(x) |
double |
返回 x 的双曲余弦。 | SELECT COSH(0) -- 1.0 |
sin |
SIN(x) |
double |
返回弧度值 x 的正弦。 | SELECT SIN(0) -- 0.0 |
tan |
TAN(x) |
double |
返回弧度值 x 的正切。 | SELECT TAN(0) -- 0.0 |
tanh |
TANH(x) |
double |
返回 x 的双曲正切。 | SELECT TANH(0) -- 0.0 |
ceiling |
CEILING(x) |
DOUBLE |
返回大于或等于 x 的最小整数值，是 CEIL 的别名。 | SELECT CAST(CEILING(3.14159) AS BIGINT) -- 4 |
random |
RANDOM() |
DOUBLE |
返回 [0.0, 1.0) 范围内的伪随机 DOUBLE。 | SELECT RANDOM() >= 0 AND RANDOM() < 1 -- true |
cbrt |
CBRT(x) |
double |
返回 x 的立方根。 | SELECT CBRT(27) -- 3.0 |
is_nan |
IS_NAN(x) |
boolean |
判断 x 是否为 IEEE 754 的 NaN。 | SELECT IS_NAN(CAST('NaN' AS DOUBLE)) -- true |
pow |
POW(x, y) |
double |
返回 x 的 y 次幂，是 POWER 的别名。 | SELECT POW(2, 3) -- 8.0 |
窗口函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
dense_rank |
DENSE_RANK() |
bigint |
按窗口排序返回稠密排名；并列值排名相同，后续排名不留空缺。 | SELECT ARRAY_AGG(r ORDER BY x) FROM (SELECT x, DENSE_RANK() OVER (ORDER BY x) AS r FROM (VALUES 10, 10, 20) AS t(x)) AS ranked -- [1, 1, 2] |
rank |
RANK() |
bigint |
按窗口排序返回排名；并列值排名相同，并在后续排名中留下相应空缺。 | SELECT ARRAY_AGG(r ORDER BY x) FROM (SELECT x, RANK() OVER (ORDER BY x) AS r FROM (VALUES 10, 10, 20) AS t(x)) AS ranked -- [1, 1, 3] |
percent_rank |
PERCENT_RANK() |
double |
返回 (rank - 1) / (分区行数 - 1)；单行分区返回 0。 | SELECT ARRAY_AGG(r ORDER BY x) FROM (SELECT x, PERCENT_RANK() OVER (ORDER BY x) AS r FROM (VALUES 10, 20, 30) AS t(x)) AS ranked -- [0.0, 0.5, 1.0] |
ntile |
NTILE(n) |
bigint |
按窗口顺序把分区尽量均匀地分入 n 个桶，桶号从 1 开始，多余行优先放入编号较小的桶。 | SELECT ARRAY_AGG(bucket ORDER BY x) FROM (SELECT x, NTILE(2) OVER (ORDER BY x) AS bucket FROM (VALUES 10, 20, 30, 40) AS t(x)) AS bucketed -- [1, 1, 2, 2] |
row_number |
ROW_NUMBER() |
bigint |
按窗口顺序为每行分配从 1 开始且不重复的连续序号。 | SELECT ARRAY_AGG(r ORDER BY x) FROM (SELECT x, ROW_NUMBER() OVER (ORDER BY x) AS r FROM (VALUES 10, 20, 30) AS t(x)) AS numbered -- [1, 2, 3] |
first_value |
FIRST_VALUE(x) |
same as first arg |
返回当前窗口 frame 排序后的第一个值；结果受 frame 边界影响。 | SELECT ARRAY_AGG(v ORDER BY x) FROM (SELECT x, FIRST_VALUE(x) OVER (ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS v FROM (VALUES 10, 20, 30) AS t(x)) AS valued -- [10, 10, 10] |
last_value |
LAST_VALUE(x) |
same as first arg |
返回当前窗口 frame 排序后的最后一个值；默认 frame 通常只到当前行，要取分区最后值需显式扩展 frame。 | SELECT ARRAY_AGG(v ORDER BY x) FROM (SELECT x, LAST_VALUE(x) OVER (ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS v FROM (VALUES 10, 20, 30) AS t(x)) AS valued -- [30, 30, 30] |
lead |
LEAD(x) |
same as first arg |
返回窗口排序中当前行之后第 1 行的 x；不存在时返回 NULL。 | SELECT ARRAY_AGG(v ORDER BY x) FROM (SELECT x, LEAD(x) OVER (ORDER BY x) AS v FROM (VALUES 10, 20, 30) AS t(x)) AS valued -- [20, 30, NULL] |
lead |
LEAD(x, offset) |
same as first arg |
返回窗口排序中当前行之后第 offset 行的 x；不存在时返回 NULL。 | SELECT ARRAY_AGG(v ORDER BY x) FROM (SELECT x, LEAD(x, 2) OVER (ORDER BY x) AS v FROM (VALUES 10, 20, 30) AS t(x)) AS valued -- [30, NULL, NULL] |
lead |
LEAD(x, offset, default_value) |
same as first arg |
返回窗口排序中当前行之后第 offset 行的 x；不存在时返回 default_value。 | SELECT ARRAY_AGG(v ORDER BY x) FROM (SELECT x, LEAD(x, 1, 99) OVER (ORDER BY x) AS v FROM (VALUES 10, 20, 30) AS t(x)) AS valued -- [20, 30, 99] |
lag |
LAG(x) |
same as first arg |
返回窗口排序中当前行之前第 1 行的 x；不存在时返回 NULL。 | SELECT ARRAY_AGG(v ORDER BY x) FROM (SELECT x, LAG(x) OVER (ORDER BY x) AS v FROM (VALUES 10, 20, 30) AS t(x)) AS valued -- [NULL, 10, 20] |
lag |
LAG(x, offset) |
same as first arg |
返回窗口排序中当前行之前第 offset 行的 x；不存在时返回 NULL。 | SELECT ARRAY_AGG(v ORDER BY x) FROM (SELECT x, LAG(x, 2) OVER (ORDER BY x) AS v FROM (VALUES 10, 20, 30) AS t(x)) AS valued -- [NULL, NULL, 10] |
lag |
LAG(x, offset, default_value) |
same as first arg |
返回窗口排序中当前行之前第 offset 行的 x；不存在时返回 default_value。 | SELECT ARRAY_AGG(v ORDER BY x) FROM (SELECT x, LAG(x, 1, 0) OVER (ORDER BY x) AS v FROM (VALUES 10, 20, 30) AS t(x)) AS valued -- [0, 10, 20] |
近似计算函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
approx_percentile |
APPROX_PERCENTILE(x, percentage) |
same as input |
返回全部输入值 x 在 percentage 处的近似百分位数；percentage 必须是 0 到 1 之间且对所有输入行保持不变的常量。 | SELECT APPROX_PERCENTILE(x, 0.5) FROM (VALUES 10, 10, 10) AS t(x) -- 10 |
位运算函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
bitwise_and |
BITWISE_AND(x, y) |
bigint |
将 x 和 y 的每个位进行比较，只有两个位都是 1 时，结果位才是 1。 | SELECT BITWISE_AND(10, 11) -- 10 |
bitwise_not |
BITWISE_NOT(x) |
bigint |
将 x 的每个位取反，1 变成 0，0 变成 1。 | SELECT BITWISE_NOT(10) -- -11 |
bitwise_or |
BITWISE_OR(x, y) |
bigint |
将 x 和 y 的每个位进行比较，只要有一个位是 1，结果位就是 1。 | SELECT BITWISE_OR(10, 11) -- 11 |
bitwise_xor |
BITWISE_XOR(x, y) |
bigint |
将 x 和 y 的每个位进行比较，只有两个位不相同时，结果位才是 1。 | SELECT BITWISE_XOR(10, 11) -- 1 |
bitwise_arithmetic_shift_right |
BITWISE_ARITHMETIC_SHIFT_RIGHT(x, shift) |
bigint |
对 x 执行保留符号位的算术右移 shift 位。 | SELECT BITWISE_ARITHMETIC_SHIFT_RIGHT(-8, 2) -- -2 |
bitwise_left_shift |
BITWISE_LEFT_SHIFT(x, shift) |
same as input |
把 value 的位模式向左移动 shift 位，右侧补 0。 | SELECT BITWISE_LEFT_SHIFT(1, 2) -- 4 |
bitwise_right_shift |
BITWISE_RIGHT_SHIFT(x, shift) |
same as input |
把 value 的位模式向右逻辑移动 shift 位，左侧补 0。 | SELECT BITWISE_RIGHT_SHIFT(8, 2) -- 2 |
bitwise_right_shift_arithmetic |
BITWISE_RIGHT_SHIFT_ARITHMETIC(x, shift) |
same as input |
把 value 的位模式向右算术移动 shift 位，左侧使用符号位填充。 | SELECT BITWISE_RIGHT_SHIFT_ARITHMETIC(-8, 2) -- -2 |
条件函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
coalesce |
COALESCE(value1, value2 [, ...]) |
same as first non null arg |
返回多个表达式中第一个非NULL的值。 | SELECT COALESCE(null, null, 2, 3) -- 2 |
decode |
DECODE(value, search1, result1, ...) |
same as input |
依次比较 value 与各 search；返回第一个匹配项对应的 result，均不匹配时返回可选 default，未提供 default 时返回 NULL。 | SELECT DECODE(2, 1, 'one', 2, 'two', 'other') -- two |
greatest |
GREATEST(value1, value2, ...) |
same as input |
返回所有参数中的最大值；参数必须可比较且能转换到公共类型，任一参数为 NULL 时返回 NULL。 | SELECT GREATEST(3, 9, 5) -- 9 |
least |
LEAST(value1, value2, ...) |
same as input |
返回所有参数中的最小值；参数必须可比较且能转换到公共类型，任一参数为 NULL 时返回 NULL。 | SELECT LEAST(3, 9, 5) -- 3 |
nullif |
NULLIF(value1, value2) |
same as input |
当 value1 等于 value2 时返回 NULL，否则返回 value1。 | SELECT NULLIF(5, 5) -- NULL |
nvl |
NVL(value, default_value) |
same as input |
当 value 为 NULL 时返回 default_value，否则返回 value；等同于两个参数的 COALESCE。 | SELECT NVL(NULL, 7) -- 7 |
JSON 函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
json_extract |
JSON_EXTRACT(json, json_path) |
json |
按 JSONPath 从 json 中提取 JSON 值，返回值仍保留 JSON 类型和 JSON 字符串引号。 | SELECT JSON_EXTRACT('{"a":"b"}', '$.a') -- "b" |
json_array_get |
JSON_ARRAY_GET(json_array, index) |
json |
返回 JSON 数组中从 0 开始的 index 位置的 JSON 值；负索引从末尾倒数，越界返回 NULL。 | SELECT JSON_ARRAY_GET('["a", [3, 9], "c"]', 1) -- [3, 9] |
json_extract_scalar |
JSON_EXTRACT_SCALAR(json, json_path) |
varchar |
按 JSONPath 提取标量并返回不带 JSON 引号的 VARCHAR；数组或对象等非标量返回 NULL。 | SELECT JSON_EXTRACT_SCALAR('[1, 2, 3]', '$[2]') -- 3 |
json_parse |
JSON_PARSE(string) |
json |
校验并把 JSON 文本反序列化为 JSON 值；输入不是合法 JSON 时查询失败。 | SELECT JSON_FORMAT(JSON_PARSE('{"a": 1, "b": 2}')) -- {"a":1,"b":2} |
is_json_scalar |
IS_JSON_SCALAR(json) |
boolean |
判断 JSON 值是否为标量；JSON 数字、字符串、布尔值和 null 是标量，数组和对象不是。 | SELECT IS_JSON_SCALAR('[1, 2, 3]') -- false |
json_array_contains |
JSON_ARRAY_CONTAINS(json, value) |
boolean |
判断 JSON 数组文本中是否包含指定标量值。 | SELECT JSON_ARRAY_CONTAINS('[1, 2, 3]', 2) -- true |
json_array_length |
JSON_ARRAY_LENGTH(json) |
bigint |
返回 JSON 数组文本中的元素数量。 | SELECT JSON_ARRAY_LENGTH('[1, 2, 3]') -- 3 |
json_format |
JSON_FORMAT(json) |
varchar |
把 JSON 值序列化为符合 JSON 语法的紧凑文本，是 JSON_PARSE 的逆操作。 | SELECT JSON_FORMAT(JSON_PARSE('[1, 2, 3]')) -- [1,2,3] |
json_size |
JSON_SIZE(json, json_path) |
bigint |
返回 JSONPath 指向的数组元素数或对象成员数；标量大小为 0。 | SELECT JSON_SIZE('{"x": [1, 2, 3]}', '$.x') -- 3 |
正则表达式函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
regexp_extract_all |
REGEXP_EXTRACT_ALL(string, pattern) |
array(varchar) |
返回所有匹配项；未指定 group 时返回整个匹配（第 0 组），指定 group 时返回对应捕获组。 | SELECT REGEXP_EXTRACT_ALL('1a 2b 14m', '\d+') -- ["1","2","14"] |
regexp_extract |
REGEXP_EXTRACT(string, pattern) |
varchar |
返回 string 中正则表达式模式匹配的第一个子字符串。 | SELECT REGEXP_EXTRACT('1a 2b 14m', '\d+') -- 1 |
regexp_like |
REGEXP_LIKE(string, pattern) |
boolean |
判断 pattern 是否匹配 string 的任意子串；若要匹配整个字符串，应在 pattern 中使用 ^ 和 $。 | SELECT REGEXP_LIKE('1a 2b 14m', '\d+b') -- true |
regexp_replace |
REGEXP_REPLACE(string, pattern, replacement) |
varchar |
把所有匹配 pattern 的子串替换为 replacement；replacement 可用 $1、$2 等引用捕获组。 | SELECT REGEXP_REPLACE('1a 2b 14m', '(\d+)([ab])', '3c$2') -- 3ca 3cb 14m |
类型转换函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
cast |
CAST(value AS type) |
ANY |
把 value 转换为 type；不支持或失败的转换会使查询报错。 | SELECT CAST(3.14159 AS INTEGER) -- 3 |
try_cast |
TRY_CAST(value AS type) |
ANY |
将一个值转换为指定的数据类型，转换失败时返回 null。 | SELECT TRY_CAST('abc' AS INTEGER) -- null |
系统函数
| 函数 | 语法 | 返回类型 | 说明 | 示例 |
|---|---|---|---|---|
database |
DATABASE() |
varchar |
返回当前会话选择的数据库名称；未选择数据库时可能返回 NULL。 | SELECT DATABASE() IS NULL OR DATABASE() IS NOT NULL -- true |
version |
VERSION() |
varchar |
返回 Tardis 当前对外报告的引擎版本字符串。 | SELECT VERSION() -- 8.0.27 |