系统(内置)函数
This documentation is for an unreleased version of Apache Flink. We recommend you use the latest stable version.

系统(内置)函数 #

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 的数据类型和值都相同返回 FALSENULL 视为与任何其他值相同。 例如 1 IS DISTINCT FROM NULL 返回 TRUENULL IS DISTINCT FROM NULL 返回 FALSE
value1 IS NOT DISTINCT FROM value2 不适用 A 和 B 的数据类型和值都相同返回 TRUE。A 和 B 的数据类型和值不完全相同则返回 FALSENULL 视为与任何其他值相同。 例如 1 IS NOT DISTINCT FROM NULL 返回 FALSENULL 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 时,返回 FALSEUNKNOWN。 例如 12 BETWEEN 15 AND 12 返回 FALSE12 BETWEEN SYMMETRIC 15 AND 12 返回 TRUE12 BETWEEN 10 AND NULL 返回 UNKNOWN12 BETWEEN NULL AND 10 返回 FALSE12 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 时,返回 TRUEUNKNOWN。 例如 12 NOT BETWEEN 15 AND 12 返回 TRUE12 NOT BETWEEN SYMMETRIC 15 AND 12 返回 FALSE12 NOT BETWEEN NULL AND 15 返回 UNKNOWN12 NOT BETWEEN 15 AND NULL 返回 TRUE12 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) 返回 FALSE1 IN (1, 2, NULL) 返回 TRUE4 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) 返回 TRUE1 NOT IN (1, 2, NULL) 返回 FALSE4 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 时, 返回 FALSEUNKNOWN
不适用 value1.notBetween(value2, value3) 如果 value1 大于或等于 value2 且小于或等于 value3 返回 FALSE。当 value2 或 value3 为 NULL 时, 返回 TRUEUNKNOWN

逻辑函数 #

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 为 TRUEUNKNOWN 返回 FALSE
boolean IS NOT FALSE BOOLEAN.isNotFalse 如果 boolean 为 TRUEUNKNOWN 返回 TRUE;如果 boolean 为 FALSE 返回 FALSE
boolean IS TRUE BOOLEAN.isTrue 如果 boolean 为 TRUE 返回 TRUE;如果 boolean 为 FALSEUNKNOWN 返回 FALSE
boolean IS NOT TRUE BOOLEAN.isNotTrue 如果 boolean 为 FALSEUNKNOWN 返回 TRUE;如果 boolean 为 TRUE 返回 FALSE
boolean IS UNKNOWN 不适用 如果 boolean 为 UNKNOWN 返回 TRUE;如果 boolean 为 TRUEFALSE 返回 FALSE
boolean IS NOT UNKNOWN 不适用 如果 boolean 为 TRUEFALSE 返回 TRUE;如果 boolean 为 UNKNOWN 返回 FALSE

算术函数 #

SQL 函数 Table 函数 描述
  • numeric
+ NUMERIC 返回 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') 返回 97ascii(CAST(NULL AS VARCHAR)) 返回 NULL
CHR(integer) INT.chr() 返回二进制等于 integer 的 ASCII 字符。如果整数 integer 大于 255,我们先将整数 integer 对 255 取模数, 并返回模数的 CHR。如果整数为 NULL,则返回 NULL。例如 chr(97) 返回 achr(353) 返回 aascii(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' DAYINTERVAL '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)作为结果。

Flink SQL> SET 'table.local-time-zone' = 'Europe/Berlin';

-- 返回 25201
Flink SQL> SELECT UNIX_TIMESTAMP('1970-01-01 08:00:01.001', 'yyyy-MM-dd HH:mm:ss.SSS');
-- 返回 1
Flink SQL> SELECT UNIX_TIMESTAMP('1970-01-01 08:00:01.001 +0800', 'yyyy-MM-dd HH:mm:ss.SSS X');
-- 返回 25201
Flink SQL> SELECT UNIX_TIMESTAMP('1970-01-01 08:00:01.001 +0800', 'yyyy-MM-dd HH:mm:ss.SSS');
-- 返回 -9223372036854775808
Flink SQL> SELECT UNIX_TIMESTAMP('1970-01-01 08:00:01.001', 'yyyy-MM-dd HH:mm:ss.SSS X');
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 的当前水印,如果管道中的当前操作没有可用的上游操作的公共水印时则为 NULL。 函数的返回类型被推断为与提供的时间列属性匹配,但调整后的精度为 3。例如时间列属性为 TIMESTAMP_LTZ(9),则函数将返回 TIMESTAMP_LTZ(3)。

