| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License |
| |
| comparison: |
| - sql: value1 = value2 |
| table: value1 === value2 |
| description: 如果 value1 等于 value2 返回 `TRUE`；如果 value1 或者 value2 为 `NULL` 返回 `UNKNOW`。 |
| - sql: value1 <> value2 |
| table: value1 !== value2 |
| description: 如果 value1 不等于 value2 返回 `TRUE`；如果 value1 或 value2 为 `NULL` 返回 `UNKNOWN`。 |
| - sql: value1 > value2 |
| table: value1 > value2 |
| description: 如果 value1 大于 value2 返回 `TRUE`；如果 value1 或 value2 为 `NULL` 返回 `UNKNOWN`。 |
| - sql: value1 >= value2 |
| table: value1 >= value2 |
| description: 如果 value1 大于或等于 value2 返回 `TRUE`；如果 value1 或 value2 为 `NULL` 返回 `UNKNOWN`。 |
| - sql: value1 < value2 |
| table: value1 < value2 |
| description: 如果 value1 小于 value2 返回 `TRUE`；如果 value1 或 value2 为 `NULL` 返回 `UNKNOWN`。 |
| - sql: value1 <= value2 |
| table: value1 <= value2 |
| description: 如果 value1 小于或等于 value2 返回 `TRUE`；如果 value1 或 value2 为 `NULL` 返回 `UNKNOWN`。 |
| - sql: value IS NULL |
| table: value.isNull |
| description: 如果值为 `NULL` 返回 `TRUE`。 |
| - sql: value IS NOT NULL |
| table: value.isNotNull |
| description: 如果值不为 `NULL` 返回 `TRUE`。 |
| - sql: value1 IS DISTINCT FROM value2 |
| description: | |
| A 和 B 的数据类型和值不完全相同返回 `TRUE`。A 和 B 的数据类型和值都相同返回 `FALSE`。将 `NULL` 视为相同。 |
| 例如 `1 IS DISTINCT FROM NULL` 返回 `TRUE`；`NULL IS DISTINCT FROM NULL` 返回 `FALSE`。 |
| - sql: value1 IS NOT DISTINCT FROM value2 |
| description: | |
| A 和 B 的数据类型和值都相同返回 `TRUE`。A 和 B 的数据类型和值不完全相同则返回 `FALSE`。将 `NULL` 视为相同。 |
| 例如 `1 IS NOT DISTINCT FROM NULL` 返回 `FALSE`；`NULL IS NOT DISTINCT FROM NULL` 返回 `TRUE`。 |
| - sql: value1 BETWEEN [ ASYMMETRIC | SYMMETRIC ] value2 AND value3 |
| description: | |
| 默认或使用 `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`。 |
| - sql: value1 NOT BETWEEN [ ASYMMETRIC | SYMMETRIC ] value2 AND value3 |
| description: | |
| 默认或使用 `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`。 |
| - sql: string1 LIKE string2 [ ESCAPE char ] |
| table: string1.like(string2) |
| description: | |
| 如果 string1 匹配 string2 返回 `TRUE`；如果 string1 或 string2 为 `NULL` 返回 `UNKNOWN`。 |
| 如果需要可以定义转义字符。尚不支持转义字符。 |
| - sql: string1 NOT LIKE string2 [ ESCAPE char ] |
| description: | |
| 如果 string1 与 string2 不匹配返回 `TRUE`；如果 string1 或 string2 为 `NULL` 返回 `UNKNOWN`。 |
| 如果需要可以定义转义字符。尚不支持转义字符。 |
| - sql: string1 SIMILAR TO string2 [ ESCAPE char ] |
| table: string1.similar(string2) |
| description: | |
| 如果 string1 匹配 SQL 正则表达式 string2 返回 `TRUE`；如果 string1 或 string2 为 `NULL` 返回 |
| `UNKNOWN`。如果需要可以定义转义字符。尚不支持转义字符。 |
| - sql: string1 NOT SIMILAR TO string2 [ ESCAPE char ] |
| description: | |
| 如果 string1 与 SQL 正则表达式 string2 不匹配返回 `TRUE`；如果 string1 或 string2 为 `NULL` 返回 |
| `UNKNOWN`。如果需要可以定义转义字符。尚不支持转义字符。 |
| - sql: value1 IN (value2 [, value3]* ) |
| table: value1.in(valu2) |
| description: | |
| 在给定列表 (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`。 |
| - sql: value1 NOT IN (value2 [, value3]* ) |
| description: | |
| 在给定列表 (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`。 |
| - sql: EXISTS (sub-query) |
| description: | |
| 如果子查询至少返回一行则返回 `TRUE`。 仅支持可以在 join 和分组操作中可以被重写的操作。对于流式查询，该操作在 join |
| 和分组操作中被重写。根据输入行的数量计算查询结果所需的状态可能会无限增长。请提供具有有效保留间隔的查询配置，以防止状态过大。 |
| - sql: value IN (sub-query) |
| table: value1.in(TABLE) |
| description: 如果 value 等于子查询结果集中的一行则返回 `TRUE`。 |
| - sql: value NOT IN (sub-query) |
| description: 如果 value 不包含于子查询返回的行则返回 `TRUE`。 |
| - table: value1.between(value2, value3) |
| description: | |
| 如果 value1 大于或等于 value2 且小于或等于 value3 返回 `TRUE`。当 value2 或 value3 为 `NULL` 时， |
| 返回 `FALSE` 或 `UNKNOWN`。 |
| - table: value1.notBetween(value2, value3) |
| description: | |
| 如果 value1 大于或等于 value2 且小于或等于 value3 返回 `FALSE`。当 value2 或 value3 为 `NULL` 时， |
| 返回 `TRUE` 或 `UNKNOWN`。 |
| |
| logical: |
| - sql: boolean1 OR boolean2 |
| table: BOOLEAN1 || BOOLEAN2 |
| description: | |
| 如果 boolean1 为 `TRUE` 或 boolean2 为 `TRUE` 返回 `TRUE`。支持三值逻辑。 |
| 例如 `true || Null(BOOLEAN)` 返回 `TRUE`。 |
| - sql: boolean1 AND boolean2 |
| table: BOOLEAN1 && BOOLEAN2 |
| description: | |
| 如果 boolean1 和 boolean2 都为 `TRUE` 返回 `TRUE`。支持三值逻辑。 |
| 例如 `true && Null(BOOLEAN)` 返回 `UNKNOWN`。 |
| - sql: NOT boolean |
| table: BOOLEAN.not(), not(BOOLEAN), or '!BOOLEAN' (Scala only) |
| description: | |
| 如果布尔值为 `FALSE` 返回 `TRUE`；如果布尔值为 `TRUE` 返回 `FALSE`；如果布尔值为 `UNKNOWN` |
| 返回 `UNKNOWN`。 |
| - sql: boolean IS FALSE |
| table: BOOLEAN.isFalse |
| description: 如果布尔值为 `FALSE` 返回 `TRUE`；如果 boolean 为 `TRUE` 或 `UNKNOWN` 返回 `FALSE`。 |
| - sql: boolean IS NOT FALSE |
| table: BOOLEAN.isNotFalse |
| description: 如果 boolean 为 `TRUE` 或 `UNKNOWN` 返回 `TRUE`；如果 boolean 为 `FALSE` 返回 `FALSE`。 |
| - sql: boolean IS TRUE |
| table: BOOLEAN.isTrue |
| description: 如果 boolean 为 `TRUE` 返回 `TRUE`；如果 boolean 为 `FALSE` 或 `UNKNOWN` 返回 `FALSE`。 |
| - sql: boolean IS NOT TRUE |
| table: BOOLEAN.isNotTrue |
| description: 如果 boolean 为 `FALSE` 或 `UNKNOWN` 返回 `TRUE`；如果布尔值为 `TRUE` 返回 `FALSE`。 |
| - sql: boolean IS UNKNOWN |
| description: 如果布尔值为 `UNKNOWN` 返回 `TRUE`；如果 boolean 为 `TRUE` 或 `FALSE` 返回 `FALSE`。 |
| - sql: boolean IS NOT UNKNOWN |
| description: 如果 boolean 为 `TRUE` 或 `FALSE` 返回 `TRUE`；如果布尔值为 `UNKNOWN` 返回 `FALSE`。 |
| |
| arithmetic: |
| - sql: + numeric |
| table: + NUMERIC |
| description: 返回 numeric。 |
| - sql: '- numeric' |
| table: '- NUMERIC' |
| description: 返回 numeric 的相反数。 |
| - sql: numeric1 + numeric2 |
| table: NUMERIC1 + NUMERIC2 |
| description: 返回 numeric1 加 numeric2。 |
| - sql: numeric1 - numeric2 |
| table: NUMERIC1 + NUMERIC2 |
| description: 返回 numeric1 减 numeric2。 |
| - sql: numeric1 * numberic2 |
| table: NUMERIC1 * NUMERIC2 |
| description: 返回 numeric1 乘以 numeric2。 |
| - sql: numeric1 / numeric2 |
| table: NUMERIC1 / NUMERIC2 |
| description: 返回 numeric1 除以 numeric2。 |
| - sql: numeric1 % numeric2 |
| table: MOD(NUMERIC1, NUMERIC2) |
| description: 返回 numeric1 除以 numeric2 的余数（模数）。仅当 numeric1 为负时，结果才为负。 |
| - sql: POWER(numeric1, numeric2) |
| table: NUMERIC1.power(NUMERIC2) |
| description: 返回 numeric1 的 numeric2 次方。 |
| - sql: ABS(numeric) |
| table: NUMERIC.abs() |
| description: 返回 numeric 的绝对值。 |
| - sql: SQRT(numeric) |
| table: NUMERIC.sqrt() |
| description: 返回 numeric 的平方根。 |
| - sql: LN(numeric) |
| table: NUMERIC.ln() |
| description: 返回 numeric 的自然对数（以 e 为底）。 |
| - sql: LOG10(numeric) |
| table: NUMERIC.log10() |
| description: 返回以 10 为底的 numeric 的对数。 |
| - sql: LOG2(numeric) |
| table: NUMERIC.log2() |
| description: 返回以 2 为底的 numeric 的对数。 |
| - sql: | |
| LOG(numeric2) |
| LOG(numeric1, numeric2) |
| table: | |
| NUMERIC1.log() |
| NUMERIC1.log(NUMERIC2) |
| description: | |
| 当用一个参数调用时，返回 numeric2 的自然对数。当使用两个参数调用时，此函数返回 numeric2 以 numeric1 |
| 为底的对数。numeric2 必须大于 0，numeric1 必须大于 1。 |
| - sql: EXP(numeric) |
| table: NUMERIC.exp() |
| description: 返回 e 的 numeric 次幂。 |
| - sql: | |
| CEIL(numeric) |
| CEILING(numeric) |
| table: | |
| NUMERIC.ceil() |
| NUMERIC.ceiling() |
| description: 向上取整，并返回大于或等于 numeric 的最小整数。 |
| - sql: FLOOR(numeric) |
| table: NUMERIC.floor() |
| description: 向下取整，并返回小于或等于 numeric 的最大整数。 |
| - sql: SIN(numeric) |
| table: NUMERIC.sin() |
| description: 返回 numeric 的正弦值。 |
| - sql: SINH(numeric) |
| table: NUMERIC.sinh() |
| description: 返回 numeric 的双曲正弦值。返回类型为 DOUBLE。 |
| - sql: COS(numeric) |
| table: NUMERIC.cos() |
| description: 返回 numeric 的余弦值。 |
| - sql: TAN(numeric) |
| table: NUMERIC.tan() |
| description: 返回 numeric 的正切值。 |
| - sql: TANH(numeric) |
| table: NUMERIC.tanh() |
| description: 返回 numeric 的双曲正切值。返回类型为 DOUBLE。 |
| - sql: COT(numeric) |
| table: NUMERIC.cot() |
| description: 返回 numeric 的余切值。 |
| - sql: ASIN(numeric) |
| table: NUMERIC.asin() |
| description: 返回 numeric 的反正弦值。 |
| - sql: ACOS(numeric) |
| table: NUMERIC.acos() |
| description: 返回 numeric 的反余弦值。 |
| - sql: ATAN(numeric) |
| table: NUMERIC.atan() |
| description: 返回 numeric 的反正切值。 |
| - sql: ATAN2(numeric1, numeric2) |
| table: atan2(NUMERIC1, NUMERIC2) |
| description: 返回坐标 (numeric1, numeric2) 的反正切。 |
| - sql: COSH(numeric) |
| table: NUMERIC.cosh() |
| description: 返回 numeric 的双曲余弦值。返回值类型为 DOUBLE。 |
| - sql: DEGREES(numeric) |
| table: NUMERIC.degrees() |
| description: 返回弧度 numeric 的度数表示。 |
| - sql: RADIANS(numeric) |
| table: NUMERIC.radians() |
| description: 返回度数 numeric 的弧度表示。 |
| - sql: SIGN(numeric) |
| table: NUMERIC.sign() |
| description: 返回 numeric 的符号。 |
| - sql: ROUND(numeric, INT) |
| table: NUMERIC.round(INT) |
| description: 返回 numeric 四舍五入保留 INT 小数位的值。 |
| - sql: PI() |
| table: pi() |
| description: 返回无比接近 pi 的值。 |
| - sql: E() |
| table: e() |
| description: 返回无比接近 e 的值。 |
| - sql: RAND() |
| table: rand() |
| description: 返回 [0.0, 1.0) 范围内的伪随机双精度值。 |
| - sql: RAND(INT) |
| table: rand(INT) |
| description: | |
| 返回范围为 [0.0, 1.0) 的伪随机双精度值，初始种子为 INT。 |
| 如果两个 RAND 函数具有相同的初始种子，它们将返回相同的数字序列。 |
| - sql: RAND_INTEGER(INT) |
| table: randInteger(INT) |
| description: 返回 [0.0, INT) 范围内的伪随机双精度值。 |
| - sql: RAND_INTEGER(INT1, INT2) |
| table: randInteger(INT1, INT2) |
| description: | |
| 返回范围为 [0.0, INT2) 的伪随机双精度值，初始种子为 INT1。 |
| 如果两个 RAND_INTGER 函数具有相同的初始种子和边界，它们将返回相同的数字序列。 |
| - sql: UUID() |
| table: uuid() |
| description: | |
| 根据 RFC 4122 类型 4（伪随机生成）UUID，返回 UUID（通用唯一标识符）字符串。 |
| 例如“3d3c68f7-f608-473f-b60c-b0c44ad4cc4e”，UUID 是使用加密强的伪随机数生成器生成的。 |
| - sql: BIN(INT) |
| table: INT.bin() |
| description: | |
| 以二进制格式返回 INTEGER 的字符串表示形式。如果 INTEGER 为 `NULL`，则返回 `NULL`。 |
| 例如 4.bin() 返回“100”，12.bin() 返回“1100”。 |
| - sql: | |
| HEX(numeric) |
| HEX(string) |
| table: | |
| NUMERIC.hex() |
| string.hex() |
| description: | |
| 以十六进制格式返回整数 numeric 值或 STRING 的字符串表示形式。如果参数为 `NULL`，则返回 `NULL`。 |
| 例如数字 20 返回“14”，数字 100 返回“64”，字符串“hello,world” 返回“68656C6C6F2C776F726C64”。 |
| - sql: TRUNCATE(numeric1, integer2) |
| table: NUMERIC1.truncate(INTEGER2) |
| description: | |
| 返回截取 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。 |
| |
| string: |
| - sql: string1 || string2 |
| table: STRING1 + STRING2 |
| description: 返回 STRING1 和 STRING2 的连接。 |
| - sql: | |
| CHAR_LENGTH(string) |
| CHARACTER_LENGTH(string) |
| table: STRING.charLength() |
| description: 返回字符串中的字符数。 |
| - sql: UPPER(string) |
| table: STRING.upperCase() |
| description: 以大写形式返回字符串。 |
| - sql: LOWER(string) |
| table: STRING.lowerCase() |
| description: 以小写形式返回字符串。 |
| - sql: POSITION(string1 IN string2) |
| table: STRING1.position(STRING2) |
| description: 返回 STRING2 中第一次出现 STRING1 的位置（从 1 开始）；如果在 STRING2 中找不到 STRING1 返回 0。 |
| - sql: TRIM([ BOTH | LEADING | TRAILING ] string1 FROM string2) |
| table: | |
| STRING1.trim(LEADING, STRING2) |
| STRING1.trim(TRAILING, STRING2) |
| STRING1.trim(BOTH, STRING2) |
| STRING1.trim(BOTH) |
| STRING1.trim() |
| description: 返回从 STRING1 中删除以字符串 STRING2 开头/结尾/开头且结尾的字符串的结果。默认情况下，两边的空格都会被删除。 |
| - sql: LTRIM(string) |
| table: STRING.ltrim() |
| description: | |
| 返回从 STRING 中删除左边空格的字符串。 |
| 例如 `' This is a test String.'.ltrim()` 返回 `'This is a test String.'`。 |
| - sql: RTRIM(string) |
| table: STRING.rtrim() |
| description: | |
| 返回从 STRING 中删除右边空格的字符串。 |
| 例如 `'This is a test String. '.ltrim()` 返回 `'This is a test String.'`。 |
| - sql: REPEAT(string, int) |
| table: STRING.repeat(INT) |
| description: | |
| 返回 INT 个 `string` 连接的字符串。 |
| 例如 `REPEAT('This is a test String.', 2)` 返回 `"This is a test String.This is a test String."`。 |
| - sql: REGEXP_REPLACE(string1, string2, string3) |
| table: STRING1.regexpReplace(STRING2, STRING3) |
| description: | |
| 返回 STRING1 所有与正则表达式 STRING2 匹配的子字符串被 STRING3 替换后的字符串。 |
| 例如 `'foobar'.regexpReplace('oo|ar', '')` 返回 `"fb"`。 |
| - sql: OVERLAY(string1 PLACING string2 FROM integer1 [ FOR integer2 ]) |
| table: | |
| STRING1.overlay(STRING2, INT1) |
| STRING1.overlay(STRING2, INT1, INT2) |
| description: | |
| 返回一个字符串，该字符串从位置 INT1 用 STRING2 替换 STRING1 的 INT2（默认为 STRING2 的长度）字符。 |
| 例如 `'xxxxxtest'.overlay('xxxx', 6)` 返回 `"xxxxxxxxx"`； |
| `'xxxxxtest'.overlay('xxxx', 6, 2)` 返回 `"xxxxxxxxxst"`。 |
| - sql: SUBSTRING(string FROM integer1 [ FOR integer2 ]) |
| table: | |
| STRING.substring(INT1) |
| STRING.substring(INT1, INT2) |
| description: 返回 STRING 从位置 INT1 开始，长度为 INT2（默认到结尾）的子字符串。 |
| - sql: REPLACE(string1, string2, string3) |
| table: STRING1.replace(STRING2, STRING3) |
| description: | |
| 返回一个新字符串，它用 STRING1 中的 STRING3（非重叠）替换所有出现的 STRING2。 |
| 例如 `'hello world'.replace('world', 'flink')` 返回 `'hello flink'`； |
| `'ababab'.replace('abab', 'z')` 返回 `'zab'`。 |
| - sql: REGEXP_EXTRACT(string1, string2[, integer]) |
| table: STRING1.regexpExtract(STRING2[, INTEGER1]) |
| description: | |
| 将字符串 STRING1 按照 STRING2 正则表达式的规则拆分，返回指定 INTEGER1 处位置的字符串。正则表达式匹配组索引从 1 开始， |
| 0 表示匹配整个正则表达式。此外，正则表达式匹配组索引不应超过定义的组数。 |
| 例如 `REGEXP_EXTRACT('foothebar', 'foo(.*?)(bar)', 2)` 返回 `"bar"`。 |
| - sql: INITCAP(string) |
| table: STRING.initCap() |
| description: | |
| 返回新形式的 STRING，其中每个单词的第一个字符转换为大写，其余字符转换为小写。这里的单词表示字母数字的字符序列。 |
| - sql: CONCAT(string1, string2, ...) |
| table: concat(STRING1, STRING2, ...) |
| description: | |
| 返回连接 string1，string2， ... 的字符串。如果有任一参数为 `NULL`，则返回 `NULL`。 |
| 例如 `CONCAT('AA', 'BB', 'CC')` 返回 `"AABBCC"`。 |
| - sql: CONCAT_WS(string1, string2, string3, ...) |
| table: concat_ws(STRING1, STRING2, STRING3, ...) |
| description: | |
| 返回将 STRING2， STRING3， ... 与分隔符 STRING1 连接起来的字符串。在要连接的字符串之间添加分隔符。 |
| 如果 STRING1 为 `NULL`，则返回 `NULL`。与 concat() 相比，concat_ws() 会自动跳过 `NULL` 参数。 |
| 例如 `concat_ws('~', 'AA', Null(STRING), 'BB', '', 'CC')` 返回 `"AA~BB~~CC"`. |
| - sql: LPAD(string1, integer, string2) |
| table: STRING1.lpad(INT, STRING2) |
| description: | |
| 返回从 string1 靠左填充 string2 到 INT 长度的新字符串。如果 string1 的长度小于 INT 值，则返回 string1 缩 |
| 短为整数字符。例如 `LPAD('hi', 4, '??')` 返回 `"??hi"`；`LPAD('hi', 1, '??')` 返回 `"h"。 |
| - sql: RPAD(string1, integer, string2) |
| table: STRING1.rpad(INT, STRING2) |
| description: | |
| 返回从 string1 靠右边填充 string2 到 INT 长度的新字符串。如果 string1 的长度小于 INT 值，则返回 string1 缩 |
| 短为长度为 INT 的新字符串。例如 `RPAD('hi', 4, '??')` 返回 `"hi??"`, `RPAD('hi', 1, '??')` 返回 `"h"`。 |
| - sql: FROM_BASE64(string) |
| table: STRING.fromBase64() |
| description: | |
| 返回字符串 string1 的 base64 解码的结果；如果字符串为 `NULL`，则返回 `NULL`。 |
| 例如 `FROM_BASE64('aGVsbG8gd29ybGQ=')` 返回 `"hello world"`。 |
| - sql: TO_BASE64(string) |
| table: STRING.toBase64() |
| description: | |
| 返回字符串 string 的 base64 编码的结果；如果字符串为 `NULL`，则返回 `NULL`。 |
| 例如 `TO_BASE64('hello world')` 返回 `"aGVsbG8gd29ybGQ="`。 |
| - sql: ASCII(string) |
| description: | |
| 返回字符串 string 第一个字符的数值。如果字符串为 `NULL` 则返回 `NULL`。 |
| 例如 `ascii('abc')` 返回 `97`，`ascii(CAST(NULL AS VARCHAR))` 返回 `NULL`。 |
| - sql: CHR(integer) |
| description: | |
| 返回二进制等于 integer 的 ASCII 字符。如果整数 integer 大于 255，我们先将得到整数对 255 取模数， |
| 并返回模数的 CHR。如果整数为 `NULL`，则返回 `NULL`。例如 `chr(97)` 返回 `a`，`chr(353)` 返回 `a`， |
| `ascii(CAST(NULL AS VARCHAR))` 返回 `NULL`。 |
| - sql: DECODE(binary, string) |
| description: | |
| 使用提供的字符集（'US-ASCII'，'ISO-8859-1'，'UTF-8'，'UTF-16BE'，'UTF-16LE'，'UTF-16'）解码。 |
| 如果任一参数为空，则结果也将为空。 |
| - sql: ENCODE(string1, string2) |
| description: | |
| 使用提供的字符集（'US-ASCII'，'ISO-8859-1'，'UTF-8'，'UTF-16BE'，'UTF-16LE'，'UTF-16'）编码。 |
| 如果任一参数为空，则结果也将为空。 |
| - sql: INSTR(string1, string2) |
| description: 返回 string2 在 string1 中第一次出现的位置。如果有任一参数为 `NULL`，则返回 `NULL`。 |
| - sql: LEFT(string, integer) |
| description: | |
| 返回字符串中最左边的长度为 integer 值的字符串。如果 integer 为负，则返回 `EMPTY` 字符串。如果有任一参数 |
| 为 `NULL` 则返回 `NULL`。 |
| - sql: RIGHT(string, integer) |
| description: | |
| 返回字符串中最右边的长度为 integer 值的字符串。如果 integer 为负，则返回 `EMPTY` 字符串。如果有任一参数 |
| 为 `NULL` 则返回 `NULL`。 |
| - sql: LOCATE(string1, string2[, integer]) |
| description: | |
| 返回 string2 中 string1 在位置 integer 之后第一次出现的位置。未找到返回 0。如果有任一参数为 `NULL` 则返回 `NULL`。 |
| - sql: PARSE_URL(string1, string2[, string3]) |
| description: | |
| 从 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'`。 |
| - sql: REGEXP(string1, string2) |
| description: | |
| 如果 string1 的任何（可能为空）子字符串与 Java 正则表达式 string2 匹配，则返回 TRUE，否则返回 FALSE。 |
| 如果有任一参数为 `NULL`，则返回 `NULL`。 |
| - sql: REVERSE(string) |
| description: 返回反转的字符串。如果字符串为 `NULL`，则返回 `NULL`。 |
| - sql: SPLIT_INDEX(string1, string2, integer1) |
| description: | |
| 通过分隔符 string2 拆分 string1，返回拆分字符串的第 integer（从零开始）个字符串。如果整数为负，则返回 `NULL`。 |
| 如果有任一参数为 `NULL`，则返回 `NULL`。 |
| - sql: STR_TO_MAP(string1[, string2, string3]]) |
| description: | |
| 使用分隔符将 string1 拆分为键值对后返回一个 map。string2 是 pair 分隔符，默认为 ','。string3 是键值分隔符，默认为 '='。 |
| - sql: SUBSTR(string[, integer1[, integer2]]) |
| description: 返回字符串的子字符串，从位置 integer1 开始，长度为 integer2（默认到末尾）。 |
| |
| temporal: |
| - sql: DATE string |
| table: STRING.toDate() |
| description: 以“yyyy-MM-dd”的形式返回从字符串解析的 SQL 日期。 |
| - sql: TIME string |
| table: STRING.toTime() |
| description: 以“HH:mm:ss”的形式返回从字符串解析的 SQL 时间。 |
| - sql: TIMESTAMP string |
| table: STRING.toTimestamp() |
| description: 以“yyyy-MM-dd HH:mm:ss[.SSS]”的形式返回从字符串解析的 SQL 时间戳。 |
| - sql: INTERVAL string range |
| description: | |
| 从“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` 返回间隔。 |
| - sql: YEAR(date) |
| table: numeric.year | numeric.years |
| description: 创建 numeric 年的月间隔。 |
| - table: numeric.quarter | numeric.quarters |
| description: 为 numeric 季度创建月间隔。例如 `2.quarters` 返回 `6`。 |
| - table: numeric.month | numeric.months |
| description: 创建 numeric 个月的间隔。 |
| - table: numeric.week | numeric.weeks |
| description: 为 numeric 周创建毫秒间隔。例如 2.weeks 返回 1209600000。 |
| - table: numeric.day | numeric.days |
| description: 创建 numeric 天的毫秒间隔。 |
| - table: numeric.hour | numeric.hours |
| description: 创建 numeric 小时的毫秒间隔。 |
| - table: numeric.minute | numeric.minutes |
| description: 创建 numeric 分钟的毫秒间隔。 |
| - table: numeric.second | numeric.seconds |
| description: 创建 numeric 秒的毫秒间隔。 |
| - table: numeric.milli | numeric.millis |
| description: 创建 numeric 毫秒的毫秒间隔。 |
| - sql: LOCALTIME |
| table: localTime() |
| description: | |
| 返回本地时区的当前 SQL 时间，返回类型为 TIME(0)。在流模式下为每条记录进行取值。 |
| 但在批处理模式下，它在查询开始时计算一次，并对每一行使用相同的结果。 |
| - sql: LOCALTIMESTAMP |
| table: localTimestamp() |
| description: | |
| 返回本地时区的当前 SQL 时间，返回类型为 TIMESTAMP(3)。在流模式下为每条记录进行取值。 |
| 但在批处理模式下，它在查询开始时计算一次，并对每一行使用相同的结果。 |
| - sql: CURRENT_TIME |
| table: currentTime() |
| description: 返回本地时区的当前 SQL 时间，这是 LOCAL_TIME 的同义词。 |
| - sql: CURRENT_DATE |
| table: currentDate() |
| description: | |
| 返回本地时区中的当前 SQL 日期。在流模式下为每条记录进行取值。 |
| 但在批处理模式下，它在查询开始时计算一次，并对每一行使用相同的结果。 |
| - sql: CURRENT_TIMESTAMP |
| table: currentTimestamp() |
| description: | |
| 返回本地时区的当前 SQL 时间戳，返回类型为 TIMESTAMP_LTZ(3)。在流模式下为每条记录进行取值。 |
| 但在批处理模式下，它在查询开始时计算一次，并对每一行使用相同的结果。 |
| - sql: NOW() |
| description: 返回本地时区的当前 SQL 时间戳，这是 CURRENT_TIMESTAMP 的同义词。 |
| - sql: CURRENT_ROW_TIMESTAMP() |
| description: | |
| 返回本地时区的当前 SQL 时间戳，返回类型为 TIMESTAMP_LTZ(3)。无论是在批处理模式还是流模式下，都会为每条记录进行取值。 |
| - sql: EXTRACT(timeinteravlunit FROM temporal) |
| table: TEMPORAL.extract(TIMEINTERVALUNIT) |
| description: 返回从时间的时间间隔单位部分提取的 long 值。例如 `EXTRACT(DAY FROM DATE '2006-06-05')` 返回 5。 |
| - sql: YEAR(date) |
| description: | |
| 从 SQL 日期 date 返回年份。相当于 EXTRACT(YEAR FROM date)。例如 `YEAR(DATE '1994-09-27')` 返回 1994。 |
| - sql: QUARTER(date) |
| description: | |
| 从 SQL 日期 date 返回一年中的季度（1 到 4 之间的整数）。相当于 EXTRACT(QUARTER FROM date)。 |
| 例如 `QUARTER(DATE '1994-09-27')` 返回 3。 |
| - sql: MONTH(date) |
| description: | |
| 从 SQL 日期 date 返回一年中的月份（1 到 12 之间的整数）。相当于 EXTRACT(MONTH FROM date)。 |
| 例如 `MONTH(DATE '1994-09-27')` 返回 9。 |
| - sql: WEEK(date) |
| description: | |
| 从 SQL 日期 date 返回一年中的第几周（1 到 53 之间的整数）。相当于 EXTRACT(WEEK FROM date)。 |
| 例如 `WEEK(DATE '1994-09-27')` 返回 39。 |
| - sql: DAYOFYEAR(date) |
| description: | |
| 从 SQL 日期 date 返回一年中的第几天（1 到 366 之间的整数）。相当于 EXTRACT(DOY FROM date)。 |
| 例如 `DAYOFYEAR(DATE '1994-09-27')` 返回 270。 |
| - sql: DAYOFMONTH |
| description: | |
| 从 SQL 日期 date 返回一个月中的第几天（1 到 31 之间的整数）。相当于 EXTRACT(DAY FROM date)。 |
| 例如 `DAYOFWEEK(DATE '1994-09-27')` 返回 3。 |
| - sql: HOUR(timestamp) |
| description: | |
| 从 SQL 时间戳 timestamp 返回小时单位部分的小时（0 到 23 之间的整数）数。相当于 EXTRACT(HOUR FROM timestamp)。 |
| 例如 `MINUTE(TIMESTAMP '1994-09-27 13:14:15')` 返回 14。 |
| - sql: MINUTE(timestamp) |
| description: | |
| 从 SQL 时间戳 timestamp 返回分钟单位的分钟数（0 到 59 之间的整数）。相当于 EXTRACT(MINUTE FROM timestamp)。 |
| 例如 `MINUTE(TIMESTAMP '1994-09-27 13:14:15')` 返回 14。 |
| - sql: SECOND(timestamp) |
| description: | |
| 从 SQL 时间戳 timestamp 返回秒单位部分的秒数（0 到 59 之间的整数）。相当于 EXTRACT(SECOND FROM timestamp)。 |
| 例如 `SECOND(TIMESTAMP '1994-09-27 13:14:15')` 返回 15。 |
| - sql: FLOOR(timepoint TO timeintervalunit) |
| table: TIMEPOINT.floor(TIMEINTERVALUNIT) |
| description: | |
| 返回将时间点 timepoint 向下取值到时间单位 timeintervalunit 的值。例如 `FLOOR(TIME '12:44:31' TO MINUTE)` |
| 返回 12:44:00。 |
| - sql: CEIL(timespoint TO timeintervaluntit) |
| table: TIMEPOINT.ceil(TIMEINTERVALUNIT) |
| description: | |
| 返回将时间点 timespoint 向上取值到时间单位 TIMEINTERVALUNIT 的值。例如 `CEIL(TIME '12:44:31' TO MINUTE)` |
| 返回 12:45:00。 |
| - sql: (timepoint1, temporal1) OVERLAPS (timepoint2, temporal2) |
| table: temporalOverlaps(TIMEPOINT1, TEMPORAL1, TIMEPOINT2, TEMPORAL2) |
| description: | |
| 如果由 (timepoint1, temporal1) 和 (timepoint2, temporal2) 定义的两个时间间隔重叠，则返回 TRUE。 |
| 时间值可以是时间点或时间间隔。例如 |
| `(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。 |
| - sql: DATE_FORMAT(timestamp, string) |
| description: | |
| 将时间戳 timestamp 转换为日期格式字符串 string 指定格式的字符串值。格式字符串与 Java 的 SimpleDateFormat 兼容。 |
| - sql: TIMESTAMPADD(timeintervalunit, interval, timepoint) |
| - sql: TIMESTAMPDIFF(timepointunit, timepoint1, timepoint2) |
| table: timestampDiff(TIMEPOINTUNIT, TIMEPOINT1, TIMEPOINT2) |
| description: | |
| 返回 timepoint1 和 timepoint2 之间时间间隔。间隔的单位由第一个参数给出，它应该是以下值之一： |
| SECOND，MINUTE，HOUR，DAY，MONTH 或 YEAR。 |
| - sql: CONVERT_TZ(string1, string2, string3) |
| description: | |
| 将日期时间 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`'。 |
| - sql: FROM_UNIXTIME(numeric[, string]) |
| description: | |
| 以字符串格式 string 返回数字参数 numberic 的表示形式（默认为 'yyyy-MM-dd HH:mm:ss'）。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'。 |
| - sql: UNIX_TIMESTAMP() |
| description: 以秒为单位获取当前的 Unix 时间戳。此函数不是确定性的，这意味着将为每个记录重新计算该值。 |
| - sql: UNIX_TIMESTAMP(string1[, string2]) |
| description: | |
| 使用表配置中指定的时区将格式为 string2 的日期时间字符串 string1（如果未指定默认情况下：yyyy-MM-dd HH:mm:ss） |
| 转换为 Unix 时间戳（以秒为单位）。 |
| - sql: TO_DATE(string1[, string2]) |
| description: 将格式为 string2（默认为 'yyyy-MM-dd'）的字符串 string1 转换为日期。 |
| - sql: TO_TIMESTAMP_LTZ(numeric, precision) |
| table: toTimestampLtz(numeric, PRECISION) |
| description: | |
| 将纪元秒或纪元毫秒转换为 TIMESTAMP_LTZ，有效精度为 0 或 3，0 代表 `TO_TIMESTAMP_LTZ(epochSeconds, 0)`， |
| 3 代表` TO_TIMESTAMP_LTZ(epochMilliseconds, 3)`。 |
| - sql: TO_TIMESTAMP(string1[, string2]) |
| description: 将 'UTC+0' 时区下格式为 string2（默认为：'yyyy-MM-dd HH:mm:ss'）的字符串 string1 转换为时间戳。 |
| - sql: CURRENT_WATERMARK(rowtime) |
| description: | |
| 返回给定时间列属性 rowtime 的当前水印，如果管道中的当前操作没有可用的上游操作的公共水印时则为 `NULL`。 |
| 函数的返回类型被推断为与提供的时间列属性匹配，但调整后的精度为 3。例如时间列属性为 TIMESTAMP_LTZ(9)，则函数将返回 |
| TIMESTAMP_LTZ(3)。 |
| |
| 请注意，此函数可以返回 `NULL`，您可能必须考虑这种情况。例如，如果您想过滤掉后期数据，您可以使用： |
| ``` |
| WHERE |
| CURRENT_WATERMARK(ts) IS NULL |
| OR ts > CURRENT_WATERMARK(ts) |
| ``` |
| |
| conditional: |
| - sql: | |
| CASE value |
| WHEN value1_1 [, value1_2]* THEN RESULT1 |
| (WHEN value2_1 [, value2_2 ]* THEN result_2)* |
| (ELSE result_z) |
| END |
| description: | |
| 当第一个时间值包含在 (valueX_1, valueX_2, ...) 中时，返回 resultX。当没有值匹配时，如果提供则返回 result_z， |
| 否则返回 `NULL`。 |
| - sql: | |
| CASE |
| WHEN condition1 THEN result1 |
| (WHEN condition2 THEN result2)* |
| (ELSE result_z) |
| END |
| description: 满足第一个条件 X 时返回 resultX。当不满足任何条件时，如果提供则返回 result_z，否则返回 `NULL`。 |
| - sql: NULLIF(value1, value2) |
| description: | |
| 如果 value1 等于 value2 返回 `NULL`；否则返回 value1。例如 `NULLIF(5, 5)` 返回 `NULL`；`NULLIF(5, 0)` 返回 5。 |
| - sql: COALESCE(value1, value2 [, value3]*) |
| description: 从 value1, value2, ... 返回第一个不为 `NULL` 的值。例如 `COALESCE(3, 5, 3)` 返回 3。 |
| - sql: IF(condition, true_value, false_value) |
| description: 如果满足条件，则返回 true_value，否则返回 false_value。例如 `IF(5 > 3, 5, 3)` 返回 5。 |
| - sql: IFNULL(input, null_replacement) |
| table: input.ifNull(nullReplacement) |
| description: | |
| 如果输入为 `NULL`，则返回 null_replacement；否则返回输入。与 COALESCE 或 CASE WHEN 相比，此函数返回的数据类型 |
| 在是否为空方面非常明确。。返回的类型是两个参数的公共类型，但只有在 null_replacement 可为空时才能为空。该函数允许将可 |
| 为空的列传递到使用 NOT NULL 约束声明的函数或表中。例如 `IFNULL(nullable_column, 5)` 一定不返回 `NULL`。 |
| - sql: IS_ALPHA(string) |
| description: 如果字符串中的所有字符都是字母，则返回 `true`，否则返回 `false`。 |
| - sql: IS_DECIMAL(string) |
| description: 如果 string 可以解析为有效数字，则返回 `true`，否则返回 `false`。 |
| - sql: IS_DIGIT(string) |
| description: 如果字符串中的所有字符都是数字，则返回 `true`，否则返回 `false`。 |
| - table: BOOLEAN.?(VALUE1, VALUE2) |
| description: | |
| 如果 BOOLEAN 计算结果为 TRUE，则返回 VALUE1；否则返回 VALUE2。例如 `(42 > 5).?('A', 'B')` 返回 `"A"`。 |
| - sql: GREATEST(value1[, value2]*) |
| description: 返回所有输入参数的最大值，如果输入参数中包含 NULL，则返回 NULL。 |
| - sql: LEAST(value1[, value2]*) |
| description: 返回所有输入参数的最小值，如果输入参数中包含 NULL，则返回 NULL。 |
| |
| conversion: |
| - sql: CAST(value AS type) |
| table: ANY.cast(TYPE) |
| description: | |
| 返回被强制转换为类型 type 的新值。例如 `CAST('42' AS INT)` 返回 42； |
| `CAST(NULL AS VARCHAR)` 返回 VARCHAR 类型的 `NULL`。 |
| - sql: TYPEOF(input) | TYPEOF(input, force_serializable) |
| table: call("TYPEOF", input) | call("TYPEOF", input, force_serializable) |
| description: | |
| 返回输入表达式的数据类型的字符串表示形式。默认情况下返回的字符串是一个摘要字符串，可能会为了可读性而省略某些细节。 |
| 如果 force_serializable 设置为 TRUE，则字符串表示可以保留在目录中的完整数据类型。请注意， |
| 特别是匿名的内联数据类型没有可序列化的字符串表示。在这种情况下返回 `NULL`。 |
| |
| collection: |
| - sql: CARDINALITY(array) |
| table: ARRAY.cardinality() |
| description: 返回数组中元素的数量。 |
| - sql: array '[' INT ']' |
| table: ARRAY.at(INT) |
| description: 返回数组中 INT 位置的元素。索引从 1 开始。 |
| - sql: ELEMENT(array) |
| table: ARRAY.element() |
| description: 返回数组的唯一元素（其基数应为 1）；如果数组为空，则返回 `NULL`。如果数组有多个元素，则抛出异常。 |
| - sql: CARDINALITY(map) |
| table: MAP.cardinality() |
| description: 返回 map 中的 entries 数量。 |
| - sql: map ‘[’ value ‘]’ |
| table: MAP.at(ANY) |
| description: 返回 map 中指定 key 对应的值。 |
| |
| json: |
| - sql: IS JSON [ { VALUE | SCALAR | ARRAY | OBJECT } ] |
| table: STRING.isJson([JsonType type]) |
| description: | |
| Determine whether a given string is valid JSON. |
| |
| Specifying the optional type argument puts a constraint on which type of JSON object is |
| allowed. If the string is valid JSON, but not that type, `false` is returned. The default is |
| `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 |
| ``` |
| - sql: JSON_EXISTS(jsonValue, path [ { TRUE | FALSE | UNKNOWN | ERROR } ON ERROR ]) |
| table: STRING.jsonExists(STRING path [, JsonExistsOnError onError]) |
| description: | |
| Determines whether a JSON string satisfies a given path search criterion. |
| |
| If the error behavior is omitted, `FALSE ON ERROR` is assumed as the default. |
| |
| ``` |
| -- 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); |
| ``` |
| - sql: JSON_VALUE(jsonValue, path [RETURNING <dataType>] [ { NULL | ERROR | DEFAULT <defaultExpr> } ON EMPTY ] [ { NULL | ERROR | DEFAULT <defaultExpr> } ON ERROR ]) |
| table: STRING.jsonValue(STRING path [, returnType, onEmpty, defaultOnEmpty, onError, defaultOnError]) |
| description: | |
| Extracts a scalar from a JSON string. |
| |
| This method searches a JSON string for a given path expression and returns the value if the |
| value at that path is scalar. Non-scalar values cannot be returned. By default, the value is |
| returned as `STRING`. Using `returningType` a different type can be chosen, with the following |
| types being supported: |
| |
| * `VARCHAR` / `STRING` |
| * `BOOLEAN` |
| * `INTEGER` |
| * `DOUBLE` |
| |
| For empty path expressions or errors a behavior can be defined to either return `null`, raise |
| an error or return a defined default value instead. When omitted, the default is |
| `NULL ON EMPTY` or `NULL ON ERROR`, respectively. The default value may be a literal or an |
| expression. If the default value itself raises an error, it falls through to the error |
| behavior for `ON EMPTY`, and raises an error for `ON ERROR`. |
| |
| ``` |
| // STRING: "true" |
| JSON_VALUE('{"a": true}', '$.a') |
| |
| // BOOLEAN: true |
| JSON_VALUE('{"a": true}', '$.a' RETURNING BOOLEAN) |
| |
| // STRING: "false" |
| JSON_VALUE('{"a": true}', 'lax $.b' |
| DEFAULT FALSE ON EMPTY) |
| |
| // STRING: "false" |
| JSON_VALUE('{"a": true}', 'strict $.b' |
| DEFAULT FALSE ON ERROR) |
| ``` |
| - sql: 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 ]) |
| table: STRING.jsonQuery(path [, JsonQueryWrapper [, JsonQueryOnEmptyOrError, JsonQueryOnEmptyOrError ] ]) |
| description: | |
| Extracts JSON values from a JSON string. |
| |
| The result is always returned as a `STRING`. The `RETURNING` clause is currently not supported. |
| |
| The `wrappingBehavior` determines whether the extracted value should be wrapped into an array, |
| and whether to do so unconditionally or only if the value itself isn't an array already. |
| |
| `onEmpty` and `onError` determine the behavior in case the path expression is empty, or in |
| case an error was raised, respectively. By default, in both cases `null` is returned. Other |
| choices are to use an empty array, an empty object, or to raise an error. |
| |
| ``` |
| -- '{ "b": 1 }' |
| JSON_QUERY('{ "a": { "b": 1 } }', '$.a') |
| -- '[1, 2]' |
| JSON_QUERY('[1, 2]', '$') |
| -- NULL |
| JSON_QUERY(CAST(NULL AS STRING), '$') |
| |
| -- Wrap result into an array |
| -- '[{}]' |
| 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) |
| |
| -- Scalars must be wrapped to be returned |
| -- NULL |
| JSON_QUERY(1, '$') |
| -- '[1]' |
| JSON_QUERY(1, '$' WITH CONDITIONAL ARRAY WRAPPER) |
| |
| -- Behavior if path expression is empty / there is an error |
| -- '{}' |
| JSON_QUERY('{}', 'lax $.invalid' EMPTY OBJECT ON EMPTY) |
| -- '[]' |
| JSON_QUERY('{}', 'strict $.invalid' EMPTY ARRAY ON ERROR) |
| ``` |
| - sql: JSON_OBJECT([[KEY] key VALUE value]* [ { NULL | ABSENT } ON NULL ]) |
| table: jsonObject(JsonOnNull, keyValues...) |
| description: | |
| Builds a JSON object string from a list of key-value pairs. |
| |
| Note that keys must be non-`NULL` string literals, while values may be arbitrary expressions. |
| |
| This function returns a JSON string. The `ON NULL` behavior defines how to treat `NULL` |
| values. If omitted, `NULL ON NULL` is assumed by default. |
| |
| |
| ``` |
| -- '{}' |
| JSON_OBJECT() |
| |
| -- '{"K1":"V1","K2":"V2"}' |
| JSON_OBJECT('K1' VALUE 'V1', 'K2' VALUE 'V2') |
| |
| -- Expressions as values |
| 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' |
| ) |
| ) |
| ``` |
| |
| valueconstruction: |
| - sql: | |
| -- implicit constructor with parenthesis |
| (value1 [, value2]*) |
| table: row(ANY1, ANY2, ...) |
| description: | |
| 返回从值列表 (value1, value2, ...) 创建的行。隐式行构造函数支持任意表达式作为字段，但至少需要两个字段。 |
| 显式行构造函数可以处理任意数量的字段，但目前还不能很好地支持所有类型的字段表达式。 |
| - sql: ARRAY ‘[’ value1 [, value2 ]* ‘]’ |
| table: array(ANY1, ANY2, ...) |
| description: 返回从值列表 (value1, value2, ...) 创建的数组。 |
| - sql: MAP ‘[’ value1, value2 [, value3, value4 ]* ‘]’ |
| table: map(ANY1, ANY2, ANY3, ANY4, ...) |
| description: 返回从键值对列表 ((value1, value2), (value3, value4), ...) 创建的 map。 |
| - table: numeric.rows |
| description: 创建一个 numeric 行间隔（通常用于窗口创建）。 |
| |
| valueaccess: |
| - sql: tableName.compositeType.field |
| table: COMPOSITE.get(STRING) | COMPOSITE.get(INT) |
| description: 按名称从 Flink 复合类型（例如，Tuple，POJO）返回字段的值。 |
| - sql: tableName.compositeType.* |
| table: ANY.flatten() |
| description: | |
| 返回 Flink 复合类型（例如，Tuple，POJO）的平面表示，将其每个直接子类型转换为单独的字段。在大多数情况下，平面表示 |
| 的字段与原始字段的命名类似，但使用 `$` 分隔符（例如 mypojo$mytuple$f0）。 |
| |
| grouping: |
| - sql: GROUP_ID() |
| description: 返回唯一标识分组键组合的整数。 |
| - sql: GROUPING(expression1 [, expression2]* ) | GROUPING_ID(expression1 [, expression2]* ) |
| description: 返回给定分组表达式的位向量。 |
| |
| hashfunctions: |
| - sql: MD5(string) |
| table: STRING.md5() |
| description: 以 32 个十六进制数字的字符串形式返回 string 的 MD5 哈希值；如果字符串为 `NULL`，则返回 `NULL`。 |
| - sql: SHA1(string) |
| table: STRING.sha1() |
| description: 以 56 个十六进制数字的字符串形式返回 string 的 SHA-224 哈希值；如果字符串为 `NULL`，则返回 `NULL`。 |
| - sql: SHA224(string) |
| table: STRING.sha224() |
| description: 以 56 个十六进制数字的字符串形式返回 string 的 SHA-224 哈希值；如果字符串为 `NULL`，则返回 `NULL`。 |
| - sql: SHA256(string) |
| table: STRING.sha256() |
| description: 以 64 个十六进制数字的字符串形式返回 string 的 SHA-256 哈希值；如果字符串为 `NULL`，则返回 `NULL`。 |
| - sql: SHA384(string) |
| table: STRING.sha384() |
| description: 以 96 个十六进制数字的字符串形式返回 string 的 SHA-384 哈希值；如果字符串为 `NULL`，则返回 `NULL`。 |
| - sql: SHA512(string) |
| table: STRING.sha512() |
| description: 以 128 个十六进制数字的字符串形式返回 string 的 SHA-512 哈希值；如果字符串为 `NULL`，则返回 `NULL`。 |
| - sql: SHA2(string, hashLength) |
| table: STRING.sha2(INT) |
| description: | |
| 使用 SHA-2 系列散列函数（SHA-224，SHA-256，SHA-384 或 SHA-512）返回散列值。第一个参数字符串是要散列的字符串， |
| 第二个参数 hashLength 是结果的位长（224，256，384 或 512）。如果 string 或 hashLength 为 `NULL`，则返回 `NULL`。 |
| |
| auxilary: |
| - table: callSql(STRING) |
| description: | |
| 对 SQL 表达式的调用。给定的字符串在规划期间被解析并转换为 Table API 表达式。在运行时只计算翻译后的表达式。 |
| 目前，调用仅限于简单的标量表达式。不支持调用聚合函数或表值函数。子查询也是不允许的。 |
| 例如 `table.select(callSql("UPPER(myColumn)").substring(3))` |
| - table: ANY.as(NAME1, NAME2, ...) |
| description: 指定 ANY（字段）的名称。如果表达式扩展为多个字段，则可以指定其他名称。 |
| |
| aggregate: |
| - sql: COUNT([ ALL ] expression | DISTINCT expression1 [, expression2]*) |
| description: 默认情况下或使用关键字 `ALL`，返回不为 `NULL` 的表达式的输入行数。使用 `DISTINCT` 则对所有值去重后计算。 |
| - sql: COUNT(*) | COUNT(1) |
| table: FIELD.count |
| description: 返回输入行数。 |
| - sql: AVG([ ALL | DISTINCT ] expression) |
| table: FIELD.avg |
| description: | |
| 默认情况下或使用关键字 `ALL`，返回所有输入行中表达式的平均值（算术平均值）。使用 `DISTINCT` 则对所有值去重后计算。 |
| - sql: SUM([ ALL | DISTINCT ] expression) |
| table: FIELD.sum |
| description: 默认情况下或使用关键字 `ALL`，返回所有输入行的表达式总和。使用 `DISTINCT` 则对所有值去重后计算。 |
| - table: FIELD.sum0 |
| description: 返回所有输入行的数字字段的总和。如果所有值都为 `NULL`，则返回 0。 |
| - sql: MAX([ ALL | DISTINCT ] expression) |
| table: FIELD.max |
| description: 默认情况下或使用关键字 `ALL`，返回所有输入行中表达式的最大值。使用 `DISTINCT` 则对所有值去重后计算。 |
| - sql: MIN([ ALL | DISTINCT ] expression ) |
| table: FIELD.min |
| description: 默认情况下或使用关键字 `ALL`，返回所有输入行中表达式的最小值。使用 `DISTINCT` 则对所有值去重后计算。 |
| - sql: STDDEV_POP([ ALL | DISTINCT ] expression) |
| table: FIELD.stddevPop |
| description: 默认情况下或使用关键字 `ALL`，返回所有输入行中表达式的总体标准偏差。使用 `DISTINCT` 则对所有值去重后计算。 |
| - sql: STDDEV_SAMP([ ALL | DISTINCT ] expression) |
| table: FIELD.stddevSamp |
| description: 默认情况下或使用关键字 `ALL`，返回所有输入行中表达式的样本标准偏差。使用 `DISTINCT` 则对所有值去重后计算。 |
| - sql: VAR_POP([ ALL | DISTINCT ] expression) |
| table: FIELD.varPop |
| description: | |
| 默认情况下或使用关键字 `ALL`，返回所有输入行中表达式的总体方差（总体标准差的平方）。使用 `DISTINCT` 则对所有值去重后计算。 |
| - sql: VAR_SAMP([ ALL | DISTINCT ] expression) |
| table: FIELD.varSamp |
| description: | |
| 默认情况下或使用关键字 `ALL`，返回所有输入行中表达式的样本方差（样本标准差的平方）。使用 `DISTINCT` 则对所有值去重后计算。 |
| - sql: COLLECT([ ALL | DISTINCT ] expression) |
| table: FIELD.collect |
| description: | |
| 默认情况下或使用关键字 `ALL`，返回跨所有输入行的多组表达式。`NULL` 值将被忽略。使用 `DISTINCT` 则对所有值去重后计算。 |
| - sql: VARIANCE([ ALL | DISTINCT ] expression) |
| description: VAR_SAMP() 的同义方法。 |
| - sql: RANK() |
| description: 返回值在一组值中的排名。结果是 1 加上分区顺序中当前行之前或等于当前行的行数。排名在序列中不一定连续。 |
| - sql: DENSE_RANK() |
| description: | |
| 返回值在一组值中的排名。结果是一加先前分配的等级值。与函数 rank 不同，dense_rank 不会在排名序列中产生间隙。 |
| - sql: ROW_NUMBER() |
| description: | |
| 在窗口分区内根据 rows 的排序为每一行分配一个唯一的序列号，从一开始。ROW_NUMBER 和 RANK 相似。ROW_NUMBER 按 |
| 顺序对所有行进行编号（例如 1，2，3，4，5）。RANK 为等值 row 提供相同的序列值（例如 1，2，2，4，5）。 |
| - sql: LEAD(expression [, offset] [, default]) |
| description: 返回窗口中当前行之后第 offset 行处的表达式值。offset 的默认值为 1，default 的默认值为 `NULL`。 |
| - sql: LAG(expression [, offset] [, default]) |
| description: 返回窗口中当前行之前第 offset 行处的表达式值。offset 的默认值为 1，default 的默认值为 `NULL`。 |
| - sql: FIRST_VALUE(expression) |
| description: 返回一组有序值中的第一个值。 |
| - sql: LAST_VALUE(expression) |
| description: 返回一组有序值中的最后一个值。 |
| - sql: LISTAGG(expression [, separator]) |
| description: 连接字符串表达式的值并在它们之间放置分隔符值。字符串末尾不添加分隔符时则分隔符的默认值为“,”。 |
