系统(内置)函数 #
Flink Table API & SQL 为用户提供了一组内置的数据转换函数。本页简要介绍了它们。如果你需要的函数尚不支持,你可以实现 用户自定义函数。如果你觉得这个函数够通用,请 创建一个 Jira issue并详细 说明。
标量函数 #
标量函数将零、一个或多个值作为输入并返回单个值作为结果。
比较函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
value1 = value2 | value1 === value2 |
如果 value1 等于 value2 返回 TRUE ;如果 value1 或者 value2 为 NULL 返回 UNKNOW 。
|
value1 <> value2 | value1 !== value2 |
如果 value1 不等于 value2 返回 TRUE ;如果 value1 或 value2 为 NULL 返回 UNKNOWN 。
|
value1 > value2 | value1 > value2 |
如果 value1 大于 value2 返回 TRUE ;如果 value1 或 value2 为 NULL 返回 UNKNOWN 。
|
value1 >= value2 | value1 >= value2 |
如果 value1 大于或等于 value2 返回 TRUE ;如果 value1 或 value2 为 NULL 返回 UNKNOWN 。
|
value1 < value2 | value1 < value2 |
如果 value1 小于 value2 返回 TRUE ;如果 value1 或 value2 为 NULL 返回 UNKNOWN 。
|
value1 <= value2 | value1 <= value2 |
如果 value1 小于或等于 value2 返回 TRUE ;如果 value1 或 value2 为 NULL 返回 UNKNOWN 。
|
value IS NULL | value.isNull |
如果值为 NULL 返回 TRUE 。
|
value IS NOT NULL | value.isNotNull |
如果值不为 NULL 返回 TRUE 。
|
value1 IS DISTINCT FROM value2 | 不适用 |
A 和 B 的数据类型和值不完全相同返回 TRUE 。A 和 B 的数据类型和值都相同返回 FALSE 。NULL 视为与任何其他值相同。
例如 1 IS DISTINCT FROM NULL 返回 TRUE ;NULL IS DISTINCT FROM NULL 返回 FALSE 。
|
value1 IS NOT DISTINCT FROM value2 | 不适用 |
A 和 B 的数据类型和值都相同返回 TRUE 。A 和 B 的数据类型和值不完全相同则返回 FALSE 。NULL 视为与任何其他值相同。
例如 1 IS NOT DISTINCT FROM NULL 返回 FALSE ;NULL IS NOT DISTINCT FROM NULL 返回 TRUE 。
|
value1 BETWEEN [ ASYMMETRIC | SYMMETRIC ] value2 AND value3 | 不适用 |
默认或使用 ASYMMETRIC 关键字的情况下,如果 value1 大于等于 value2 且小于等于 value3 返回 TRUE 。
使用 SYMMETRIC 关键字则 value1 在 value2 和 value3 之间返回 TRUE 。
当 value2 或 value3 为 NULL 时,返回 FALSE 或 UNKNOWN 。
例如 12 BETWEEN 15 AND 12 返回 FALSE ;
12 BETWEEN SYMMETRIC 15 AND 12 返回 TRUE ;
12 BETWEEN 10 AND NULL 返回 UNKNOWN ;
12 BETWEEN NULL AND 10 返回 FALSE ;
12 BETWEEN SYMMETRIC NULL AND 12 返回 UNKNOWN 。
|
value1 NOT BETWEEN [ ASYMMETRIC | SYMMETRIC ] value2 AND value3 | 不适用 |
默认或使用 ASYMMETRIC 关键字的情况下,如果 value1 小于 value2 或大于 value3,则返回 TRUE 。
使用 SYMMETRIC 关键字则 value1 不在 value2 和 value3 之间返回 TRUE 。
当 value2 或 value3 为 NULL 时,返回 TRUE 或 UNKNOWN 。
例如 12 NOT BETWEEN 15 AND 12 返回 TRUE ;
12 NOT BETWEEN SYMMETRIC 15 AND 12 返回 FALSE ;
12 NOT BETWEEN NULL AND 15 返回 UNKNOWN ;
12 NOT BETWEEN 15 AND NULL 返回 TRUE ;
12 NOT BETWEEN SYMMETRIC 12 AND NULL 返回 UNKNOWN 。
|
string1 LIKE string2 [ ESCAPE char ] | string1.like(string2) |
如果 string1 匹配 string2 返回 TRUE ;如果 string1 或 string2 为 NULL 返回 UNKNOWN 。
如果需要可以定义转义字符。尚不支持转义字符。
|
string1 NOT LIKE string2 [ ESCAPE char ] | 不适用 |
如果 string1 与 string2 不匹配返回 TRUE ;如果 string1 或 string2 为 NULL 返回 UNKNOWN 。
如果需要可以定义转义字符。尚不支持转义字符。
|
string1 SIMILAR TO string2 [ ESCAPE char ] | string1.similar(string2) |
如果 string1 匹配 SQL 正则表达式 string2 返回 TRUE ;如果 string1 或 string2 为 NULL 返回
UNKNOWN 。如果需要可以定义转义字符。尚不支持转义字符。
|
string1 NOT SIMILAR TO string2 [ ESCAPE char ] | 不适用 |
如果 string1 与 SQL 正则表达式 string2 不匹配返回 TRUE ;如果 string1 或 string2 为 NULL 返回
UNKNOWN 。如果需要可以定义转义字符。尚不支持转义字符。
|
value1 IN (value2 [, value3]* ) | value1.in(value2) |
在给定列表 (value2, value3, …) 中存在 value1 返回 TRUE 。当列表包含 NULL ,如果可以找到 value1 则返回
TRUE ,否则返回 UNKNOWN 。如果 value1 为 NULL 则始终返回 UNKNOWN 。例如 4 IN (1, 2, 3) 返回
FALSE ;1 IN (1, 2, NULL) 返回 TRUE ;4 IN (1, 2, NULL) 返回 UNKNOWN 。
|
value1 NOT IN (value2 [, value3]* ) | 不适用 |
在给定列表 (value2, value3, …) 中不存在 value1 返回 TRUE 。当列表包含 NULL ,如果可以找到 value1 则
返回 FALSE ,否则返回 UNKNOWN 。如果 value1 为 NULL ,则始终返回 UNKNOWN 。例如 4 NOT IN (1, 2, 3)
返回 TRUE ;1 NOT IN (1, 2, NULL) 返回 FALSE ;4 NOT IN (1, 2, NULL) 返回 UNKNOWN 。
|
EXISTS (sub-query) | 不适用 |
如果子查询至少返回一行则返回 TRUE 。 仅支持可以在 join 和分组操作中可以被重写的操作。对于流式查询,该操作在 join
和分组操作中被重写。计算查询结果所需的状态大小取决于输入行的数量,状态可能会无限增长。请在查询配置中合理配置状态保留时间,以防止状态过大。
|
value IN (sub-query) | value1.in(TABLE) |
如果 value 等于子查询结果集中的一行则返回 TRUE 。
|
value NOT IN (sub-query) | 不适用 |
如果 value 不包含于子查询返回的行则返回 TRUE 。
|
不适用 | value1.between(value2, value3) |
如果 value1 大于或等于 value2 且小于或等于 value3 返回 TRUE 。当 value2 或 value3 为 NULL 时,
返回 FALSE 或 UNKNOWN 。
|
不适用 | value1.notBetween(value2, value3) |
如果 value1 大于或等于 value2 且小于或等于 value3 返回 FALSE 。当 value2 或 value3 为 NULL 时,
返回 TRUE 或 UNKNOWN 。
|
逻辑函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
boolean1 OR boolean2 | BOOLEAN1 || BOOLEAN2 |
如果 boolean1 为 TRUE 或 boolean2 为 TRUE 返回 TRUE 。支持三值逻辑。
例如 true || Null(BOOLEAN) 返回 TRUE 。
|
boolean1 AND boolean2 | BOOLEAN1 && BOOLEAN2 |
如果 boolean1 和 boolean2 都为 TRUE 返回 TRUE 。支持三值逻辑。
例如 true && Null(BOOLEAN) 返回 UNKNOWN 。
|
NOT boolean | BOOLEAN.not(), not(BOOLEAN), 或者 '!BOOLEAN' (仅适用于Scala) |
如果 boolean 为 FALSE 返回 TRUE ;如果 boolean 为 TRUE 返回 FALSE ;如果 boolean 为 UNKNOWN
返回 UNKNOWN 。
|
boolean IS FALSE | BOOLEAN.isFalse |
如果 boolean 为 FALSE 返回 TRUE ;如果 boolean 为 TRUE 或 UNKNOWN 返回 FALSE 。
|
boolean IS NOT FALSE | BOOLEAN.isNotFalse |
如果 boolean 为 TRUE 或 UNKNOWN 返回 TRUE ;如果 boolean 为 FALSE 返回 FALSE 。
|
boolean IS TRUE | BOOLEAN.isTrue |
如果 boolean 为 TRUE 返回 TRUE ;如果 boolean 为 FALSE 或 UNKNOWN 返回 FALSE 。
|
boolean IS NOT TRUE | BOOLEAN.isNotTrue |
如果 boolean 为 FALSE 或 UNKNOWN 返回 TRUE ;如果 boolean 为 TRUE 返回 FALSE 。
|
boolean IS UNKNOWN | 不适用 |
如果 boolean 为 UNKNOWN 返回 TRUE ;如果 boolean 为 TRUE 或 FALSE 返回 FALSE 。
|
boolean IS NOT UNKNOWN | 不适用 |
如果 boolean 为 TRUE 或 FALSE 返回 TRUE ;如果 boolean 为 UNKNOWN 返回 FALSE 。
|
算术函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
|
+ NUMERIC | 返回 numeric。 |
|
- NUMERIC | 返回 numeric 的相反数。 |
numeric1 + numeric2 | NUMERIC1 + NUMERIC2 | 返回 numeric1 加 numeric2。 |
numeric1 - numeric2 | NUMERIC1 - NUMERIC2 | 返回 numeric1 减 numeric2。 |
numeric1 * numberic2 | NUMERIC1 * NUMERIC2 | 返回 numeric1 乘以 numeric2。 |
numeric1 / numeric2 | NUMERIC1 / NUMERIC2 | 返回 numeric1 除以 numeric2。 |
numeric1 % numeric2 | MOD(NUMERIC1, NUMERIC2) | 返回 numeric1 除以 numeric2 的余数(模数)。仅当 numeric1 为负时,结果才为负。 |
POWER(numeric1, numeric2) | NUMERIC1.power(NUMERIC2) | 返回 numeric1 的 numeric2 次方。 |
ABS(numeric) | NUMERIC.abs() | 返回 numeric 的绝对值。 |
SQRT(numeric) | NUMERIC.sqrt() | 返回 numeric 的平方根。 |
LN(numeric) | NUMERIC.ln() | 返回 numeric 的自然对数(以 e 为底)。 |
LOG10(numeric) | NUMERIC.log10() | 返回以 10 为底的 numeric 的对数。 |
LOG2(numeric) | NUMERIC.log2() | 返回以 2 为底的 numeric 的对数。 |
LOG(numeric2) LOG(numeric1, numeric2) | NUMERIC1.log() NUMERIC1.log(NUMERIC2) | 当用一个参数调用时,返回 numeric2 的自然对数。当使用两个参数调用时,此函数返回 numeric2 以 numeric1 为底的对数,此时 numeric2 必须大于 0,numeric1 必须大于 1。 |
EXP(numeric) | NUMERIC.exp() | 返回 e 的 numeric 次幂。 |
CEIL(numeric) CEILING(numeric) | NUMERIC.ceil() NUMERIC.ceiling() | 向上取整,并返回大于或等于 numeric 的最小整数。 |
FLOOR(numeric) | NUMERIC.floor() | 向下取整,并返回小于或等于 numeric 的最大整数。 |
SIN(numeric) | NUMERIC.sin() | 返回 numeric 的正弦值。 |
SINH(numeric) | NUMERIC.sinh() | 返回 numeric 的双曲正弦值。返回类型为 DOUBLE。 |
COS(numeric) | NUMERIC.cos() | 返回 numeric 的余弦值。 |
TAN(numeric) | NUMERIC.tan() | 返回 numeric 的正切值。 |
TANH(numeric) | NUMERIC.tanh() | 返回 numeric 的双曲正切值。返回类型为 DOUBLE。 |
COT(numeric) | NUMERIC.cot() | 返回 numeric 的余切值。 |
ASIN(numeric) | NUMERIC.asin() | 返回 numeric 的反正弦值。 |
ACOS(numeric) | NUMERIC.acos() | 返回 numeric 的反余弦值。 |
ATAN(numeric) | NUMERIC.atan() | 返回 numeric 的反正切值。 |
ATAN2(numeric1, numeric2) | atan2(NUMERIC1, NUMERIC2) | 返回坐标 (numeric1, numeric2) 的反正切。 |
COSH(numeric) | NUMERIC.cosh() | 返回 numeric 的双曲余弦值。返回值类型为 DOUBLE。 |
DEGREES(numeric) | NUMERIC.degrees() | 返回弧度 numeric 的度数表示。 |
RADIANS(numeric) | NUMERIC.radians() | 返回度数 numeric 的弧度表示。 |
SIGN(numeric) | NUMERIC.sign() | 返回 numeric 的符号。 |
ROUND(numeric, INT) | NUMERIC.round(INT) | 返回 numeric 四舍五入保留 INT 小数位的值。 |
PI() | pi() | 返回无比接近 pi 的值。 |
E() | e() | 返回无比接近 e 的值。 |
RAND() | rand() | 返回 [0.0, 1.0) 范围内的伪随机双精度值。 |
RAND(INT) | rand(INT) | 返回范围为 [0.0, 1.0) 的伪随机双精度值,初始种子为 INT。 如果两个 RAND 函数具有相同的初始种子,它们将返回相同的数字序列。 |
RAND_INTEGER(INT) | randInteger(INT) | 返回 [0, INT) 范围内的伪随机整数。 |
RAND_INTEGER(INT1, INT2) | randInteger(INT1, INT2) | 返回范围为 [0, INT2) 的伪随机整数,初始种子为 INT1。 如果两个 RAND_INTGER 函数具有相同的初始种子和边界,它们将返回相同的数字序列。 |
UUID() | uuid() | 根据 RFC 4122 类型 4(伪随机生成)UUID,返回 UUID(通用唯一标识符)字符串。 例如“3d3c68f7-f608-473f-b60c-b0c44ad4cc4e”,UUID 是使用加密强的伪随机数生成器生成的。 |
BIN(INT) | INT.bin() |
以二进制格式返回 INTEGER 的字符串表示形式。如果 INTEGER 为 NULL ,则返回 NULL 。
例如 4.bin() 返回“100”,12.bin() 返回“1100”。
|
HEX(numeric) HEX(string) | NUMERIC.hex() STRING.hex() |
以十六进制格式返回整数 numeric 或字符串 string 的字符串表示。如果参数为 NULL ,则返回 NULL 。
例如数字 20 返回“14”,数字 100 返回“64”,字符串“hello,world” 返回“68656C6C6F2C776F726C64”。
|
TRUNCATE(numeric1, integer2) | NUMERIC1.truncate(INTEGER2) |
返回截取 integer2 位小数的数字。如果 numeric1 或 integer2 为 NULL ,则返回 NULL 。
如果 integer2 为 0,则结果没有小数点或小数部分。integer2 可以为负数,使值的小数点左边的 integer2 位变为零。
此函数也可以只传入一个参数 numeric1 且不设置参数 integer2 来使用。如果未设置 integer2 则 integer2 默认为 0。
例如 42.324.truncate(2) 为 42.32,42.324.truncate() 为 42.0。
|
字符串函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
string1 || string2 | STRING1 + STRING2 | 返回 STRING1 和 STRING2 的连接。 |
CHAR_LENGTH(string) CHARACTER_LENGTH(string) | STRING.charLength() | 返回字符串中的字符数。 |
UPPER(string) | STRING.upperCase() | 以大写形式返回字符串。 |
LOWER(string) | STRING.lowerCase() | 以小写形式返回字符串。 |
POSITION(string1 IN string2) | STRING1.position(STRING2) | 返回 STRING2 中第一次出现 STRING1 的位置(从 1 开始);如果在 STRING2 中找不到 STRING1 返回 0。 |
TRIM([ BOTH | LEADING | TRAILING ] string1 FROM string2) | STRING1.trim(LEADING, STRING2) STRING1.trim(TRAILING, STRING2) STRING1.trim(BOTH, STRING2) STRING1.trim(BOTH) STRING1.trim() | 删除字符串 STRING1 开头和结尾可能存在的字符串 STRING2 并返回。默认情况下,会删除 STRING1 开头和结尾的空格。 |
LTRIM(string) | STRING.ltrim() |
返回从 STRING 中删除左边空格的字符串。
例如 ' This is a test String.'.ltrim() 返回 'This is a test String.' 。
|
RTRIM(string) | STRING.rtrim() |
返回从 STRING 中删除右边空格的字符串。
例如 'This is a test String. '.rtrim() 返回 'This is a test String.' 。
|
REPEAT(string, int) | STRING.repeat(INT) |
返回 INT 个 string 连接的字符串。
例如 REPEAT('This is a test String.', 2) 返回 "This is a test String.This is a test String." 。
|
REGEXP_REPLACE(string1, string2, string3) | STRING1.regexpReplace(STRING2, STRING3) |
返回 STRING1 所有与正则表达式 STRING2 匹配的子字符串被 STRING3 替换后的字符串。
例如 'foobar'.regexpReplace('oo|ar', '') 返回 "fb" 。
|
OVERLAY(string1 PLACING string2 FROM integer1 [ FOR integer2 ]) | STRING1.overlay(STRING2, INT1) STRING1.overlay(STRING2, INT1, INT2) |
将字符串 STRING1 从位置 INT1 开始替换 INT2(默认为 STRING2 的长度)个来自字符串 STRING2 的字符并返回。
例如 'xxxxxtest'.overlay('xxxx', 6) 返回 "xxxxxxxxx" ;
'xxxxxtest'.overlay('xxxx', 6, 2) 返回 "xxxxxxxxxst" 。
|
SUBSTRING(string FROM integer1 [ FOR integer2 ]) | STRING.substring(INT1) STRING.substring(INT1, INT2) | 返回 STRING 从位置 INT1 开始,长度为 INT2(默认到结尾)的子字符串。 |
REPLACE(string1, string2, string3) | STRING1.replace(STRING2, STRING3) |
返回一个新字符串,它用 STRING3(非重叠)替换 STRING1 中所有出现的 STRING2。
例如 'hello world'.replace('world', 'flink') 返回 'hello flink' ;
'ababab'.replace('abab', 'z') 返回 'zab' 。
|
REGEXP_EXTRACT(string1, string2[, integer]) | STRING1.regexpExtract(STRING2[, INTEGER1]) |
将字符串 STRING1 按照 STRING2 正则表达式的规则拆分,返回指定 INTEGER1 处位置的字符串。正则表达式匹配组索引从 1 开始,
0 表示匹配整个正则表达式。此外,正则表达式匹配组索引不应超过定义的组数。
例如 REGEXP_EXTRACT('foothebar', 'foo(.*?)(bar)', 2) 返回 "bar" 。
|
INITCAP(string) | STRING.initCap() | 返回新形式的 STRING,其中每个单词的第一个字符转换为大写,其余字符转换为小写。这里的单词表示字母数字的字符序列。 |
CONCAT(string1, string2, …) | concat(STRING1, STRING2, ...) |
返回连接 string1,string2, … 的字符串。如果有任一参数为 NULL ,则返回 NULL 。
例如 CONCAT('AA', 'BB', 'CC') 返回 "AABBCC" 。
|
CONCAT_WS(string1, string2, string3, …) | concat_ws(STRING1, STRING2, STRING3, ...) |
返回将 STRING2, STRING3, … 与分隔符 STRING1 连接起来的字符串。在要连接的字符串之间添加分隔符。
如果 STRING1 为 NULL ,则返回 NULL 。与 concat() 相比,concat_ws() 会自动跳过 NULL 参数。
例如 concat_ws('~', 'AA', Null(STRING), 'BB', '', 'CC') 返回 "AA~BB~~CC" .
|
LPAD(string1, integer, string2) | STRING1.lpad(INT, STRING2) |
返回从 string1 靠左填充 string2 到 integer 长度的新字符串。如果 string1 的长度小于 INT 值,则返回 string1 缩
短到 integer 长度的字符串。例如 LPAD('hi', 4, '??') 返回 "??hi" ;LPAD('hi', 1, '??') 返回 `“h”。
|
RPAD(string1, integer, string2) | STRING1.rpad(INT, STRING2) |
返回从 string1 靠右边填充 string2 到 integer 长度的新字符串。如果 string1 的长度小于 integer 值,则返回 string1 缩
短到 integer 长度的新字符串。例如 RPAD('hi', 4, '??') 返回 "hi??" , RPAD('hi', 1, '??') 返回 "h" 。
|
FROM_BASE64(string) | STRING.fromBase64() |
返回字符串 string 的 base64 解码的结果;如果字符串 string 为 NULL ,则返回 NULL 。
例如 FROM_BASE64('aGVsbG8gd29ybGQ=') 返回 "hello world" 。
|
TO_BASE64(string) | STRING.toBase64() |
返回字符串 string 的 base64 编码的结果;如果字符串 string 为 NULL ,则返回 NULL 。
例如 TO_BASE64('hello world') 返回 "aGVsbG8gd29ybGQ=" 。
|
ASCII(string) | STRING.ascii() |
返回字符串 string 第一个字符的数值。如果字符串为 NULL 则返回 NULL 。
例如 ascii('abc') 返回 97 ,ascii(CAST(NULL AS VARCHAR)) 返回 NULL 。
|
CHR(integer) | INT.chr() |
返回二进制等于 integer 的 ASCII 字符。如果整数 integer 大于 255,我们先将整数 integer 对 255 取模数,
并返回模数的 CHR。如果整数为 NULL ,则返回 NULL 。例如 chr(97) 返回 a ,chr(353) 返回 a ,
ascii(CAST(NULL AS VARCHAR)) 返回 NULL 。
|
DECODE(binary, string) | BINARY.decode(STRING) | 使用提供的字符集 string(‘US-ASCII’,‘ISO-8859-1’,‘UTF-8’,‘UTF-16BE’,‘UTF-16LE’,‘UTF-16’)解码第一个参数 binary 为字符串。 如果任一参数为空,则结果也将为空。 |
ENCODE(string1, string2) | STRING1.encode(STRING2) | 使用提供的字符集 string2(‘US-ASCII’,‘ISO-8859-1’,‘UTF-8’,‘UTF-16BE’,‘UTF-16LE’,‘UTF-16’)将字符串 string1 编码。 如果任一参数为空,则结果也将为空。 |
INSTR(string1, string2) | STRING1.instr(STRING2) |
返回 string2 在 string1 中第一次出现的位置。如果有任一参数为 NULL ,则返回 NULL 。
|
LEFT(string, integer) | STRING.LEFT(INT) |
返回字符串中最左边的长度为 integer 值的字符串。如果 integer 为负,则返回 EMPTY 字符串。如果有任一参数
为 NULL 则返回 NULL 。
|
RIGHT(string, integer) | STRING.RIGHT(INT) |
返回字符串中最右边的长度为 integer 值的字符串。如果 integer 为负,则返回 EMPTY 字符串。如果有任一参数
为 NULL 则返回 NULL 。
|
LOCATE(string1, string2[, integer]) | STRING1.locate(STRING2[, INTEGER]) |
返回 string2 中 string1 在位置 integer 之后第一次出现的位置。未找到返回 0。如果有任一参数为 NULL 则返回 NULL 。
|
PARSE_URL(string1, string2[, string3]) | STRING1.parseUrl(STRING2[, STRING3]) |
从 URL 返回指定的部分。string2 的有效值包括“HOST”,“PATH”,“QUERY”,“REF”,“PROTOCOL”,“AUTHORITY”,“FILE”和“USERINFO”。
如果有任一参数为 NULL ,则返回 NULL 。例如
parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'HOST') 返回 'facebook.com' 。
还可以通过提供关键词 string3 作为第三个参数来提取 QUERY 中特定键的值。例如
parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'QUERY', 'k1') 返回 'v1' 。
|
REGEXP(string1, string2) | STRING1.regexp(STRING2) |
如果 string1 的任何(可能为空)子字符串与 Java 正则表达式 string2 匹配,则返回 TRUE,否则返回 FALSE。
如果有任一参数为 NULL ,则返回 NULL 。
|
REVERSE(string) | STRING.reverse() |
返回反转的字符串。如果字符串为 NULL ,则返回 NULL 。
|
SPLIT_INDEX(string1, string2, integer1) | STRING1.splitIndex(STRING2, INTEGER1) |
通过分隔符 string2 拆分 string1,返回分隔后这组字符串的第 integer(从0开始)个字符串。如果 integer 为负,则返回 NULL 。
如果有任一参数为 NULL ,则返回 NULL 。
|
STR_TO_MAP(string1[, string2, string3]) | STRING1.strToMap([STRING2, STRING3]) |
使用分隔符将 string1 拆分为键值对后返回一个 map。string2 是 pair 分隔符,默认为 ‘,’。string3 是键值分隔符,默认为 ‘=’。
pair 分隔符与键值分隔符均为正则表达式,当使用特殊字符作为分隔符时请提前进行转义,例如 <([{\^-=$!|]})?*+.> 。
|
SUBSTR(string, integer1[, integer2]) | STRING.substr(INTEGER1[, INTEGER2]) | 返回字符串的子字符串,从位置 integer1 开始,长度为 integer2(默认到末尾)。 |
时间函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
DATE string | STRING.toDate() | 以“yyyy-MM-dd”的形式返回从字符串解析的 SQL 日期。 |
TIME string | STRING.toTime() | 以“HH:mm:ss”的形式返回从字符串解析的 SQL 时间。 |
TIMESTAMP string | STRING.toTimestamp() | 以“yyyy-MM-dd HH:mm:ss[.SSS]”的形式返回从字符串解析的 SQL 时间戳。 |
INTERVAL string range | 不适用 |
从“dd hh:mm:ss.fff”形式的字符串解析 SQL 毫秒间隔或者从“yyyy-mm”形式的字符串解析 SQL 月数间隔。间隔范围可以
是 DAY,MINUTE,DAY TO HOUR 或 DAY TO SECOND,以毫秒为间隔;YEAR 或 YEAR TO MONTH 表示几个月的间隔。例
如 INTERVAL '10 00:00:00.004' DAY TO SECOND,INTERVAL '10' DAY 或 INTERVAL '2-10' YEAR TO MONTH 返回间隔。
|
不适用 | NUMERIC.year | NUMERIC.years | 创建 NUMERIC 年的月间隔。 |
不适用 | NUMERIC.quarter | NUMERIC.quarters |
为 NUMERIC 季度创建月间隔。例如 2.quarters 返回 6 。
|
不适用 | NUMERIC.month | NUMERIC.months | 创建 NUMERIC 个月的间隔。 |
不适用 | NUMERIC.week | NUMERIC.weeks | 为 NUMERIC 周创建毫秒间隔。例如 2.weeks 返回 1209600000。 |
不适用 | NUMERIC.day | NUMERIC.days | 创建 NUMERIC 天的毫秒间隔。 |
不适用 | NUMERIC.hour | NUMERIC.hours | 创建 NUMERIC 小时的毫秒间隔。 |
不适用 | NUMERIC.minute | NUMERIC.minutes | 创建 NUMERIC 分钟的毫秒间隔。 |
不适用 | NUMERIC.second | NUMERIC.seconds | 创建 NUMERIC 秒的毫秒间隔。 |
不适用 | NUMERIC.milli | NUMERIC.millis | 创建 NUMERIC 毫秒的毫秒间隔。 |
LOCALTIME | localTime() | 返回本地时区的当前 SQL 时间,返回类型为 TIME(0)。在流模式下为每条记录进行取值。 但在批处理模式下,它在查询开始时计算一次,并对每一行使用相同的结果。 |
LOCALTIMESTAMP | localTimestamp() | 返回本地时区的当前 SQL 时间戳,返回类型为 TIMESTAMP(3)。在流模式下为每条记录进行取值。 但在批处理模式下,它在查询开始时计算一次,并对每一行使用相同的结果。 |
CURRENT_TIME | currentTime() | 返回本地时区的当前 SQL 时间,这是 LOCAL_TIME 的同义词。 |
CURRENT_DATE | currentDate() | 返回本地时区中的当前 SQL 日期。在流模式下为每条记录进行取值。 但在批处理模式下,它在查询开始时计算一次,并对每一行使用相同的结果。 |
CURRENT_TIMESTAMP | currentTimestamp() | 返回本地时区的当前 SQL 时间戳,返回类型为 TIMESTAMP_LTZ(3)。在流模式下为每条记录进行取值。 但在批处理模式下,它在查询开始时计算一次,并对每一行使用相同的结果。 |
NOW() | 不适用 | 返回本地时区的当前 SQL 时间戳,这是 CURRENT_TIMESTAMP 的同义词。 |
CURRENT_ROW_TIMESTAMP() | 不适用 | 返回本地时区的当前 SQL 时间戳,返回类型为 TIMESTAMP_LTZ(3)。无论是在批处理模式还是流模式下,都会为每条记录进行取值。 |
EXTRACT(timeinteravlunit FROM temporal) | TEMPORAL.extract(TIMEINTERVALUNIT) |
返回从时间 temporal 的时间间隔单位部分 timeinteravlunit 提取的 long 值。例如 EXTRACT(DAY FROM DATE '2006-06-05') 返回 5。
|
YEAR(date) | 不适用 |
从 SQL 日期 date 返回年份。相当于 EXTRACT(YEAR FROM date)。例如 YEAR(DATE '1994-09-27') 返回 1994。
|
QUARTER(date) | 不适用 |
从 SQL 日期 date 返回一年中的季度(1 到 4 之间的整数)。相当于 EXTRACT(QUARTER FROM date)。
例如 QUARTER(DATE '1994-09-27') 返回 3。
|
MONTH(date) | 不适用 |
从 SQL 日期 date 返回一年中的月份(1 到 12 之间的整数)。相当于 EXTRACT(MONTH FROM date)。
例如 MONTH(DATE '1994-09-27') 返回 9。
|
WEEK(date) | 不适用 |
从 SQL 日期 date 返回一年中的第几周(1 到 53 之间的整数)。相当于 EXTRACT(WEEK FROM date)。
例如 WEEK(DATE '1994-09-27') 返回 39。
|
DAYOFYEAR(date) | 不适用 |
从 SQL 日期 date 返回一年中的第几天(1 到 366 之间的整数)。相当于 EXTRACT(DOY FROM date)。
例如 DAYOFYEAR(DATE '1994-09-27') 返回 270。
|
DAYOFMONTH(date) | 不适用 |
从 SQL 日期 date 返回一个月中的第几天(1 到 31 之间的整数)。相当于 EXTRACT(DAY FROM date)。
例如 DAYOFMONTH(DATE '1994-09-27') 返回 27。
|
DAYOFWEEK(date) | 不适用 |
从 SQL 日期 date 返回一个星期中的第几天(1 到 7 之间的整数)。相当于 EXTRACT(DOW FROM date)。
例如 DAYOFWEEK(DATE '1994-09-27') 返回 3。
|
HOUR(timestamp) | 不适用 |
从 SQL 时间戳 timestamp 返回小时单位部分的小时(0 到 23 之间的整数)数。相当于 EXTRACT(HOUR FROM timestamp)。
例如 MINUTE(TIMESTAMP '1994-09-27 13:14:15') 返回 14。
|
MINUTE(timestamp) | 不适用 |
从 SQL 时间戳 timestamp 返回分钟单位的分钟数(0 到 59 之间的整数)。相当于 EXTRACT(MINUTE FROM timestamp)。
例如 MINUTE(TIMESTAMP '1994-09-27 13:14:15') 返回 14。
|
SECOND(timestamp) | 不适用 |
从 SQL 时间戳 timestamp 返回秒单位部分的秒数(0 到 59 之间的整数)。相当于 EXTRACT(SECOND FROM timestamp)。
例如 SECOND(TIMESTAMP '1994-09-27 13:14:15') 返回 15。
|
FLOOR(timepoint TO timeintervalunit) | TIMEPOINT.floor(TIMEINTERVALUNIT) |
返回将时间点 timepoint 向下取值到时间单位 timeintervalunit 的值。例如 FLOOR(TIME '12:44:31' TO MINUTE)
返回 12:44:00。
|
CEIL(timespoint TO timeintervaluntit) | TIMEPOINT.ceil(TIMEINTERVALUNIT) |
返回将时间点 timespoint 向上取值到时间单位 timeintervaluntit 的值。例如 CEIL(TIME '12:44:31' TO MINUTE)
返回 12:45:00。
|
(timepoint1, temporal1) OVERLAPS (timepoint2, temporal2) | temporalOverlaps(TIMEPOINT1, TEMPORAL1, TIMEPOINT2, TEMPORAL2) |
如果由 (timepoint1, temporal1) 和 (timepoint2, temporal2) 定义的两个时间间隔重叠,则返回 TRUE。
时间值 temporal1 可以是时间点或时间间隔。例如
(TIME '2:55:00', INTERVAL '1' HOUR) OVERLAPS (TIME '3:30:00', INTERVAL '2' HOUR) 返回 TRUE;
(TIME '9:00:00', TIME '10:00:00') OVERLAPS (TIME '10:15:00', INTERVAL '3' HOUR) 返回 FALSE。
|
DATE_FORMAT(timestamp, string) | dateFormat(TIMESTAMP, STRING) | 将时间戳 timestamp 转换为日期格式字符串 string 指定格式的字符串值。格式字符串与 Java 的 SimpleDateFormat 兼容。 |
TIMESTAMPADD(timeintervalunit, interval, timepoint) | 不适用 | |
TIMESTAMPDIFF(timepointunit, timepoint1, timepoint2) | timestampDiff(TIMEPOINTUNIT, TIMEPOINT1, TIMEPOINT2) | 返回 timepoint1 和 timepoint2 之间时间间隔。间隔的单位由第一个参数给出,它应该是以下值之一: SECOND,MINUTE,HOUR,DAY,MONTH 或 YEAR。 |
CONVERT_TZ(string1, string2, string3) | convertTz(STRING1, STRING2, STRING3) |
将日期时间 string1(具有默认 ISO 时间戳格式 ‘yyyy-MM-dd HH:mm:ss’)从时区 string2 转换为时区 string3 的值。
时区的格式应该是缩写如“PST”,全名如“America/Los_Angeles”,或自定义 ID 如“GMT-08:00”。例如
CONVERT_TZ('1970-01-01 00:00:00', 'UTC', 'America/Los_Angeles') 返回 '1969-12-31 16:00:00 ’。
|
FROM_UNIXTIME(numeric[, string]) | fromUnixtime(NUMERIC[, STRING]) | 以格式 string(默认为 ‘yyyy-MM-dd HH:mm:ss’)表示数字参数 numberic 的值。numeric 是一个内部 时间戳值,表示自'1970-01-01 00:00:00’ UTC 以来的秒数,由 UNIX_TIMESTAMP() 函数生成。返回值以会话时区表示 (在 TableConfig 中指定)。例如,如果在 UTC 时区,FROM_UNIXTIME(44) 返回 ‘1970-01-01 00:00:44’,如果在 ‘Asia/Tokyo’ 时区,则返回 ‘1970-01-01 09:00:44’。 |
UNIX_TIMESTAMP() | unixTimestamp() | 以秒为单位获取当前的 Unix 时间戳。此函数不是确定性的,这意味着将为每个记录重新计算该值。 |
UNIX_TIMESTAMP(string1[, string2]) | unixTimestamp(STRING1[, STRING2]) |
使用表配置中指定的时区将格式为 string2 的日期时间字符串 string1(如果未指定默认情况下:yyyy-MM-dd HH:mm:ss) 转换为 Unix 时间戳(以秒为单位)。 如果时间戳字符串指定了时区并使用 UTC+X 的格式解析(例如:“yyyy-MM-dd HH:mm:ss.SSS X”),此函数将会使用时间戳字符串中的时区来转换,而不是 Flink 会话中所配置的时区。 如果时间戳字符串无法正常解析,此函数将会默认返回 Long.MIN_VALUE(即: -9223372036854775808)作为结果。
|
TO_DATE(string1[, string2]) | toDate(STRING1[, STRING2]) | 将格式为 string2(默认为 ‘yyyy-MM-dd’)的字符串 string1 转换为日期。 |
TO_TIMESTAMP_LTZ(numeric, precision) | toTimestampLtz(numeric, PRECISION) |
将纪元秒或纪元毫秒转换为 TIMESTAMP_LTZ,有效精度为 0 或 3,0 代表 TO_TIMESTAMP_LTZ(epochSeconds, 0) ,
3 代表 TO_TIMESTAMP_LTZ(epochMilliseconds, 3) 。
|
TO_TIMESTAMP(string1[, string2]) | toTimestamp(STRING1[, STRING2]) | 将格式为 string2(默认为:‘yyyy-MM-dd HH:mm:ss’)的字符串 string1 转换为 timestamp,不带时区。 |
CURRENT_WATERMARK(rowtime) | 不适用 |
返回给定时间列属性 rowtime 的当前水印,如果管道中的当前操作没有可用的上游操作的公共水印时则为 请注意,此函数可以返回
|
条件函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
CASE value WHEN value1_1 [, value1_2]* THEN RESULT1 (WHEN value2_1 [, value2_2 ]* THEN result_2)* (ELSE result_z) END | 不适用 |
当值 value 第一次满足在 (valueX_1, valueX_2, …) 中时,返回对应的结果 resultX。当没有匹配到时,如果提供了 result_z 则返回 result_z,
否则返回 NULL 。
|
CASE WHEN condition1 THEN result1 (WHEN condition2 THEN result2)* (ELSE result_z) END | 不适用 |
满足第一个条件 X 时返回 resultX。当不满足任何条件时,如果提供了 result_z 则返回 result_z,否则返回 NULL 。
|
NULLIF(value1, value2) | 不适用 |
如果 value1 等于 value2 返回 NULL ;否则返回 value1。例如 NULLIF(5, 5) 返回 NULL ;NULLIF(5, 0) 返回 5。
|
COALESCE(value1, value2 [, value3]*) | 不适用 |
| 从 value1, value2, … 返回第一个不为
|
IF(condition, true_value, false_value) | 不适用 |
如果满足条件,返回 true_value,否则返回 false_value。例如 IF(5 > 3, 5, 3) 返回 5。
|
IFNULL(input, null_replacement) | input.ifNull(nullReplacement) |
如果输入为 与 COALESCE 或 CASE WHEN 相比,此函数返回的数据类型在是否为空方面非常明确。返回的类型是两个参数的公共类型,但只有在 null_replacement 可为空时才能为可空类型。 该函数允许将可空的列传递到使用 NOT NULL 约束声明的函数或表中。 例如 |
IS_ALPHA(string) | 不适用 |
如果字符串中的所有字符都是字母,则返回 true ,否则返回 false 。
|
IS_DECIMAL(string) | 不适用 |
如果 string 可以解析为有效数字,则返回 true ,否则返回 false 。
|
IS_DIGIT(string) | 不适用 |
如果字符串中的所有字符都是数字,则返回 true ,否则返回 false 。
|
不适用 | BOOLEAN.?(VALUE1, VALUE2) |
如果 BOOLEAN 计算结果为 TRUE,则返回 VALUE1;否则返回 VALUE2。例如 (42 > 5).?('A', 'B') 返回 "A" 。
|
GREATEST(value1[, value2]*) | 不适用 | 返回所有输入参数的最大值,如果输入参数中包含 NULL,则返回 NULL。 |
LEAST(value1[, value2]*) | 不适用 | 返回所有输入参数的最小值,如果输入参数中包含 NULL,则返回 NULL。 |
类型转换函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
CAST(value AS type) | ANY.cast(TYPE) |
返回 value 被转换为类型 type 的新值。CAST错误会抛出异常并导致作业失败。为了处理错误,在使用可能失败的 CAST 操作时,例如 STRING 转换为 INT,建议使用 TRY_CAST 替代。 如果开启了 “table.exec.legacy-cast-behaviour”,CAST 行为将变得与 TRY_CAST 一致。 例如, CAST(‘42’ AS INT) 返回 42; CAST(NULL AS STRING) 返回字符串类型的 |
TRY_CAST(value AS type) | ANY.tryCast(TYPE) |
TRY_CAST 行为与 CAST 相似, 但在遇到错误时 TRY_CAST 会返回 NULL 而不是使作业失败。
例如:TRY_CAST(‘42’ AS INT) 返回 42; TRY_CAST(NULL AS STRING) 返回字符串类型的 NULL ; TRY_CAST(’non-number’ AS INT) 返回 INT 类型的 NULL ; COALESCE(TRY_CAST(’non-number’ AS INT), 0) 返回 INT 类型的 0。
|
TYPEOF(input) | TYPEOF(input, force_serializable) | call("TYPEOF", input) | call("TYPEOF", input, force_serializable) |
返回输入表达式的数据类型的字符串表示。默认情况下返回的字符串是一个摘要字符串,可能会为了可读性而省略某些细节。
如果 force_serializable 设置为 TRUE,则字符串表示可以持久化保存在 catalog 中的完整数据类型。
请注意,特别是匿名的内联数据类型没有可序列化的字符串表示。在这种情况下返回 NULL 。
|
集合函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
CARDINALITY(array) | ARRAY.cardinality() | 返回数组中元素的数量。 |
array ‘[’ INT ‘]’ | ARRAY.at(INT) | 返回数组中 INT 位置的元素。索引从 1 开始。 |
ELEMENT(array) | ARRAY.element() |
返回数组的唯一元素(其基数应为 1);如果数组为空,则返回 NULL 。如果数组有多个元素,则抛出异常。
|
CARDINALITY(map) | MAP.cardinality() | 返回 map 中的 entries 数量。 |
map ‘[’ value ‘]’ | MAP.at(ANY) | 返回 map 中指定 key 对应的值。 |
ARRAY_CONTAINS(haystack, needle) | haystack.arrayContains(needle) | 返回是否数组 haystack 中包含指定元素 needle。支持检查数组中是否存在 null。 如果数组本身是null,函数会返回 null。如果需要,指定元素会隐式转换为数组的元素类型。 |
ARRAY_DISTINCT(haystack) | haystack.arrayDistinct() | 返回没有重复元素的新数组。如果数组本身是null,函数会返回 null。函数会保留数组中元素的顺序。 |
ARRAY_POSITION(haystack, needle) | haystack.arrayPosition(needle) | 返回数组中第一次出现 needle 元素的位置,返回类型为 int。如果数组中不存在该元素则返回 0。如果两个参数中任何一个参数为 null,则返回 null。序号不是从 0 开始,而是从 1 开始,第一个元素的序号为 1。 |
ARRAY_REMOVE(haystack, needle) | haystack.arrayRemove(needle) | 删除数组中所有和元素 needle 相等的元素。如果数组是 null,则返回 null。函数会保留数组中元素的顺序。 |
ARRAY_REVERSE(haystack) | haystack.arrayReverse() | 翻转并返回数组 haystack。 如果数组是 null,则返回 null。 |
ARRAY_SLICE(array, start_offset[, end_offset]) | array.arraySlice(start_offset[, end_offset]) | 返回输入数组的子数组,位于“start_offset”和“end_offset”之间 包含“start_offset”和“end_offset”)。偏移量从 1 开始,但 0 也被视为数组的开头。正值从数组开头开始计数, 负值从数组末尾开始计数。如果省略“end_offset”,则该偏移量将被视为数组的长度。如果“start_offset”在 “end_offset”之后或者两者都超出数组范围,则将返回空数组。如果任何输入为 null,则返回 null。 |
ARRAY_UNION(array1, array2) | haystack.arrayUnion(array) | 返回由 array1 和 array2 的全部元素构成的数组,不包含重复元素。如果任意一个数组是 null,该函数返回 null。 |
ARRAY_CONCAT(array1, …) | array1.arrayConcat(...) | 返回一个数组,该数组是连接至少一个数组的结果。该数组包含第一个数组中的所有元素,然后是第二个数组中的所有元素,依此类推,直到第 N 个数组。如果任何输入数组为 NULL,则函数返回 NULL。 |
ARRAY_MAX(array) | array.arrayMax() | 返回数组中的最大值,如果数组是 null,则返回 null。 |
ARRAY_JOIN(array, delimiter[, nullReplacement]) | array.arrayJoin(delimiter[, nullReplacement]) | 返回一个字符串,表示给定数组中元素的串联,并且给定数组中元素的数据类型为字符串。 分隔符 delimiter 是一个字符串,用于分隔数组的每对连续元素。 可选的参数 nullReplacement 是一个字符串,用于替换数组中的 null 元素。 如果未指定 nullReplacement,则结果字符串中将从数组中省略 null 元素。 如果输入数组或分隔符或 nullReplacement 为 null,则返回 null。 |
MAP_KEYS(map) | MAP.mapKeys() | 以数组形式返回 map 中的所有 key,不保证顺序。 |
MAP_VALUES(map) | MAP.mapValues() | 以数组形式返回 map 中的所有 value,不保证顺序。 |
MAP_ENTRIES(map) | MAP.mapEntries() | 以数组形式返回 map 中的所有 entry,不保证顺序。 |
MAP_FROM_ARRAYS(array_of_keys, array_of_values) | mapFromArrays(array_of_keys, array_of_values) | 返回由 key 的数组 keys 和 value 的数组 values 创建的 map。请注意两个数组的长度应该相等。 |
JSON 函数 #
JSON 函数使用符合 ISO/IEC TR 19075-6 SQL标准的 JSON 路径表达式。 它们的语法受到 ECMAScript 的启发,并 采用了 ECMAScript 的许多功能,但不是其子集或超集。
路径表达式有宽容模式和严格模式两种模式。 当不指定时,默认使用严格模式。
严格模式旨在从 Schema 的角度检查数据,并且只要数据不符合路径表达式就会抛出错误。 但是像JSON_VALUE
的函数
允许定义遇到错误时的后备行为。 另一方面,宽容模式更加宽容,并将错误转换为空序列。
特殊字符$
表示 JSON 路径中的根节点。 路径可以访问属性($.a
), 数组元素 ($.a[0].b
),或遍历数组中的
所有元素 ($.a[*].b
)。
已知限制:
- 目前,并非宽容模式的所有功能都被正确支持。 这是一个上游的错误(CALCITE-4717)。无法保证行为符合标准。
SQL 函数 | Table 函数 | 描述 |
---|---|---|
IS JSON [ { VALUE | SCALAR | ARRAY | OBJECT } ] | STRING.isJson([JsonType type]) |
判定给定字符串是否为有效的 JSON。 指定可选参数 type 将会限制 JSON 对象所允许的类型。
如果字符串是有效的 JSON,但不是指定的类型,则返回
|
JSON_EXISTS(jsonValue, path [ { TRUE | FALSE | UNKNOWN | ERROR } ON ERROR ]) | STRING.jsonExists(STRING path [, JsonExistsOnError onError]) |
判定 JSON 字符串是否满足给定的路径搜索条件。 如果要忽略错误行为,那么将
|
JSON_STRING(value) | jsonString(value) |
将值序列化为 JSON。 此函数返回一个包含序列化值的 JSON 字符串。如果值为
|
JSON_VALUE(jsonValue, path [RETURNING |
STRING.jsonValue(STRING path [, returnType, onEmpty, defaultOnEmpty, onError, defaultOnError]) |
从 JSON 字符串中提取标量。 此方法搜索给定路径表达式的 JSON 字符串,如果该路径上的值是标量则返回该值。不能返回非标量值。默认情况下返回值类型为
对于空路径表达式或错误,可以将行为定义为返回 对于路径表达式中包含特殊字符(如空格),你可以使用
|
JSON_QUERY(jsonValue, path [ { WITHOUT | WITH CONDITIONAL | WITH UNCONDITIONAL } [ ARRAY ] WRAPPER ] [ { NULL | EMPTY ARRAY | EMPTY OBJECT | ERROR } ON EMPTY ] [ { NULL | EMPTY ARRAY | EMPTY OBJECT | ERROR } ON ERROR ]) | STRING.jsonQuery(path [, JsonQueryWrapper [, JsonQueryOnEmptyOrError, JsonQueryOnEmptyOrError ] ]) |
从 JSON 字符串中提取 JSON 值。 结果总是以
|
JSON_OBJECT([[KEY] key VALUE value]* [ { NULL | ABSENT } ON NULL ]) | jsonObject(JsonOnNull, keyValues...) |
将键值对列表构建为 JSON 对象字符串。 注意,键必须是非 这个函数返回一个 JSON 字符串。 值是由另一个 JSON 构造函数调用 (
|
JSON_ARRAY([value]* [ { NULL | ABSENT } ON NULL ]) | jsonArray(JsonOnNull, values...) |
将数值列表构建为 JSON 数组字符串。 这个函数返回一个 JSON 字符串,值可以是任意表达式。 元素是由另一个 JSON 构造函数调用 (
|
值构建函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
implicit constructor with parenthesis (value1 [, value2]*) explicit ROW constructor with ROW(value1 [, value2]*) |
row(ANY1, ANY2, ...) | 返回从值列表 (value1, value2, …) 创建的行。隐式行构造函数至少需要两个字段。显式行构造函数可以处理任意数量的字段。 两者都支持任意表达式作为字段 |
ARRAY ‘[’ value1 [, value2 ]* ‘]’ | array(ANY1, ANY2, ...) | 返回从值列表 (value1, value2, …) 创建的数组。 |
MAP ‘[’ value1, value2 [, value3, value4 ]* ‘]’ | map(ANY1, ANY2, ANY3, ANY4, ...) | 返回从键值对列表 ((value1, value2), (value3, value4), …) 创建的 map。 |
不适用 | NUMERIC.rows | 创建一个 NUMERIC 行间隔(通常用于窗口创建)。 |
值获取函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
tableName.compositeType.field | COMPOSITE.get(STRING) COMPOSITE.get(INT) | 按名称从 Flink 复合类型(例如,Tuple,POJO)返回字段的值。 |
tableName.compositeType.* | ANY.flatten() |
返回 Flink 复合类型(例如,Tuple,POJO)的平面表示,将其每个直接子类型转换为单独的字段。在大多数情况下,平面表示
的字段与原始字段的命名类似,但使用 $ 分隔符(例如 mypojo$mytuple$f0)。
|
分组函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
GROUP_ID() | 不适用 | 返回唯一标识分组键组合的整数。 |
GROUPING(expression1 [, expression2]* ) GROUPING_ID(expression1 [, expression2]* ) | 不适用 | 返回给定分组表达式的位向量。 |
哈希函数 #
SQL 函数 | Table 函数 | 描述 |
---|---|---|
MD5(string) | STRING.md5() |
以 32 位十六进制数字的字符串形式返回 string 的 MD5 哈希值;如果字符串为 NULL ,则返回 NULL 。
|
SHA1(string) | STRING.sha1() |
以 40 位十六进制数字的字符串形式返回 string 的 SHA-1 哈希值;如果字符串为 NULL ,则返回 NULL 。
|
SHA224(string) | STRING.sha224() |
以 56 位十六进制数字的字符串形式返回 string 的 SHA-224 哈希值;如果字符串为 NULL ,则返回 NULL 。
|
SHA256(string) | STRING.sha256() |
以 64 位十六进制数字的字符串形式返回 string 的 SHA-256 哈希值;如果字符串为 NULL ,则返回 NULL 。
|
SHA384(string) | STRING.sha384() |
以 96 位十六进制数字的字符串形式返回 string 的 SHA-384 哈希值;如果字符串为 NULL ,则返回 NULL 。
|
SHA512(string) | STRING.sha512() |
以 128 位十六进制数字的字符串形式返回 string 的 SHA-512 哈希值;如果字符串为 NULL ,则返回 NULL 。
|
SHA2(string, hashLength) | STRING.sha2(INT) |
使用 SHA-2 系列散列函数(SHA-224,SHA-256,SHA-384 或 SHA-512)返回散列值。第一个参数 string 是要散列的字符串,
第二个参数 hashLength 是结果的位数(224,256,384 或 512)。如果 string 或 hashLength 为 NULL ,则返回 NULL 。
|
辅助函数 #
SQL 函数 | Table 函数 | 描述 |
---|
聚合函数 #
聚合函数将所有的行作为输入,并返回单个聚合值作为结果。
SQL 函数 | Table 函数 | 描述 |
---|---|---|
COUNT([ ALL ] expression | DISTINCT expression1 [, expression2]*) | 不适用 |
默认情况下或使用关键字 ALL ,返回不为 NULL 的表达式的输入行数。使用 DISTINCT 则对所有值去重后计算。
|
COUNT(*) | COUNT(1) | FIELD.count | 返回输入行数。 |
AVG([ ALL | DISTINCT ] expression) | FIELD.avg |
默认情况下或使用关键字 ALL ,返回所有输入行中表达式的平均值(算术平均值)。使用 DISTINCT 则对所有值去重后计算。
|
SUM([ ALL | DISTINCT ] expression) | FIELD.sum |
默认情况下或使用关键字 ALL ,返回所有输入行的表达式总和。使用 DISTINCT 则对所有值去重后计算。
|
不适用 | FIELD.sum0 |
返回所有输入行的数字字段 FIELD 的总和。如果所有值都为 NULL ,则返回 0。
|
MAX([ ALL | DISTINCT ] expression) | FIELD.max |
默认情况下或使用关键字 ALL ,返回所有输入行中表达式的最大值。使用 DISTINCT 则对所有值去重后计算。
|
MIN([ ALL | DISTINCT ] expression ) | FIELD.min |
默认情况下或使用关键字 ALL ,返回所有输入行中表达式的最小值。使用 DISTINCT 则对所有值去重后计算。
|
STDDEV_POP([ ALL | DISTINCT ] expression) | FIELD.stddevPop |
默认情况下或使用关键字 ALL ,返回所有输入行中表达式的总体标准偏差。使用 DISTINCT 则对所有值去重后计算。
|
STDDEV_SAMP([ ALL | DISTINCT ] expression) | FIELD.stddevSamp |
默认情况下或使用关键字 ALL ,返回所有输入行中表达式的样本标准偏差。使用 DISTINCT 则对所有值去重后计算。
|
VAR_POP([ ALL | DISTINCT ] expression) | FIELD.varPop |
默认情况下或使用关键字 ALL ,返回所有输入行中表达式的总体方差(总体标准差的平方)。使用 DISTINCT 则对所有值去重后计算。
|
VAR_SAMP([ ALL | DISTINCT ] expression) | FIELD.varSamp |
默认情况下或使用关键字 ALL ,返回所有输入行中表达式的样本方差(样本标准差的平方)。使用 DISTINCT 则对所有值去重后计算。
|
COLLECT([ ALL | DISTINCT ] expression) | FIELD.collect |
默认情况下或使用关键字 ALL ,返回跨所有输入行的多组表达式。NULL 值将被忽略。使用 DISTINCT 则对所有值去重后计算。
|
VARIANCE([ ALL | DISTINCT ] expression) | 不适用 | VAR_SAMP() 的同义方法。 |
RANK() | 不适用 | 返回值在一组值中的排名。结果是 1 加上分区顺序中当前行之前或等于当前行的行数。排名在序列中不一定连续。 |
DENSE_RANK() | 不适用 | 返回值在一组值中的排名。结果是一加先前分配的等级值。与函数 rank 不同,dense_rank 不会在排名序列中产生间隙。 |
ROW_NUMBER() | 不适用 | 在窗口分区内根据 rows 的排序为每一行分配一个唯一的序列号,从 1 开始。ROW_NUMBER 和 RANK 相似。ROW_NUMBER 按 顺序对所有行进行编号(例如 1,2,3,4,5)。RANK 为等值 row 提供相同的序列值(例如 1,2,2,4,5)。 |
LEAD(expression [, offset] [, default]) | 不适用 |
返回窗口中当前行之后第 offset 行处的表达式值。offset 的默认值为 1,default 的默认值为 NULL 。
|
LAG(expression [, offset] [, default]) | 不适用 |
返回窗口中当前行之前第 offset 行处的表达式值。offset 的默认值为 1,default 的默认值为 NULL 。
|
FIRST_VALUE(expression) | FIELD.firstValue | 返回一组有序值中的第一个值。 |
LAST_VALUE(expression) | FIELD.lastValue | 返回一组有序值中的最后一个值。 |
LISTAGG(expression [, separator]) | FIELD.listagg | 连接字符串表达式的值并在它们之间放置分隔符值。字符串末尾不添加分隔符。分隔符的默认值为“,”。 |
CUME_DIST() | 不适用 | 返回值在一组值的累积分布。结果是小于或等于当前行的值的行数除以窗口分区的总行数。 |
PERCENT_RANK() | 不适用 | 返回值在一组值的百分比排名。结果是当前行在窗口分区中的排名减 1,然后除以窗口分区的总行数减 1。如果窗口分区的总行数为 1,则该函数返回 0。 |
NTILE(n) | 不适用 | 将窗口分区中的所有数据按照顺序划分为 n 个分组,返回分配给各行数据的分组编号(从 1 开始,最大为 n)。 如果不能均匀划分为 n 个分组,则剩余值从第 1 个分组开始,为每一分组分配一个。 比如某个窗口分区有 6 行数据,划分为 4 个分组,则各行的分组编号为:1,1,2,2,3,4。 |
JSON_OBJECTAGG([KEY] key VALUE value [ { NULL | ABSENT } ON NULL ]) | jsonObjectAgg(JsonOnNull, keyExpression, valueExpression) |
通过将 key-value 聚合到单个 JSON 对象中,构建 JSON 对象字符串。 键表达式必须返回不为空的字符串。值表达式可以是任意的,包括其他 JSON 函数。
如果值为 请注意,键必须是唯一的。如果一个键出现多次,将抛出一个错误。 目前在
|
JSON_ARRAYAGG(items [ { NULL | ABSENT } ON NULL ]) | jsonArrayAgg(JsonOnNull, itemExpression) |
通过将字段聚合到数组中构建 JSON 对象字符串。 项目表达式可以是任意的,包括其他 JSON 函数。如果值为 此函数目前不支持
|
时间间隔单位和时间点单位标识符 #
下表列出了时间间隔单位和时间点单位标识符。
对于 Table API,请使用 _
代替空格(例如 DAY_TO_HOUR
)。
时间间隔单位 | 时间点单位 |
---|---|
MILLENNIUM |
|
CENTURY |
|
DECADE |
|
YEAR |
YEAR |
YEAR TO MONTH |
|
QUARTER |
QUARTER |
MONTH |
MONTH |
WEEK |
WEEK |
DAY |
DAY |
DAY TO HOUR |
|
DAY TO MINUTE |
|
DAY TO SECOND |
|
HOUR |
HOUR |
HOUR TO MINUTE |
|
HOUR TO SECOND |
|
MINUTE |
MINUTE |
MINUTE TO SECOND |
|
SECOND |
SECOND |
MILLISECOND |
MILLISECOND |
MICROSECOND |
MICROSECOND |
NANOSECOND |
|
EPOCH |
|
DOY (仅适用SQL) |
|
DOW (仅适用SQL) |
|
ISODOW (仅适用SQL) |
|
ISOYEAR (仅适用SQL) |
|
SQL_TSI_YEAR (仅适用SQL) |
|
SQL_TSI_QUARTER (仅适用SQL) |
|
SQL_TSI_MONTH (仅适用SQL) |
|
SQL_TSI_WEEK (仅适用SQL) |
|
SQL_TSI_DAY (仅适用SQL) |
|
SQL_TSI_HOUR (仅适用SQL) |
|
SQL_TSI_MINUTE (仅适用SQL) |
|
SQL_TSI_SECOND (仅适用SQL) |
列函数 #
列函数用于选择或丢弃表的列。
列函数仅在 Table API 中使用。
语法 | 描述 |
---|---|
withColumns(…) | 选择指定的列 |
withoutColumns(…) | 选择除指定列以外的列 |
withAllColumns() | select all columns (like SELECT * in SQL) |
详细语法如下:
列函数:
withColumns(columnExprs)
withoutColumns(columnExprs)
withAllColumns()
多列表达式:
columnExpr [, columnExpr]*
单列表达式:
columnRef | columnIndex to columnIndex | columnName to columnName
列引用:
columnName(The field name that exists in the table) | columnIndex(a positive integer starting from 1)
列函数的用法如下表所示(假设我们有一个包含 5 列的表:(a: Int, b: Long, c: String, d:String, e: String)
):
接口 | 用法举例 | 描述 |
---|---|---|
withColumns($(*)) | select(withColumns($("*"))) = select($(“a”), $(“b”), $(“c”), $(“d”), $(“e”)) | 全部列 |
withColumns(m to n) | select(withColumns(range(2, 4))) = select($(“b”), $(“c”), $(“d”)) | 第 m 到第 n 列 |
withColumns(m, n, k) | select(withColumns(lit(1), lit(3), $(“e”))) = select($(“a”), $(“c”), $(“e”)) | 第 m、n、k 列 |
withColumns(m, n to k) | select(withColumns(lit(1), range(3, 5))) = select($(“a”), $(“c”), $(“d”), $(“e”)) | 以上两种用法的混合 |
withoutColumns(m to n) | select(withoutColumns(range(2, 4))) = select($(“a”), $(“e”)) | 不选从第 m 到第 n 列 |
withoutColumns(m, n, k) | select(withoutColumns(lit(1), lit(3), lit(5))) = select($(“b”), $(“d”)) | 不选第 m、n、k 列 |
withoutColumns(m, n to k) | select(withoutColumns(lit(1), range(3, 5))) = select($(“b”)) | 以上两种用法的混合 |
列函数可用于所有需要列字段的地方,例如 select、groupBy、orderBy、UDFs
等函数,例如:
table
.groupBy(withColumns(range(1, 3)))
.select(withColumns(range("a", "b")), myUDAgg(myUDF(withColumns(range(5, 20)))));
table
.groupBy(withColumns(range(1, 3)))
.select(withColumns('a to 'b), myUDAgg(myUDF(withColumns(5 to 20))))
table
.group_by(with_columns(range_(1, 3)))
.select(with_columns(range_('a', 'b')), myUDAgg(myUDF(with_columns(range_(5, 20)))))