请注意,此函数可以返回 NULL,您可能必须考虑这种情况。例如,如果您想过滤掉迟到数据,您可以使用:

WHERE
  CURRENT_WATERMARK(ts) IS NULL
  OR ts > CURRENT_WATERMARK(ts)

条件函数 #

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) 返回 NULLNULLIF(5, 0) 返回 5。
COALESCE(value1, value2 [, value3]*) 不适用

| 从 value1, value2, … 返回第一个不为 NULL 的值。例如 COALESCE(3, 5, 3) 返回 3。 如果所有参数为 NULL,返回 NULL。返回类型是所有参数的限制最最少的通用类型,如果所有参数是可空的类型,返回类型也是可空的类型。

-- 返回 f0,f1中第一个非空的值,如果 f0 和 f1 都是 NULL,则返回 'default' COALESCE(f0, f1, 'default') ```
IF(condition, true_value, false_value) 不适用 如果满足条件,返回 true_value,否则返回 false_value。例如 IF(5 > 3, 5, 3) 返回 5。
IFNULL(input, null_replacement) input.ifNull(nullReplacement)

如果输入为 NULL,则返回 null_replacement;否则返回 input。

与 COALESCE 或 CASE WHEN 相比,此函数返回的数据类型在是否为空方面非常明确。返回的类型是两个参数的公共类型,但只有在 null_replacement 可为空时才能为可空类型。 该函数允许将可空的列传递到使用 NOT NULL 约束声明的函数或表中。

例如 IFNULL(nullable_column, 5) 一定不返回 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) 返回字符串类型的 NULL; CAST(’non-number’ AS INT) 抛出异常且作业失败。

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_APPEND(array, element) array.arrayAppend(element) Appends an element to the end of the array and returns the result. If the array itself is null, the function will return null. If an element to add is null, the null element will be added to the end of the array.
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_PREPEND(array, element) array.arrayPrepend(element) Appends an element to the beginning of the array and returns the result. If the array itself is null, the function will return null. If an element to add is null, the null element will be added to the beginning of the array.
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,但不是指定的类型,则返回 false。默认值为 VALUE

-- TRUE
'1' IS JSON
'[]' IS JSON
'{}' IS JSON

-- TRUE
'"abc"' IS JSON
-- FALSE
'abc' IS JSON
NULL IS JSON

-- TRUE
'1' IS JSON SCALAR
-- FALSE
'1' IS JSON ARRAY
-- FALSE
'1' IS JSON OBJECT

-- FALSE
'{}' IS JSON SCALAR
-- FALSE
'{}' IS JSON ARRAY
-- TRUE
'{}' IS JSON OBJECT
JSON_EXISTS(jsonValue, path [ { TRUE | FALSE | UNKNOWN | ERROR } ON ERROR ]) STRING.jsonExists(STRING path [, JsonExistsOnError onError])

判定 JSON 字符串是否满足给定的路径搜索条件。

如果要忽略错误行为,那么将 FALSE ON ERROR 设为默认值。

-- TRUE
SELECT JSON_EXISTS('{"a": true}', '$.a');
-- FALSE
SELECT JSON_EXISTS('{"a": true}', '$.b');
-- TRUE
SELECT JSON_EXISTS('{"a": [{ "b": 1 }]}',
  '$.a[0].b');

-- TRUE
SELECT JSON_EXISTS('{"a": true}',
  'strict $.b' TRUE ON ERROR);
-- FALSE
SELECT JSON_EXISTS('{"a": true}',
  'strict $.b' FALSE ON ERROR);
JSON_STRING(value) jsonString(value)

将值序列化为 JSON。

此函数返回一个包含序列化值的 JSON 字符串。如果值为 NULL,函数返回 NULL

-- NULL
JSON_STRING(CAST(NULL AS INT))

-- '1'
JSON_STRING(1)
-- 'true'
JSON_STRING(TRUE)
-- '"Hello, World!"'
JSON_STRING('Hello, World!')
-- '[1,2]'
JSON_STRING(ARRAY[1, 2])
JSON_VALUE(jsonValue, path [RETURNING ] [ { NULL | ERROR | DEFAULT } ON EMPTY ] [ { NULL | ERROR | DEFAULT } ON ERROR ]) STRING.jsonValue(STRING path [, returnType, onEmpty, defaultOnEmpty, onError, defaultOnError])

从 JSON 字符串中提取标量。

此方法搜索给定路径表达式的 JSON 字符串,如果该路径上的值是标量则返回该值。不能返回非标量值。默认情况下返回值类型为 STRING。 可以将 dataType 设置不同的类型,支持的类型如下所示:

  • VARCHAR / STRING
  • BOOLEAN
  • INTEGER
  • DOUBLE

对于空路径表达式或错误,可以将行为定义为返回 null、引发错误或返回定义的默认值。当省略时,默认为 NULL ON EMPTYNULL ON ERROR。默认值可以是文字或表达式。如果默认值本身引发错误,就会造成 ON EMPTY 的错误行为,并引发 ON ERROR 的错误。

对于路径表达式中包含特殊字符(如空格),你可以使用['property']["property"]来引用父对象中指定的属性。请确保在属性名两侧加上单引号或双引号。 当在 SQL 使用 JSON_VALUE 时,路径作为一个字符串参数已经被单引号引用了,因此你必须将属性名上的单引号转义,如JSON_VALUE('{"a b": "true"}', '$.[''a b'']')

-- "true"
JSON_VALUE('{"a": true}', '$.a')

-- TRUE
JSON_VALUE('{"a": true}', '$.a' RETURNING BOOLEAN)

-- "false"
JSON_VALUE('{"a": true}', 'lax $.b'
    DEFAULT FALSE ON EMPTY)

-- "false"
JSON_VALUE('{"a": true}', 'strict $.b'
    DEFAULT FALSE ON ERROR)

-- 0.998D
JSON_VALUE('{"a.b": [0.998,0.996]}','$.["a.b"][0]'
    RETURNING DOUBLE)

-- "right"
JSON_VALUE('{"contains blank": "right"}', 'strict $.[''contains blank'']' NULL ON EMPTY DEFAULT 'wrong' ON ERROR)
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 值。

结果总是以 STRING 的形式返回。目前尚不支持 RETURNING 子句。

wrappingBehavior 决定是否将提取的值包装到一个数组中,以及是否无条件地这样做,还是只有当值本身不是数组时才这样做。

onEmptyonError 分别决定路径表达式为空或引发错误时的行为。默认情况下,这两种情况都会返回 null。其他选择是 使用空数组、空对象或引发错误。

-- '{ "b": 1 }'
JSON_QUERY('{ "a": { "b": 1 } }', '$.a')
-- '[1, 2]'
JSON_QUERY('[1, 2]', '$')
-- NULL
JSON_QUERY(CAST(NULL AS STRING), '$')
-- '["c1","c2"]'
JSON_QUERY('{"a":[{"c":"c1"},{"c":"c2"}]}',
    'lax $.a[*].c')

-- 将结果包装到数组中
-- '[{}]'
JSON_QUERY('{}', '$' WITH CONDITIONAL ARRAY WRAPPER)
-- '[1, 2]'
JSON_QUERY('[1, 2]', '$' WITH CONDITIONAL ARRAY WRAPPER)
-- '[[1, 2]]'
JSON_QUERY('[1, 2]', '$' WITH UNCONDITIONAL ARRAY WRAPPER)

-- 必须包装标量才能返回
-- NULL
JSON_QUERY(1, '$')
-- '[1]'
JSON_QUERY(1, '$' WITH CONDITIONAL ARRAY WRAPPER)

-- 路径表达式为空/存在错误时的行为
-- '{}'
JSON_QUERY('{}', 'lax $.invalid' EMPTY OBJECT ON EMPTY)
-- '[]'
JSON_QUERY('{}', 'strict $.invalid' EMPTY ARRAY ON ERROR)
JSON_OBJECT([[KEY] key VALUE value]* [ { NULL | ABSENT } ON NULL ]) jsonObject(JsonOnNull, keyValues...)

将键值对列表构建为 JSON 对象字符串。

注意,键必须是非 NULL 字符串字面值,而值可以是任意表达式。

这个函数返回一个 JSON 字符串。ON NULL 行为定义了如何处理 NULL 值。如果省略,则默认为 NULL ON NULL

值是由另一个 JSON 构造函数调用 (JSON_OBJECTJSON_ARRAY) 直接插入所创建,而不是作为一个字符串。它允许构建嵌套的 JSON 结构。

-- '{}'
JSON_OBJECT()

-- '{"K1":"V1","K2":"V2"}'
JSON_OBJECT('K1' VALUE 'V1', 'K2' VALUE 'V2')

-- 表达式作为值
JSON_OBJECT('orderNo' VALUE orders.orderId)

-- ON NULL
JSON_OBJECT(KEY 'K1' VALUE CAST(NULL AS STRING) NULL ON NULL)   -- '{"K1":null}'
JSON_OBJECT(KEY 'K1' VALUE CAST(NULL AS STRING) ABSENT ON NULL) -- '{}'

-- '{"K1":{"K2":"V"}}'
JSON_OBJECT(
  KEY 'K1'
  VALUE JSON_OBJECT(
    KEY 'K2'
    VALUE 'V'
  )
)
JSON_ARRAY([value]* [ { NULL | ABSENT } ON NULL ]) jsonArray(JsonOnNull, values...)

将数值列表构建为 JSON 数组字符串。

这个函数返回一个 JSON 字符串,值可以是任意表达式。ON NULL 行为定义了如何处理 NULL 值。如果省略,则假定 ABSENT ON NULL 为默认值。

元素是由另一个 JSON 构造函数调用 (JSON_OBJECTJSON_ARRAY) 直接插入所创建,而不是作为一个字符串。它允许构建嵌套的 JSON 结构。

-- '[]'
JSON_ARRAY()
-- '[1,"2"]'
JSON_ARRAY(1, '2')

-- 表达式作为值
JSON_ARRAY(orders.orderId)

-- ON NULL
JSON_ARRAY(CAST(NULL AS STRING) NULL ON NULL) -- '[null]'
JSON_ARRAY(CAST(NULL AS STRING) ABSENT ON NULL) -- '[]'

-- '[[1]]'
JSON_ARRAY(JSON_ARRAY(1))

值构建函数 #

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。
ARRAY_AGG([ ALL | DISTINCT ] expression [ RESPECT NULLS | IGNORE NULLS ]) FIELD.arrayAgg 默认情况下或使用关键字ALL,返回输入行中表达式所组成的数组,并且如果没有输入行,则返回 NULL。使用 DISTINCT 则对所有值去重后计算。 默认情况下NULL 值不会被忽略,使用 IGNORE NULLS 忽略 NULL 值。 目前尚不支持 ORDER BY 子句。
JSON_OBJECTAGG([KEY] key VALUE value [ { NULL | ABSENT } ON NULL ]) jsonObjectAgg(JsonOnNull, keyExpression, valueExpression)

通过将 key-value 聚合到单个 JSON 对象中,构建 JSON 对象字符串。

键表达式必须返回不为空的字符串。值表达式可以是任意的,包括其他 JSON 函数。 如果值为 NULL,则 ON NULL 行为定义了要执行的操作。如果省略,默认情况下假定为 NULL ON NULL

请注意,键必须是唯一的。如果一个键出现多次,将抛出一个错误。

目前在 OVER windows 中不支持此函数。

-- '{"Apple":2,"Banana":17,"Orange":0}'
SELECT
  JSON_OBJECTAGG(KEY product VALUE cnt)
FROM orders
JSON_ARRAYAGG(items [ { NULL | ABSENT } ON NULL ]) jsonArrayAgg(JsonOnNull, itemExpression)

通过将字段聚合到数组中构建 JSON 对象字符串。

项目表达式可以是任意的,包括其他 JSON 函数。如果值为 NULL,则 ON NULL 行为定义了要执行的操作。如果省略,默认情况下假定为 ABSENT ON NULL

此函数目前不支持 OVER windows、未绑定的 session windows 或 hop windows。

-- '["Apple","Banana","Orange"]'
SELECT
  JSON_ARRAYAGG(product)
FROM orders

时间间隔单位和时间点单位标识符 #

下表列出了时间间隔单位和时间点单位标识符。

对于 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)

Back to top

列函数 #

列函数用于选择或丢弃表的列。

列函数仅在 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)))))

Back to top