

# 内置函数(Built-In Functions)

Flink Table API 和 SQL 为用户提供了一组用于数据转换的内置函数。这一页简要介绍了它们。如果您需要的函数目前还不支持，您可以实现一个[用户定义函数](udfs.html)。如果您认为该函数足够通用，请[打开一个 Jira 问题](https://issues.apache.org/jira/secure/CreateIssue!default.jspa)并提供详细描述。

## 标量函数(Scalar Functions)

标量函数接受零个、一个或多个值作为输入，并返回一个值作为结果。

### 比较函数(Comparison Functions)

| 比较函数 | 描述 |
| --- | --- |
|



```
value1 = value2
```



如果 _value1_ 等于 _value2_，则返回TRUE；如果 _value1_ 或 _value2_ 为空(NULL)，则返回未知(UNKNOWN)。



```
value1 &lt;&gt; value2
```



如果 _value1_ 不等于 _value2_，则返回 TRUE；如果 _value1_ 或 _value2_ 为空(NULL)，则返回未知(UNKNOWN)。



```
value1 &gt; value2
```



如果 _value1_ 大于 _value2_，则返回 TRUE；如果 _value1_ 或 _value2_ 为空(NULL)，则返回未知(UNKNOWN)。



```
value1 &gt;= value2
```



如果 _value1_ 大于或等于 _value2_，则返回 TRUE；如果 _value1_ 或 _value2_ 为空(NULL)，则返回未知(UNKNOWN)。



```
value1 &lt; value2
```



如果 _value1_ 小于 _value2_，则返回 TRUE；如果 _value1_ 或 _value2_ 为空(NULL)，则返回未知(UNKNOWN)。



```
value1 &lt;= value2
```



如果 _value1_ 小于或等于 _value2_，则返回 TRUE；如果 _value1_ 或 _value2_ 为空(NULL)，则返回未知(UNKNOWN)。



```
value IS NULL
```



如果 _value_ 为空(NULL)，则返回 TRUE。



```
value IS NOT NULL
```



如果 _value_ 不为空(NULL)，则返回 TRUE。



```
value1 IS DISTINCT FROM value2
```



如果两个值不相等，则返回 TRUE。空值(NULL)在这里被视为相同的。如 `1 IS DISTINCT FROM NULL` 返回 TRUE;`NULL IS DISTINCT FROM NULL`返回 FALSE。



```
value1 IS NOT DISTINCT FROM value2
```



如果两个值相等，则返回 TRUE。空值(NULL)在这里被视为相同的。如 `1 IS NOT DISTINCT FROM NULL`返回 FALSE;`NULL IS NOT DISTINCT FROM NULL`返回 TRUE。



```
value1 BETWEEN [ ASYMMETRIC &#124; SYMMETRIC ] value2 AND value3
```



默认情况下(或使用非对称关键字)，如果 _value1_ 大于或等于 _value2_，小于或等于 _value3_，则返回TRUE。如果 _value1_ 包含在 _value2_ 和 _value3_ 之间，则使用对称关键字返回TRUE。当 _value2_ 或 _value3_ 为空时，返回 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 &#124; SYMMETRIC ] value2 AND value3
```



默认情况下(或使用非对称关键字)，如果 _value1_ 小于 _value2_ 或大于 _value3_，则返回TRUE。如果 _value2_ 和 _value3_ 之间没有包含 _value1_，则使用对称关键字返回 TRUE。当 _value2_ 或 _value3_ 为空时，返回 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_ 匹配模式 _string2_，则返回 TRUE;如果 _string1_ 或 _string2_ 为空，则返回未知(NULL)。如果需要，可以定义转义字符。**注意:** 还不支持转义字符。



```
string1 NOT LIKE string2 [ ESCAPE char ]
```



如果 _string1_ 与模式 _string2_ 不匹配，则返回 TRUE;如果 _string1_ 或 _string2_ 为空(NULL)，则返回未知(UNKNOWN)。如果需要，可以定义转义字符。**注意:** 还不支持转义字符。



```
string1 SIMILAR TO string2 [ ESCAPE char ]
```



如果 _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_ 存在于给定列表 _(value2, value3，...)_ 中，则返回 TRUE。当 _(value2, value3，...)_ 包含 NULL，如果可以找到该元素，则返回 TRUE，否则返回 UNKNOWN。如果 _value1_ 为空，则始终返回 UNKNOWN。如 `4 IN (1, 2, 3)`返回 FALSE;`1 IN (1, 2, NULL)` 返回 TRUE;`4 IN (1, 2, NULL)`返回 UNKNOWN。



```
value1 NOT IN (value2 [, value3]* )
```



如果 _value1_ 不存在于给定列表 _(value2, value3，...)_ 中，则返回 TRUE。当 _(value2, value3, ...)_ 包含 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)
```



如果 _subquery_ 返回至少一行，则返回 TRUE。只有在可以在联接和组操作中重写操作时，才支持该操作。**注意:** 对于流查询，操作在 join 和 group 操作中重写。计算查询结果所需的状态可能会无限增长，这取决于不同输入行的数量。请提供具有有效保留间隔的查询配置，以防止状态过大。有关详细信息，请参见[查询配置](streaming/query_configuration.html)。



```
value IN (sub-query)
```



如果 _value_ 等于子查询返回的行，则返回 TRUE。**注意:** 对于流查询，操作在 join 和 group 操作中重写。计算查询结果所需的状态可能会无限增长，这取决于不同输入行的数量。请提供具有有效保留间隔的查询配置，以防止状态过大。有关详细信息，请参见[查询配置](streaming/query_configuration.html)。



```
value NOT IN (sub-query)
```



 | 如果 _value_ 不等于 _sub-query_ 返回的每一行，则返回 TRUE。**注意:** 对于流查询，操作在 join 和 group 操作中重写。计算查询结果所需的状态可能会无限增长，这取决于不同输入行的数量。请提供具有有效保留间隔的查询配置，以防止状态过大。有关详细信息，请参见[查询配置](streaming/query_configuration.html)。 |


| 比较函数 | 描述 |
| --- | --- |
|



```
ANY1 === ANY2
```



如果 _ANY1_ 等于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 !== ANY2
```



如果 _ANY1_ 不等于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 &gt; ANY2
```



如果 _ANY1_ 大于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 &gt;= ANY2
```



如果 _ANY1_ 大于或等于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 &lt; ANY2
```



如果 _ANY1_ 小于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 &lt;= ANY2
```



如果 _ANY1_ 小于或等于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY.isNull
```



如果 _ANY_ 为空，则返回 TRUE。



```
ANY.isNotNull
```



如果 _ANY_ 不为空，则返回 TRUE。



```
STRING1.like(STRING2)
```



如果 _STRING1_ 匹配模式 _STRING2_，则返回 TRUE;如果 _STRING1_ 或 _STRING2_ 为 NULL，则返回 UNKNOWN。如 `"JoKn".like("Jo_n%")` 返回 TRUE。



```
STRING.similar(STRING)
```



如果 _STRING1_ 匹配 SQL 正则表达式 _STRING2_，则返回 TRUE;如果 _STRING1_ 或 _STRING2_ 为 NULL，则返回 UNKNOWN。如 `"A".similar("A+")` 返回 TRUE。



```
ANY1.in(ANY2, ANY3, ...)
```



如果 _ANY1_ 存在于给定列表 _(ANY2, ANY3，...)_ 中，则返回 TRUE。当 _(ANY2, ANY3，...)_ 包含 NULL，如果可以找到该元素，则返回 TRUE，否则返回U NKNOWN。如果 _ANY1_ 为空，则始终返回 UNKNOWN。如 `4.in(1, 2, 3)` 返回 FALSE。



```
ANY.in(TABLE)
```



如果 _ANY_ 等于子查询 _TABLE_ 返回的一行，则返回 TRUE。**注意:** 对于流查询，操作在 join 和 group 操作中重写。计算查询结果所需的状态可能会无限增长，这取决于不同输入行的数量。请提供具有有效保留间隔的查询配置，以防止状态过大。有关详细信息，请参见[查询配置](streaming/query_configuration.html)。



```
ANY1.between(ANY2, ANY3)
```



如果 _ANY1_ 大于或等于 _ANY2_ 且小于或等于 _ANY3_，则返回 TRUE。当_ ANY2_ 或 _ANY3_ 为空时，返回 FALSE 或 UNKNOWN。如 `12.between(15, 12)` 返回 FALSE;`12.between(10, Null(INT))` 返回 UNKNOWN;`12.between(Null(INT), 10)`返回 FALSE。


```
ANY1.notBetween(ANY2, ANY3)
```



 | 如果 _ANY1_ 小于 _ANY2_ 或大于 _ANY3_，则返回 TRUE。当 _ANY2_ 或 _ANY3_ 为空时，返回 TRUE 或 UNKNOWN。如 `12.notBetween(15, 12)` 返回 TRUE;`12.notBetween(Null(INT), 15)` 返回 UNKNOWN;`12.notBetween(15, Null(INT))` 返回 TRUE。 |

| 比较函数 | 描述 |
| --- | --- |
|



```
ANY1 === ANY2
```



如果 _ANY1_ 等于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 !== ANY2
```



如果 _ANY1_ 不等于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 &gt; ANY2
```



如果 _ANY1_ 大于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 &gt;= ANY2
```



如果 _ANY1_ 大于或等于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 &lt; ANY2
```



如果 _ANY1_ 小于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY1 &lt;= ANY2
```



如果 _ANY1_ 小于或等于 _ANY2_，则返回 TRUE;如果 _ANY1_ 或 _ANY2_ 为 NULL，则返回 UNKNOWN。



```
ANY.isNull
```



如果 _ANY_ 为空，则返回 TRUE。



```
ANY.isNotNull
```



如果 _ANY_ 不为空，则返回 TRUE。



```
STRING1.like(STRING2)
```



如果 _STRING1_ 匹配模式 _STRING2_，则返回 TRUE;如果 _STRING1_ 或 _STRING2_ 为空，则返回 UNKNOWN。如 `"JoKn".like("Jo_n%")` 返回 TRUE。



```
STRING1.similar(STRING2)
```



如果 _STRING1_ 匹配 SQL 正则表达式 _STRING2_，则返回 TRUE;如果 _STRING1_ 或 _STRING2_ 为 NULL，则返回 UNKNOWN。如 `"A".similar("A+")` 返回 TRUE。



```
ANY1.in(ANY2, ANY3, ...)
```



如果 _ANY1_ 存在于给定列表 _(ANY2, ANY3，...)_ 中，则返回 TRUE。当 _(ANY2, ANY3，...)_ 包含 NULL，如果可以找到该元素，则返回 TRUE，否则返回 UNKNOWN。如果 _ANY1_ 为 NULL，则始终返回 UNKNOWN。如 `4.in(1, 2, 3)` 返回 FALSE。



```
ANY.in(TABLE)
```



如果 _ANY_ 等于子查询 _TABLE_ 返回的一行，则返回 TRUE。**注意:** 对于流查询，操作在 join 和 group 操作中重写。计算查询结果所需的状态可能会无限增长，这取决于不同输入行的数量。请提供具有有效保留间隔的查询配置，以防止状态过大。有关详细信息，请参见[查询配置](streaming/query_configuration.html)。



```
ANY1.between(ANY2, ANY3)
```



如果 _ANY1 _大于或等于 _ANY2_ 且小于或等于 _ANY3_，则返回 TRUE。当 _ANY2_ 或 _ANY3_ 为空时，返回 FALSE 或 UNKNOWN。如 `12.between(15, 12)` 返回 FALSE;`12.between(10, Null(Types.INT))` 返回 UNKNOWN; `12.between(Null(Types.INT), 10)` 返回 FALSE。



```
ANY1.notBetween(ANY2, ANY3)
```



 | 如果 _ANY1_ 小于 _ANY2_ 或大于 _ANY3_，则返回 TRUE。当 _ANY2_ 或 _ANY3_ 为空时，返回 TRUE 或 UNKNOWN。如 `12.notBetween(15, 12)` 返回 TRUE; `12.notBetween(Null(Types.INT), 15)` 返回 UNKNOWN; `12.notBetween(15, Null(Types.INT))` 返回 TRUE。 |

### 逻辑函数(Logical Functions)

| 逻辑函数 | 描述 |
| --- | --- |
|



```
boolean1 OR boolean2
```



如果 _boolean1_ 为真或 _boolean2_ 为真，则返回 TRUE。支持三值逻辑(three-valued logic)。如 `TRUE OR UNKNOWN` 返回 TRUE。



```
boolean1 AND boolean2
```



如果 _boolean1_ 和 _boolean2_ 都为真，则返回 TRUE。支持三值逻辑(three-valued logic)。如 `TRUE AND UNKNOWN` 返回 UNKNOWN。



```
NOT boolean
```



如果 _boolean_ 为假，则返回 TRUE;如果 _boolean_ 为真，则返回 FALSE;如果 _boolean_ 为 UNKNOWN，则返回 UNKNOWN。



```
boolean IS FALSE
```



如果 _boolean_ 为假，则返回 TRUE;如果 _boolean_ 为真或 UNKNOWN，则返回 FALSE。



```
boolean IS NOT FALSE
```



如果 _boolean_ 为真或未知(UNKNOWN)，则返回 TRUE;如果 _boolean_ 为假，则返回 FALSE。



```
boolean IS TRUE
```



如果 _boolean_ 为真，则返回 TRUE;如果 _boolean_ 为假或未知(UNKNOWN)，则返回 FALSE。



```
boolean IS NOT TRUE
```



如果 _boolean_ 为假或未知(UNKNOWN)，则返回 TRUE;如果 _boolean_ 为假，则返回 FALSE。



```
boolean IS UNKNOWN
```



如果 _boolean_ 为未知(UNKNOWN)，则返回 TRUE;如果 _boolean_ 为真或假，则返回 FALSE。



```
boolean IS NOT UNKNOWN
```



 | 如果 _boolean_ 为真或假，则返回 TRUE;如果 _boolean_ 未知(UNKNOWN)，则返回 FALSE。 |

| 逻辑函数 | 描述 |
| --- | --- |
|



```
BOOLEAN1 &#124;&#124; BOOLEAN2
```



如果 _BOOLEAN1_ 为真或 _BOOLEAN2_ 为真，则返回 TRUE。支持三值逻辑(three-valued logic)。如 `true &#124;&#124; Null(BOOLEAN)` 返回 TRUE。



```
BOOLEAN1 && BOOLEAN2
```



如果 _BOOLEAN1_ 和 _BOOLEAN2_ 都为真，则返回 TRUE。支持三值逻辑(three-valued logic)。如 `true && Null(BOOLEAN)` 返回 UNKNOWN。



```
!BOOLEAN
```



如果 _BOOLEAN_ 为假，则返回 TRUE;如果 _BOOLEAN_ 为真，则返回 FALSE;如果 _BOOLEAN_ 未知(UNKNOWN)，则返回未知(UNKNOWN)。



```
BOOLEAN.isTrue
```



如果 _BOOLEAN_ 为真，则返回 TRUE;如果 _BOOLEAN_ 为假或未知(UNKNOWN)，则返回 FALSE。



```
BOOLEAN.isFalse
```



如果 _BOOLEAN_ 为假，则返回 TRUE;如果 _BOOLEAN_ 为真或未知，则返回 FALSE。



```
BOOLEAN.isNotTrue
```



如果 _BOOLEAN_ 为假或未知，则返回 TRUE;如果 _BOOLEAN_ 为假，则返回 FALSE。



```
BOOLEAN.isNotFalse
```



 | 如果 _BOOLEAN_ 为真或未知，则返回 TRUE;如果 _BOOLEAN_ 为假，则返回 FALSE。 |

| 逻辑函数 | 描述 |
| --- | --- |
|



```
BOOLEAN1 &#124;&#124; BOOLEAN2
```



如果 _BOOLEAN1_ 为真或 _BOOLEAN2_ 为真，则返回 TRUE。支持三值逻辑(three-valued logic)。如 `true &#124;&#124; Null(Types.BOOLEAN)` 返回 TRUE。



```
BOOLEAN1 && BOOLEAN2
```



如果 _BOOLEAN1_ 和 _BOOLEAN2_ 都为真，则返回 TRUE。支持三值逻辑(three-valued logic)。如 `true && Null(Types.BOOLEAN)` 返回 UNKNOWN。



```
!BOOLEAN
```



如果 _BOOLEAN_ 为假，则返回 TRUE;如果 _BOOLEAN_ 为真，则返回 FALSE;如果 _BOOLEAN_ 未知(UNKNOWN)，则返回未知(UNKNOWN)。



```
BOOLEAN.isTrue
```



如果 _BOOLEAN_ 为真，则返回 TRUE;如果 _BOOLEAN_ 为假或未知(UNKNOWN)，则返回 FALSE。



```
BOOLEAN.isFalse
```



如果 _BOOLEAN_ 为假，则返回 TRUE;如果 _BOOLEAN_ 为真或未知(UNKNOWN)，则返回 FALSE。



```
BOOLEAN.isNotTrue
```



如果 _BOOLEAN_ 为假或未知(UNKNOWN)，则返回 TRUE;如果 _BOOLEAN_ 为假，则返回 FALSE。



```
BOOLEAN.isNotFalse
```



 | 如果 _BOOLEAN_ 为真或未知(UNKNOWN)，则返回 TRUE;如果 _BOOLEAN_ 为假，则返回 FALSE。 |

### 算术函数(Arithmetic Functions)

| 算术函数 | 描述 |
| --- | --- |
|



```
+ numeric
```



返回 _numeric_。



```
- numeric
```



返回负 _numeric_。



```
numeric1 + numeric2
```



返回 _numeric1_ 加 _numeric2_。



```
numeric1 - numeric2
```



返回 _numeric1_ 减 _numeric2_。



```
numeric1 * numeric2
```



返回 _numeric1_ 乘以 _numeric2_。



```
numeric1 / numeric2
```



返回 _numeric1_ 除以 _numeric2_。



```
POWER(numeric1, numeric2)
```



返回 _numeric1_ 的 _numeric2_ 次方。



```
ABS(numeric)
```



返回 _numeric_ 的绝对值。



```
MOD(numeric1, numeric2)
```



返回 _numeric1_ 除以 _numeric2_ 的余数(模数)。只有当 _numeric1_ 为负时，结果才为负。



```
SQRT(numeric)
```



返回 _numeric_ 的平方根。



```
LN(numeric)
```



返回 _numeric_ 的自然对数(以e为底)。



```
LOG10(numeric)
```



返回 _numeric_ 的以10为底的对数。



```
LOG2(numeric)
```



返回 _numeric_ 的以2为底的对数。



```
LOG(numeric2)
LOG(numeric1, numeric2)
```



当使用一个参数调用时，返回 _numeric2_ 的自然对数。当使用两个参数调用时，该函数将返回 _numeric2_ 的以 _numeric1_ 为底的对数。**注意:** 当前，_numeric2_ 必须大于0，_numeric1_ 必须大于1。



```
EXP(numeric)
```



返回 e 的_numeric_次方。



```
CEIL(numeric)
CEILING(numeric)
```



将_numeric_向上舍入，并返回大于或等于_numeric_的最小数字。



```
FLOOR(numeric)
```



将_numeric_向下舍入，并返回小于或等于_numeric_的最大数字。



```
SIN(numeric)
```



返回 _numeric_ 的正弦值。



```
SINH(numeric)
```



返回 _numeric_ 的双曲正弦值。返回类型为 _DOUBLE_。



```
COS(numeric)
```



返回 _numeric_ 的余弦值。



```
TAN(numeric)
```



返回 _numeric_ 的正切值。



```
TANH(numeric)
```



返回 _numeric_ 的双曲正切值。返回类型为 _DOUBLE_。



```
COT(numeric)
```



返回 _numeric_ 的余切值。



```
ASIN(numeric)
```



返回 _numeric_ 的反正弦值。



```
ACOS(numeric)
```



返回 _numeric_ 的反余弦值。



```
ATAN(numeric)
```



返回 _numeric_ 的反正切值。



```
ATAN2(numeric1, numeric2)
```



返回坐标 _(numeric1, numeric2)_ 的反正切值。



```
COSH(numeric)
```



返回 _NUMERIC_ 的双曲余弦值。返回值类型为 _DOUBLE_。



```
DEGREES(numeric)
```



返回弧度 _numeric_ 的度数表示。



```
RADIANS(numeric)
```



返回 _numeric_ 度的弧度表示。



```
SIGN(numeric)
```



返回 _numeric_ 的符号。



```
ROUND(numeric, integer)
```



返回舍入为 _numeric_ 的 _integer_ 小数位的数字。



```
PI
```



返回一个比任何其他值更接近于 pi 的值。



```
E()
```



返回一个比任何其他值更接近 e 的值。



```
RAND()
```



返回介于0.0(包含)和1.0(不包含)之间的伪随机双精度值。



```
RAND(integer)
```



返回一个介于0.0(包含)和1.0(不包含)之间的伪随机双值，初始种子值为 _integer_。如果两个 RAN D函数具有相同的初始种子，则它们将返回相同的数字序列。




```
RAND_INTEGER(integer)
```



返回一个介于0(包括)和_integer_(不包含)之间的伪随机整数值。



```
RAND_INTEGER(integer1, integer2)
```



返回带有初始种子的介于0(包含)和指定值(不包含)之间的伪随机整数值。如果两个 RAND_INTEGER 函数具有相同的初始种子和绑定，则它们将返回相同的数字序列。



```
UUID()
```



根据RFC 4122类型4 (伪随机生成的) UUID返回UUID(通用唯一标识符)字符串(例如，"3d3c68f7-f608-473f-b60c-b0c44ad4cc4e")。UUID是使用加密的强伪随机数生成器生成的。



```
BIN(integer)
```



以二进制格式返回 _integer_ 的字符串表示形式。如果 _integer_ 为NULL，则返回 NULL。例如 `BIN(4)` 返回 '100' 和 `BIN(12)` 返回'1100'。



```
HEX(numeric)
HEX(string)
```



 | 以十六进制格式返回整数 _numeric_ 值或 _string_ 的字符串表示形式。如果参数为 NULL，则返回 NULL。例如，数字 20 返回 "14"，数字 100 导致 "64"，字符串 "hello,world" 返回 "68656C6C6F2C776F726C64"。 |

| 算术函数 | 描述 |
| --- | --- |
|



```
+ NUMERIC
```



返回 _NUMERIC_.



```
- NUMERIC
```



返回负 _NUMERIC_.



```
NUMERIC1 + NUMERIC2
```



返回 _NUMERIC1_ 加 _NUMERIC2_.



```
NUMERIC1 - NUMERIC2
```



返回 _NUMERIC1_ 减 _NUMERIC2_.



```
NUMERIC1 * NUMERIC2
```



返回 _NUMERIC1_ 乘以 _NUMERIC2_.



```
NUMERIC1 / NUMERIC2
```



返回 _NUMERIC1_ 除以 _NUMERIC2_.



```
NUMERIC1.power(NUMERIC2)
```



返回 _NUMERIC1_ 的 _NUMERIC2_ 次方。



```
NUMERIC.abs()
```



返回 _NUMERIC_ 的绝对值。



```
NUMERIC1 % NUMERIC2
```



返回 _NUMERIC1_ 除以 _NUMERIC2_ 的余数(模数)。只有当 _numeric1_ 为负时，结果才为负。



```
NUMERIC.sqrt()
```



返回_NUMERIC_的平方根。



```
NUMERIC.ln()
```



返回 _NUMERIC_ 的自然对数(以e为底)。



```
NUMERIC.log10()
```



返回 _NUMERIC_ 的以10为底的对数。



```
NUMERIC.log2()
```



返回 _NUMERIC_ 的以2为底的对数。



```
NUMERIC1.log()
NUMERIC1.log(NUMERIC2)
```



当无参数调用时，返回 _NUMERIC1_ 的自然对数。当使用参数调用时，返回以_NUMERIC2_为底的 _NUMERIC1_ 的对数。**注意:** 当前，_NUMERIC1_ 必须大于0，_NUMERIC2_ 必须大于1。



```
NUMERIC.exp()
```



返回 e 的 _NUMERIC_ 次方。



```
NUMERIC.ceil()
```



将 _NUMERIC_ 向上舍入，并返回大于或等于 _NUMERIC_ 的最小数字。



```
NUMERIC.floor()
```



将 _NUMERIC_ 向下舍入，并返回小于或等于 _NUMERIC_ 的最大数字。



```
NUMERIC.sin()
```



返回_NUMERIC_的正弦值。



```
NUMERIC.sinh()
```



返回 _NUMERIC_ 的双曲正弦值。返回类型为 _DOUBLE_。



```
NUMERIC.cos()
```



返回 _NUMERIC_ 的余弦值。



```
NUMERIC.tan()
```



返回 _NUMERIC_ 的正切值。



```
NUMERIC.tanh()
```



返回 _NUMERIC_ 的双曲正切值。返回类型为 _DOUBLE_。



```
NUMERIC.cot()
```



返回 _NUMERIC_ 的余切值。



```
NUMERIC.asin()
```



返回 _NUMERIC_ 的反正弦值。



```
NUMERIC.acos()
```



返回 _NUMERIC_ 的反余弦值。



```
NUMERIC.atan()
```



返回 _NUMERIC_ 的反正切值。



```
atan2(NUMERIC1, NUMERIC2)
```



返回坐标 _(NUMERIC1, NUMERIC2)_ 的反正切值。



```
NUMERIC.cosh()
```



返回 _NUMERIC_ 的双曲余弦值。返回值类型为 _DOUBLE_。



```
NUMERIC.degrees()
```



返回弧度 _NUMERIC_ 的度数表示。



```
NUMERIC.radians()
```



返回 _NUMERIC_ 度的弧度表示。



```
NUMERIC.sign()
```



返回 _NUMERIC_ 的符号。



```
NUMERIC.round(INT)
```



返回舍入为 _NUMERIC_ 的 _INT_ 小数位的数字。



```
pi()
```



返回一个比任何其他值更接近于 pi 的值。



```
e()
```



返回一个比任何其他值更接近 e 的值。



```
rand()
```



返回介于0.0(包含)和1.0(不包含)之间的伪随机双精度值。



```
rand(INTEGER)
```



返回一个介于0.0(包含)和1.0(排除)之间的伪随机双精度值，初始种子值为 _INTEGER_。如果两个RAND函数具有相同的初始种子，则它们将返回相同的数字序列。



```
randInteger(INTEGER)
```



返回一个介于0(包括)和 _INTEGER_ (不包括)之间的伪随机整数值。



```
randInteger(INTEGER1, INTEGER2)
```



返回一个介于0(包含)和 _INTEGER2_ (不包括)之间的伪随机整数值，初始种子为 _INTEGER1_。如果两个randInteger函数具有相同的初始种子和边界，那么它们将返回相同的数字序列。



```
uuid()
```



根据RFC 4122类型4 (伪随机生成的) UUID返回UUID(通用唯一标识符)字符串(例如，"3d3c68f7-f608-473f-b60c-b0c44ad4cc4e")。UUID是使用加密的强伪随机数生成器生成的。



```
INTEGER.bin()
```



以二进制格式返回 _INTEGER_ 的字符串表示形式。如果 _INTEGER_ 为NULL，则返回 NULL。例如 `4.bin()` 返回 "100"，`BIN(12)` 返回 "1100"。



```
NUMERIC.hex()
STRING.hex()
```



 | 以十六进制格式返回整数 _NUMERIC_ 值或 _STRING_ 的字符串表示形式。如果参数为 NULL，则返回 NULL。例如，数字 20 返回 "14"，数字 100 导致 "64"，字符串 "hello,world" 导致 “68656C6C6F2C776F726C64”。 |

| 算术函数 | 描述 |
| --- | --- |
|



```
+ NUMERIC
```



返回 _NUMERIC_.



```
- NUMERIC
```



返回负 _NUMERIC_.



```
NUMERIC1 + NUMERIC2
```



返回 _NUMERIC1_ 加 _NUMERIC2_.



```
NUMERIC1 - NUMERIC2
```



返回 _NUMERIC1_ 减 _NUMERIC2_.



```
NUMERIC1 * NUMERIC2
```



返回 _NUMERIC1_ 乘以 _NUMERIC2_.



```
NUMERIC1 / NUMERIC2
```



返回 _NUMERIC1_ 除以 _NUMERIC2_.



```
NUMERIC1.power(NUMERIC2)
```



返回 _NUMERIC1_ 的 _NUMERIC2_ 次方。



```
NUMERIC.abs()
```



返回 _NUMERIC_ 的绝对值。



```
NUMERIC1 % NUMERIC2
```



返回 _NUMERIC1_ 除以 _NUMERIC2_ 的余数(模数)。只有当 _numeric1_ 为负时，结果才为负。



```
NUMERIC.sqrt()
```



返回 _NUMERIC_ 的平方根。



```
NUMERIC.ln()
```



返回 _NUMERIC_ 的自然对数(以e为底)。



```
NUMERIC.log10()
```



返回 _NUMERIC_ 的以10为底的对数。



```
NUMERIC.log2()
```



返回 _NUMERIC_ 的以2为底的对数。



```
NUMERIC1.log()
NUMERIC1.log(NUMERIC2)
```



当无参数调用时，返回 _NUMERIC1_ 的自然对数。当使用参数调用时，返回 _NUMERIC1_ 以 _NUMERIC2_ 为底的对数。**注意:** 当前，_NUMERIC1_ 必须大于0，_NUMERIC2_ 必须大于1。



```
NUMERIC.exp()
```



返回 e 的 _NUMERIC_ 次方。



```
NUMERIC.ceil()
```



将 _NUMERIC_ 向上舍入，并返回大于或等于 _NUMERIC_ 的最小数字。



```
NUMERIC.floor()
```



将 _NUMERIC_ 向下舍入，并返回小于或等于 _NUMERIC_ 的最大数字。



```
NUMERIC.sin()
```



返回 _NUMERIC_ 的正弦值。



```
NUMERIC.sinh()
```



返回 _NUMERIC_ 的双曲正弦。返回类型为 _DOUBLE_。



```
NUMERIC.cos()
```



返回 _NUMERIC_ 的余弦值。



```
NUMERIC.tan()
```



返回 _NUMERIC_ 的正切值。



```
NUMERIC.tanh()
```



返回 _NUMERIC_ 的双曲正切。返回类型为 _DOUBLE_。



```
NUMERIC.cot()
```



返回 _NUMERIC_ 的余切。



```
NUMERIC.asin()
```



返回 _NUMERIC_ 的反正弦值。



```
NUMERIC.acos()
```



返回 _NUMERIC_ 的反余弦值。



```
NUMERIC.atan()
```



返回 _NUMERIC_ 的反正切值。



```
atan2(NUMERIC1, NUMERIC2)
```



返回坐标 _(NUMERIC1, NUMERIC2)_ 的反正切值。



```
NUMERIC.cosh()
```



返回 _NUMERIC_ 的双曲余弦值。返回值类型为 _DOUBLE_。



```
NUMERIC.degrees()
```



返回弧度 _NUMERIC_ 的度数表示。



```
NUMERIC.radians()
```



返回 _NUMERIC_ 度的弧度表示。



```
NUMERIC.sign()
```



返回 _NUMERIC_ 的符号。



```
NUMERIC.round(INT)
```



返回舍入为 _NUMERIC_ 的 _INT_ 小数位的数字。



```
pi()
```



返回一个比任何其他值更接近 pi 的值。



```
e()
```



返回一个比任何其他值更接近 e 的值。



```
rand()
```



返回介于0.0(包含)和1.0(不包含)之间的伪随机双精度值。



```
rand(INTEGER)
```



返回一个介于0.0(包含)和1.0(不包含)之间的伪随机双精度值，初始种子值为 _INTEGER_。如果两个RAND函数具有相同的初始种子，则它们将返回相同的数字序列。



```
randInteger(INTEGER)
```



 返回一个介于0(包括)和 _INTEGER_ (不包含)之间的伪随机整数值。



```
randInteger(INTEGER1, INTEGER2)
```



返回一个介于0(包含)和 _INTEGER2_ (不包含)之间的伪随机整数值，初始种子为 _INTEGER1_。如果两个 randInteger 函数具有相同的初始种子和边界，那么它们将返回相同的数字序列。



```
uuid()
```



根据RFC 4122类型4(伪随机生成)UUID返回UUID(通用唯一标识符)字符串(例如，“3d3c68f7-f608-473f-b60c-b0c44ad4cc4e”)。UUID是使用加密的强伪随机数生成器生成的。



```
INTEGER.bin()
```



以二进制格式返回 _INTEGER_ 的字符串表示形式。如果 _INTEGER_ 为 NULL，则返回 NULL。例如，`4.bin()` 返回 "100" 和 `12.bin()` 返回 "1100"。



```
NUMERIC.hex()
STRING.hex()
```



 | 以十六进制格式返回整数 _NUMERIC_ 值或 _STRING_ 的字符串表示形式。如果参数为 NULL，则返回 NULL。例如，数字 20 返回 "14"，数字 100 返回 "64"，字符串 "hello,world" 导致 "68656C6C6F2C776F726C64"。 |

### 字符串函数(String Functions)

| 字符串函数 | 描述 |
| --- | --- |
|



```
string1 &#124;&#124; string2
```



返回 _string1_ 和 _string2_ 的连接。



```
CHAR_LENGTH(string)
CHARACTER_LENGTH(string)
```



返回 _string_ 中的字符数。



```
UPPER(string)
```



返回大写的 _string_。



```
LOWER(string)
```



返回小写的 _string_。



```
POSITION(string1 IN string2)
```



返回 _string2_ 中 _string1_ 第一次出现的位置(从1开始);如果在 _string2_ 中找不到 _string1_，则返回 0。



```
TRIM([ BOTH &#124; LEADING &#124; TRAILING ] string1 FROM string2)
```



返回一个字符串，用于从字符串 _string2_ 中删除开头和/或结尾字符_string1_。默认情况下，删除了两边的空格。




```
LTRIM(string)
```



返回一个字符串，用于从字符串 _string_ 中删除左边空格。例如 `LTRIM(' This is a test String.')` 返回 "This is a test String."。



```
RTRIM(string)
```



返回一个字符串，用于从字符串 _string_ 中删除右边的空格。例如 `RTRIM('This is a test String. ')` 返回 "This is a test String."。



```
REPEAT(string, integer)
```



返回一个字符串，该字符串重复 _string_ _integer_ 次。例如 `REPEAT('This is a test String.', 2)` 返回 "This is a test String.This is a test String."。



```
REGEXP_REPLACE(string1, string2, string3)
```



从 _string1_ 返回一个字符串，与正则表达式 _string2_ 匹配的所有子字符串将被 _string3_ 替换。例如 `REGEXP_REPLACE('foobar', 'oo&#124;ar', '')` 返回 "fb"。



```
OVERLAY(string1 PLACING string2 FROM integer1 [ FOR integer2 ])
```



返回一个字符串，该字符串将 _string1_ 的 _integer2_ (默认情况下_string2_ 的长度)字符替换为位置 _integer1_ 的 _string2_。例如 `OVERLAY('This is an old string' PLACING ' new' FROM 10 FOR 5)` 返回 "This is a new string"。



```
SUBSTRING(string FROM integer1 [ FOR integer2 ])
```



返回一个 _string_ 的子字符串，子字符串从位置 _integer1_ 开始，长度 _integer2_(默认情况下到末尾)。



```
REPLACE(string1, string2, string3)
```



返回一个新字符串，它用 _string3_ (非重叠)替换所有 _string1_ 中出现的 _string2_。例如 `REPLACE("hello world", "world", "flink")` 返回 "hello flink"; `REPLACE("ababab", "abab", "z")` 返回 "zab"。



```
REGEXP_EXTRACT(string1, string2[, integer])
```



返回一个来自 _string1_ 的字符串，该字符串由指定的正则表达式 _string2_ 和正则表达式匹配组索引 _integer_ 提取。**注意:** regex匹配组索引从1开始，0表示匹配整个regex。此外，regex 匹配组索引不应超过已定义组的数目。例如  `REGEXP_EXTRACT('foothebar', 'foo(.*?)(bar)', 2)"` 返回 "bar"。



```
INITCAP(string)
```



返回一个新形式的 _string_，其中每个单词的第一个字符转换为大写，其余字符转换为小写。这里的单词是指一系列字母数字字符。



```
CONCAT(string1, string2,...)
```



返回一个字符串，该字符串连接 _string1, string2, ..._。如果任何一个参数为 NULL，则返回 NULL。例如 `CONCAT('AA', 'BB', 'CC')` 返回 "AABBCC"。



```
CONCAT_WS(string1, string2, string3,...)
```



返回一个字符串，该字符串是用分隔符 _string1_ 连接的 _string2, string3, ..._ 。分隔符被添加到要连接的字符串之间。如果 _string1_ 为空，则返回 NULL。与 `CONCAT()` 相比，`CONCAT_WS()` 会自动跳过空参数。例如 `CONCAT_WS('~', 'AA', NULL, 'BB', '', 'CC')` 返回 "AA~BB~~CC"。



```
LPAD(string1, integer, string2)
```



返回一个新的字符串，从 _string1_ 左边填充 _string2_ 到 _integer_ 个字符的长度。如果 _string1_ 的长度小于 _integer_，则返回 _string1_ 缩短为 _integer_ 的字符.例如 `LPAD('hi',4,'??')` 返回 "??hi"; `LPAD('hi',1,'??')` 返回 "h"。



```
RPAD(string1, integer, string2)
```



返回一个新的字符串，从 _string1_ 右边填充 _string2_ 到 _integer_ 个字符的长度。如果 _string1_ 的长度小于 _integer_，则返回 _string1_ 缩短为 _integer_ 的字符.例如 `RPAD('hi',4,'??')` 返回 "hi??"，`RPAD('hi',1,'??')` 返回 "h"。



```
FROM_BASE64(string)
```



返回 _string_ 的 base64 解码结果;如果 _string_ 为空，则返回 NULL。例如 `FROM_BASE64('aGVsbG8gd29ybGQ=')` 返回 "hello world"。



```
TO_BASE64(string)
```



 | 返回 _string_ 的 base64 编码结果;如果 _string_ 为空，则返回NULL。例如 `TO_BASE64('hello world')` 返回 "aGVsbG8gd29ybGQ="。 |

| 字符串函数 | 描述 |
| --- | --- |
|



```
STRING1 + STRING2
```



返回 _STRING1_ 和 _STRING2_ 的连接。



```
STRING.charLength()
```



返回 _STRING_ 中的字符数。



```
STRING.upperCase()
```



返回大写的 _STRING_。



```
STRING.lowerCase()
```



返回小写的 _STRING_。



```
STRING1.position(STRING2)
```



返回 _STRING2_ 中 _STRING1_ 第一次出现的位置(从1开始);如果在 _STRING2_ 中找不到 _STRING1_，则返回 0。



```
STRING1.trim(LEADING, STRING2)
STRING1.trim(TRAILING, STRING2)
STRING1.trim(BOTH, STRING2)
STRING1.trim(BOTH)
STRING1.trim()
```



返回一个字符串，该字符串从 _STRING1_ 中删除开头和/或结尾字符 _STRING2_。默认情况下，删除了两边的空白(whitespaces)。



```
STRING.ltrim()
```



返回一个字符串，该字符串从 _string_ 中删除左边的空白。例如 `' This is a test String.'.ltrim()` 返回 "This is a test String."。



```
STRING.rtrim()
```



返回一个字符串，该字符串从 _string_ 中删除右边的空格。例如 `'This is a test String. '.rtrim()` 返回 "This is a test String."。



```
STRING.repeat(INT)
```



返回重复字符串 _STRING_ _INT_ 次的字符串。例如 `'This is a test String.'.repeat(2)` 返回 "This is a test String.This is a test String.".



```
STRING1.regexpReplace(STRING2, STRING3)
```



返回 _STRING1_ 中的一个字符串，其中所有与正则表达式 _STRING2_ 匹配的子字符串连续被 _STRING3_ 替换。例如 `'foobar'.regexpReplace('oo&#124;ar', '')` 返回 "fb"。



```
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"。



```
STRING.substring(INT1)
STRING.substring(INT1, INT2)
```



返回一个 _STRING_ 的子字符串，从位置 _INT1_ 开始，长度 _INT2_ (默认情况下到末尾)。



```
STRING1.replace(STRING2, STRING3)
```



返回一个新字符串，它用 _string1_ 中的 _STRING3_ (非重叠)替换所有出现 _STRING2_ 的字符串。例如 `'hello world'.replace('world', 'flink')` 返回 'hello flink'; `'ababab'.replace('abab', 'z')` 返回 'zab'。



```
STRING1.regexpExtract(STRING2[, INTEGER1])
```



返回一个来自 _STRING1_ 的字符串，该字符串由指定的正则表达式 _STRING2_ 和正则表达式匹配组索引 _INTEGER1_ 提取。**注意:** regex匹配组索引从1开始，0表示匹配整个regex。此外，regex匹配组索引不应超过已定义组的数目。例如 `'foothebar'.regexpExtract('foo(.*?)(bar)', 2)"` 返回 "bar"。



```
STRING.initCap()
```



返回一个新形式的 _STRING_，其中每个单词的第一个字符转换为大写，其余字符转换为小写。这里的单词是指一系列字母数字字符。



```
concat(STRING1, STRING2, ...)
```



返回一个字符串，该字符串连接 _STRING1, STRING2, ..._。如果参数为空，则返回 NULL。例如 `concat('AA', 'BB', 'CC')` 返回 "AABBCC"。



```
concat_ws(STRING1, STRING2, STRING3, ...)
```



返回一个字符串，该字符串用分隔符 _STRING1_ 连接  _STRING2, STRING3, ..._ 。分隔符被添加到要连接的字符串之间。如果 _STRING1_ 为 NULL，则返回 NULL。与 `concat()` 相比，`concat_ws()` 会自动跳过空参数。例如 `concat_ws('~', 'AA', Null(STRING), 'BB', '', 'CC')` 返回 "AA~BB~~CC"。



```
STRING1.lpad(INT, STRING2)
```



从用 _STRING2_ 左填充的 _STRING1_ 返回一个长度为 _INT_ 字符的新字符串。如果 _STRING1_ 的长度小于 _INT_ ，则返回 _STRING1_ 缩短为 _INT_ 个的字符.例如 `'hi'.lpad(4, '??')` 返回 "??hi"; `'hi'.lpad(1, '??')` 返回 "h"。



```
STRING1.rpad(INT, STRING2)
```



从用 _STRING2_ 右填充的 _STRING1_ 返回一个长度为 _INT_ 字符的新字符串。如果 _STRING1 _的长度小于_INT_，则返回 _STRING1_ 缩短为 _INT_ 个的字符.例如 `'hi'.rpad(4, '??')` 返回 "hi??";`'hi'.rpad(1, '??')` 返回 "h"。



```
STRING.fromBase64()
```



返回 _STRING_ 的 base64 解码结果;如果 _STRING_ 为空，则返回 NULL。例如 `'aGVsbG8gd29ybGQ='.fromBase64()` 返回 "hello world"。



```
STRING.toBase64()
```



 | 返回 _STRING_ 的 base64 编码结果;如果 _STRING_ 为空，则返回 NULL。例如 `'hello world'.toBase64()` 返回 "aGVsbG8gd29ybGQ="。 |

| 字符串函数 | 描述 |
| --- | --- |
|



```
STRING1 + STRING2
```



返回 _STRING1_ 和 _STRING2_ 的连接。



```
STRING.charLength()
```



返回 _STRING_ 中的字符数。



```
STRING.upperCase()
```



返回大写的 _STRING_。



```
STRING.lowerCase()
```



返回小写的 _STRING_。



```
STRING1.position(STRING2)
```



返回 _STRING2_ 中 _STRING1_ 第一次出现的位置(从1开始);如果在 _STRING2_ 中找不到 _STRING1_，则返回0。



```
STRING.trim(
  leading = true,
  trailing = true,
  character = " ")
```



返回一个字符串，该字符串从 _STRING_ 中删除开头和/或结尾字符。



```
STRING.ltrim()
```



返回一个字符串，该字符串从 _string_ 中删除左边的空格。例如 `" This is a test String.".ltrim()` 返回 "This is a test String."。



```
STRING.rtrim()
```



返回一个字符串，该字符串从 _string_ 中删除右边的空格。例如 `"This is a test String. ".rtrim()` 返回 "This is a test String."。



```
STRING.repeat(INT)
```



返回重复字符串 _STRING_ _INT_ 次的字符串。例如 `'This is a test String.'.repeat(2)` 返回 "This is a test String.This is a test String.".



```
STRING1.regexpReplace(STRING2, STRING3)
```



返回 _STRING1_ 中的一个字符串，其中所有与正则表达式 _STRING2_ 匹配的子字符串连续被 _STRING3_ 替换。例如 `'foobar'.regexpReplace('oo&#124;ar', '')` 返回 "fb"。



```
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"。



```
STRING.substring(INT1)
STRING.substring(INT1, INT2)
```



返回一个 _STRING_ 的子字符串，从位置 _INT1_ 开始，长度 _INT2_ (默认情况下到末尾)。



```
STRING1.replace(STRING2, STRING3)
```



返回一个新字符串，它用 _string1_ 中的 _STRING3_ (非重叠)替换所有出现 _STRING2_ 的字符串。例如 `'hello world'.replace('world', 'flink')` 返回 'hello flink'; `'ababab'.replace('abab', 'z')` 返回 'zab'。



```
STRING1.regexpExtract(STRING2[, INTEGER1])
```



返回一个来自 _STRING1_ 的字符串，该字符串由指定的正则表达式 _STRING2_ 和正则表达式匹配组索引 _INTEGER1_ 提取。**注意:** regex匹配组索引从1开始，0表示匹配整个regex。此外，regex匹配组索引不应超过已定义组的数目。例如 `'foothebar'.regexpExtract('foo(.*?)(bar)', 2)"` 返回 "bar"。



```
STRING.initCap()
```



返回一个新形式的 _STRING_，其中每个单词的第一个字符转换为大写，其余字符转换为小写。这里的单词是指一系列字母数字字符。



```
concat(STRING1, STRING2, ...)
```



返回一个字符串，该字符串连接 _STRING1, STRING2, ..._。如果参数为空，则返回 NULL。例如 `concat("AA", "BB", "CC")` 返回 "AABBCC"。



```
concat_ws(STRING1, STRING2, STRING3, ...)
```



返回一个字符串，该字符串用分隔符 _STRING1_ 连接  _STRING2, STRING3, ..._ 。分隔符被添加到要连接的字符串之间。如果 _STRING1_ 为 NULL，则返回 NULL。与 `concat()` 相比，`concat_ws()` 会自动跳过空参数。例如 `concat_ws('~', 'AA', Null(STRING), 'BB', '', 'CC')` 返回 "AA~BB~~CC"。



```
STRING1.lpad(INT, STRING2)
```



从用 _STRING2_ 左填充的 _STRING1_ 返回一个长度为 _INT_ 字符的新字符串。如果 _STRING1_ 的长度小于 _INT_ ，则返回 _STRING1_ 缩短为 _INT_ 个的字符.例如 `'hi'.lpad(4, '??')` 返回 "??hi"; `'hi'.lpad(1, '??')` 返回 "h"。



```
STRING1.rpad(INT, STRING2)
```



从用 _STRING2_ 右填充的 _STRING1_ 返回一个长度为 _INT_ 字符的新字符串。如果 _STRING1 _的长度小于_INT_，则返回 _STRING1_ 缩短为 _INT_ 个的字符.例如 `'hi'.rpad(4, '??')` 返回 "hi??";`'hi'.rpad(1, '??')` 返回 "h"。



```
STRING.fromBase64()
```



返回 _STRING_ 的 base64 解码结果;如果 _STRING_ 为空，则返回 null。例如 `"aGVsbG8gd29ybGQ=".fromBase64()` 返回 "hello world"。



```
STRING.toBase64()
```



 | 返回 _STRING_ 的 base64 编码结果;如果 _STRING_ 为空，则返回 NULL。例如 `"hello world".toBase64()` 返回 "aGVsbG8gd29ybGQ="。 |

### 时间函数(Temporal Functions)

| 时间函数 | 描述 |
| --- | --- |
|



```
DATE string
```



以 "yyyy-MM-dd" 的形式返回从 _string_ 解析的 SQL 日期。



```
TIME string
```



 以 "HH:mm:ss" 的形式返回从 _string_ 解析的 SQL 时间。



```
TIMESTAMP string
```



以 "yyyy-MM-dd HH:mm:ss[.SSS]" 的形式返回从 _string_ 解析的 SQL 时间戳。



```
INTERVAL string range
```



对于SQL间隔(intervals)为毫秒，以 "dd hh:mm:ss.fff" 形式解析间隔 _string_，对于SQL间隔月，以 "yyyy-mm"形式解析。毫秒的间隔范围可以是 `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` 返回间隔。



```
CURRENT_DATE
```



返回 UTC 时区中的当前 SQL 日期。



```
CURRENT_TIME
```



返回 UTC 时区中的当前SQL时间。



```
CURRENT_TIMESTAMP
```



返回 UTC 时区中的当前 SQL 时间戳。



```
LOCALTIME
```



返回本地时区中的当前 SQL 时间。



```
LOCALTIMESTAMP
```



 返回本地时区中的当前 SQL 时间戳。



```
EXTRACT(timeintervalunit FROM temporal)
```



返回从 _temporal_ 的 _timeintervalunit_ 部分提取的 long 值。例如 `EXTRACT(DAY FROM DATE '2006-06-05')` 返回 5。



```
YEAR(date)
```



从 SQL date _date_ 返回年份。相当于 `EXTRACT(YEAR FROM date)`。例如 `YEAR(DATE '1994-09-27')` 返回 1994。



```
QUARTER(date)
```



从SQL date _date_ 返回一个季度(1到4之间的整数)。相当于 `EXTRACT(QUARTER FROM date)`。例如 `QUARTER(DATE '1994-09-27')` 返回 3。



```
MONTH(date)
```



从SQL date _date_ 返回一年中的月份(1到12之间的整数)。相当于 `EXTRACT(MONTH FROM date)`。例如 `MONTH(DATE '1994-09-27')` 返回 9。



```
WEEK(date)
```



从SQL date _date_ 返回一年中的星期(1到53之间的整数)。相当于 `EXTRACT(WEEK FROM date)`。例如 `WEEK(DATE '1994-09-27')` 返回 39。



```
DAYOFYEAR(date)
```



从SQL date _date_ 返回一年中的日期(1到366之间的整数)。相当于 `EXTRACT(DOY FROM date)`。例如 `DAYOFYEAR(DATE '1994-09-27')` 返回 270。



```
DAYOFMONTH(date)
```



从SQL date _date_ 返回一个月的日期(1到31之间的整数)。相当于 `EXTRACT(DAY FROM date)`。例如 `DAYOFMONTH(DATE '1994-09-27')` 返回 27。



```
DAYOFWEEK(date)
```



从SQL date _date_ 返回星期几(1到7之间的整数;Sunday = 1)。相当于 `EXTRACT(DOW FROM date)`。例如 `DAYOFWEEK(DATE '1994-09-27')` 返回 3。



```
HOUR(timestamp)
```



从SQL timestamp _timestamp_ 返回一天中的小时(0到23之间的整数)。相当于 `EXTRACT(HOUR FROM timestamp)`。例如 `HOUR(TIMESTAMP '1994-09-27 13:14:15')` 返回 13。



```
MINUTE(timestamp)
```



从SQL timestamp _timestamp_ 返回一小时的分钟(0到59之间的整数)。相当于 `EXTRACT(MINUTE FROM timestamp)`。例如 `MINUTE(TIMESTAMP '1994-09-27 13:14:15')` 返回 14。



```
SECOND(timestamp)
```



从 SQL 时间戳返回一分钟的秒(0到59之间的整数)。相当于 `EXTRACT(SECOND FROM timestamp)`。例如 `SECOND(TIMESTAMP '1994-09-27 13:14:15')` 返回 15。



```
FLOOR(timepoint TO timeintervalunit)
```



返回将 _timepoint_ 向下舍入为时间单位 _timeintervalunit_ 的值。例如 `FLOOR(TIME '12:44:31' TO MINUTE)` 返回 12:44:00。



```
CEIL(timepoint TO timeintervalunit)
```



返回将 _timepoint_ 向上舍入到时间单位 _timeintervalunit_ 的值。例如 `CEIL(TIME '12:44:31' TO MINUTE)` 返回 12:45:00。



```
(timepoint1, temporal1) OVERLAPS (timepoint2, temporal2)
```



如果(_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。



```
DATE_FORMAT(timestamp, string)
```



注意，这个函数有严重的bug，目前不应该使用。请实现自定义 UDF，或者使用 EXTRACT 作为解决方案。



```
TIMESTAMPADD(timeintervalunit, interval, timepoint)
```



返回一个新的时间值，该值将一个(带符号的)整数区间添加到 _timepoint_。_interval_ 的单位由单位参数提供，该参数应该是以下值之一: `SECOND`, `MINUTE`, `HOUR`, `DAY`, `WEEK`, `MONTH`, `QUARTER` 或 `YEAR`。例如 `TIMESTAMPADD(WEEK, 1, DATE '2003-01-02')` 返回 `2003-01-09`。



```
TIMESTAMPDIFF(timepointunit, timepoint1, timepoint2)
```



 | 返回 _timepoint1_ 和 _timepoint2_ 之间 _timepointunit_ 的（带符号）编号。间隔的单位由第一个参数给出，该参数应该是以下值之一：`SECOND`，`MINUTE`，`HOUR`，`DAY`，`MONTH` 或 `YEAR`。另请参见[时间间隔和点单位说明符表](#time-interval-and-point-unit-specifiers)。例如 `TIMESTAMPDIFF(DAY, TIMESTAMP '2003-01-02 10:00:00', TIMESTAMP '2003-01-03 10:00:00')` 返回 1。 |

| 时间函数 | 描述 |
| --- | --- |
|



```
STRING.toDate()
```



以 "yyyy-MM-dd" 的形式返回从 _STRING_ 解析的 SQL 日期。



```
STRING.toTime()
```



以 "HH:mm:ss" 的形式返回从 _STRING_ 解析的 SQL 时间。



```
STRING.toTimestamp()
```



以 "yyyy-MM-dd HH:mm:ss[.SSS]" 的形式返回从 _STRING_ 解析的 SQL 时间戳。



```
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_ 毫秒的间隔。



```
currentDate()
```



返回 UTC 时区中的当前 SQL 日期。



```
currentTime()
```



返回 UTC 时区中的当前 SQL 时间。



```
currentTimestamp()
```



返回 UTC 时区中的当前 SQL 时间戳。



```
localTime()
```



返回本地时区中的当前 SQL 时间。



```
localTimestamp()
```



返回本地时区中的当前 SQL 时间戳。



```
TEMPORAL.extract(TIMEINTERVALUNIT)
```



返回从 _temporal_ 的 _TIMEINTERVALUNIT_ 部分提取的 long 值。例如 `'2006-06-05'.toDate.extract(DAY)` 返回 5；`'2006-06-05'.toDate.extract(QUARTER)` 返回 2。



```
TIMEPOINT.floor(TIMEINTERVALUNIT)
```



返回将 _TIMEPOINT_ 向下舍入为时间单位 _TIMEINTERVALUNIT_ 的值。例如 `'12:44:31'.toDate.floor(MINUTE)` 返回 12:44:00



```
TIMEPOINT.ceil(TIMEINTERVALUNIT)
```



返回将 _TIMEPOINT_ 向上舍入为时间单位 _TIMEINTERVALUNIT_ 的值。例如 `'12:44:31'.toDate.ceil(MINUTE)` 返回 12:45:00。



```
temporalOverlaps(TIMEPOINT1, TEMPORAL1, TIMEPOINT2, TEMPORAL2)
```



如果(_TIMEPOINT1_, _TEMPORAL1_)和(_TIMEPOINT2_, _TEMPORAL2_)定义的两个时间间隔重叠，则返回 TRUE。时间值可以是一个时间点，也可以是一个时间间隔。例如 `temporalOverlaps('2:55:00'.toTime, 1.hour, '3:30:00'.toTime, 2.hour)` 返回 TRUE。



```
dateFormat(TIMESTAMP, STRING)
```



注意，这个函数有严重的bug，目前不应该使用。请实现自定义UDF，或者使用extract()作为解决方案。



```
timestampDiff(TIMEPOINTUNIT, TIMEPOINT1, TIMEPOINT2)
```



 | 返回 _TIMEPOINT1_ 和 _TIMEPOINT2_ 之间 _TIMEPOINTUNIT_ 的(带符号的)编号。区间的单位由第一个参数给出，该参数应该是以下值之一:`SECOND`, `MINUTE`, `HOUR`, `DAY`, `MONTH` 或 `YEAR`。参见[时间间隔和点单位说明符表](#time-interval-and-point-unit-specifiers)。例如 `timestampDiff(DAY, '2003-01-02 10:00:00'.toTimestamp, '2003-01-03 10:00:00'.toTimestamp)` 返回 `1`。 |

| 时间函数 | 描述 |
| --- | --- |
|



```
STRING.toDate
```



以 "yyyy-MM-dd" 的形式返回从 _STRING_ 解析的 SQL 日期。



```
STRING.toTime
```



以 "HH:mm:ss" 的形式返回从 _STRING_ 解析的 SQL 时间。



```
STRING.toTimestamp
```



以 "yyyy-MM-dd HH:mm:ss[.SSS]" 的形式返回从 _STRING_ 解析的 SQL 时间戳。



```
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_ 毫秒的间隔。



```
currentDate()
```



返回 UTC 时区中的当前 SQL 日期。



```
currentTime()
```



返回 UTC 时区中的当前 SQL 时间。



```
currentTimestamp()
```



返回 UTC 时区中的当前 SQL 时间戳。



```
localTime()
```



返回本地时区中的当前 SQL 时间。



```
localTimestamp()
```



返回本地时区中的当前 SQL 时间戳。



```
TEMPORAL.extract(TIMEINTERVALUNIT)
```



返回从 _temporal_ 的 _TIMEINTERVALUNIT_ 部分提取的 long 值。例如 `"2006-06-05".toDate.extract(TimeIntervalUnit.DAY)` 返回 5；`"2006-06-05".toDate.extract(QUARTER)` 返回 2。



```
TIMEPOINT.floor(TIMEINTERVALUNIT)
```



返回将 _TIMEPOINT_ 向下舍入为时间单位 _TIMEINTERVALUNIT_ 的值。例如 `"12:44:31".toDate.floor(TimeIntervalUnit.MINUTE)` 返回 12:44:00。



```
TIMEPOINT.ceil(TIMEINTERVALUNIT)
```



返回将 _TIMEPOINT_ 向上舍入为时间单位 _TIMEINTERVALUNIT_ 的值。例如 `"12:44:31".toDate.ceil(TimeIntervalUnit.MINUTE)` 返回 12:45:00。



```
temporalOverlaps(TIMEPOINT1, TEMPORAL1, TIMEPOINT2, TEMPORAL2)
```



如果(_TIMEPOINT1_, _TEMPORAL1_)和(_TIMEPOINT2_, _TEMPORAL2_)定义的两个时间间隔重叠，则返回 TRUE。时间值可以是一个时间点，也可以是一个时间间隔。例如 `temporalOverlaps("2:55:00".toTime, 1.hour, "3:30:00".toTime, 2.hour)` 返回 TRUE。



```
dateFormat(TIMESTAMP, STRING)
```



注意，这个函数有严重的bug，目前不应该使用。请实现自定义UDF，或者使用extract()作为解决方案。



```
timestampDiff(TIMEPOINTUNIT, TIMEPOINT1, TIMEPOINT2)
```



 | 返回 _TIMEPOINT1_ 和 _TIMEPOINT2_ 之间 _TIMEPOINTUNIT_ 的(带符号)编号。区间的单位由第一个参数给出，该参数应该是以下值之一:`SECOND`, `MINUTE`, `HOUR`, `DAY`, `MONTH` 或 `YEAR`。参见[时间间隔和点单位说明符表](#time-interval-and-point-unit-specifiers)。例如 `timestampDiff(TimePointUnit.DAY, '2003-01-02 10:00:00'.toTimestamp, '2003-01-03 10:00:00'.toTimestamp)` 返回 `1`。 |


### 条件函数(Conditional Functions)

| 条件函数 | 描述 |
| --- | --- |
|



```
CASE value
WHEN value1_1 [, value1_2 ]* THEN result1
[ WHEN value2_1 [, value2_2 ]* THEN result2 ]*
[ ELSE resultZ ]
END
```



当 _value_ 第一次包含在(_valueX_1, valueX_2, ..._)时返回 _resultX_。如果没有值匹配，则返回 _resultZ_（如果已提供），否则返回NULL。



```
CASE
WHEN condition1 THEN result1
[ WHEN condition2 THEN result2 ]*
[ ELSE resultZ ]
END
```



满足第一个 _conditionX_ 时返回 _resultX_。如果没有满足条件，则返回 _resultZ_（如果已提供），否则返回 NULL。



```
NULLIF(value1, value2)
```



如果 _value1_ 等于 _value2_，则返回 NULL; 否则返回 _value1_。例如 `NULLIF(5, 5)` 返回 NULL; `NULLIF(5, 0)` 返回 5。



```
COALESCE(value1, value2 [, value3 ]* )
```



 | 从 _value1, value2, ..._ 返回非 NULL 的第一个值。例如 `COALESCE(NULL, 5)` 返回 5。 |

| 条件函数 | 描述 |
| --- | --- |
|



```
BOOLEAN.?(VALUE1, VALUE2)
```



 | 如果 _BOOLEAN_ 的计算结果为 TRUE，则返回 _VALUE1_; 否则返回 _VALUE2_。例如 `(42 &gt; 5).?('A', 'B')` 返回 "A"。 |

| 条件函数 | 描述 |
| --- | --- |
|



```
BOOLEAN.?(VALUE1, VALUE2)
```



 | 如果 _BOOLEAN_ 的计算结果为 TRUE，则返回 _VALUE1_; 否则返回 _VALUE2_。例如 `(42 &gt; 5).?("A", "B")` 返回 "A"。 |

### 类型转换函数(Type Conversion Functions)

| 类型转换函数 | 描述 |
| --- | --- |
|



```
CAST(value AS type)
```



 | 返回一个新的 _value_ 被强制转换为 _type_ 类型。查看支持的类型[此处](sql.html#data-types)。例如 `CAST('42' AS INT)` 返回 42；`CAST(NULL AS VARCHAR)` 返回 VARCHAR 类型的 NULL。 |

| 类型转换函数 | 描述 |
| --- | --- |
|



```
ANY.cast(TYPE)
```



 | 返回一个新的 _ANY_ 被强制转换为类型 _TYPE_。 查看支持的类型[此处]tableApi.html#data-types)。例如 `'42'.cast(INT)` 返回 42；`Null(STRING)` 返回 返回 STRING 类型的 NULL。 |

| 类型转换函数 | 描述 |
| --- | --- |
|



```
ANY.cast(TYPE)
```



 | 返回一个新的 _ANY_ 被强制转换为类型 _TYPE_。查看支持的类型[此处](tableApi.html#data-types)。例如 `"42".cast(Types.INT)` 返回 42；`Null(Types.STRING)` 返回 STRING 类型的 NULL。 |

### 集合函数(Collection Functions)

| 集合函数 | 描述 |
| --- | --- |
|



```
CARDINALITY(array)
```



返回 _array_ 中的元素数量。



```
array ‘[’ integer ‘]’
```



返回 _array_ 中 _integer_ 位置的元素。索引从1开始。



```
ELEMENT(array)
```



返回 _array_ 的唯一元素(基数应为1); 如果 _array_ 为空，则返回 NULL。如果 _array_ 有多个元素，则抛出异常。



```
CARDINALITY(map)
```



返回 _map_ 中的条目数。



```
map ‘[’ value ‘]’
```



 | 返回 _map_ 中 key _value_ 指定的值。 |

| 集合函数 | 描述 |
| --- | --- |
|



```
ARRAY.cardinality()
```



返回 _ARRAY_ 中的元素数量。



```
ARRAY.at(INT)
```



返回 _ARRAY_ 中 _INT_ 位置的元素。索引从1开始。



```
ARRAY.element()
```



返回 _ARRAY_ 的唯一元素(基数应为1); 如果 _ARRAY_ 为空，则返回 NULL。如果 _ARRAY_ 有多个元素，则抛出异常。



```
MAP.cardinality()
```



返回 _MAP_ 中的条目数。



```
MAP.at(ANY)
```



 | 返回 _MAP_ 中 key _ANY_ 指定的值。 |

| 集合函数 | 描述 |
| --- | --- |
|



```
ARRAY.cardinality()
```



返回 _ARRAY_ 中的元素数量。



```
ARRAY.at(INT)
```



返回 _ARRAY_ 中 _INT_ 位置的元素。索引从1开始。



```
ARRAY.element()
```



返回 _ARRAY_ 的唯一元素(基数应为1); 如果 _ARRAY_ 为空，则返回 NULL。如果 _ARRAY_ 有多个元素，则抛出异常。



```
MAP.cardinality()
```



返回 _MAP_ 中的条目数。



```
MAP.at(ANY)
```



 | 返回 _MAP_ 中 key _ANY_ 指定的值。 |

### Value 构建函数(Value Construction Functions)

| Value 构建函数 | 描述 |
| --- | --- |
|



```
ROW(value1, [, value2]*)
(value1, [, value2]*)
```



返回从值(values)列表(_value1, value2,_...)创建的行。



```
ARRAY ‘[’ value1 [, value2 ]* ‘]’
```



返回从值(values)列表(_value1, value2_, ...)创建的数组。



```
MAP ‘[’ value1, value2 [, value3, value4 ]* ‘]’
```



 | 返回从键值对(key-value pairs)列表((_value1, value2_), _(value3, value4)_, ...)创建的映射(map)。 |

| Value 构建函数 | 描述 |
| --- | --- |
|



```
row(ANY1, ANY2, ...)
```



返回从对象值列表(_ANY1, ANY2_, ...)创建的行。行是复合类型，可以通过[值访问函数](#value-access-functions)访问。



```
array(ANY1, ANY2, ...)
```



返回从对象值列表(_ANY1, ANY2_, ...)创建的数组。



```
map(ANY1, ANY2, ANY3, ANY4, ...)
```



返回从键值对列表((_ANY1, ANY2_), _(ANY3, ANY4)_, ...)创建的映射(map)。



```
NUMERIC.rows
```



 | 创建 _NUMERIC_ 行间隔(通常用于创建窗口)。 |

| Value 构建函数 | 描述 |
| --- | --- |
|



```
row(ANY1, ANY2, ...)
```



返回从对象值列表(_ANY1, ANY2_, ...)创建的行。行是复合类型，可以通过[值访问函数](#value-access-functions)访问。



```
array(ANY1, ANY2, ...)
```



返回从对象值列表(_ANY1, ANY2_, ...)创建的数组。



```
map(ANY1, ANY2, ANY3, ANY4, ...)
```



返回从键值对列表((_ANY1, ANY2_), _(ANY3, ANY4)_, ...)创建的映射(map)。



```
NUMERIC.rows
```



 | 创建 _NUMERIC_ 行间隔(通常用于创建窗口)。 |

### Value 访问函数(Value Access Functions)

| Value 访问函数 | 描述 |
| --- | --- |
|



```
tableName.compositeType.field
```



按名称返回 Flink 复合类型(例如 Tuple, POJO)中字段的值



```
tableName.compositeType.*
```



 | 返回 Flink 复合类型(例如 Tuple，POJO)的平面表示，该复合类型将其每个直接子类型转换为单独的字段。在大多数情况下，平面表示的字段的命名方式与原始字段类似，但使用美元分隔符(例如 `mypojo$mytuple$f0`)。 |

| Value 访问函数 | 描述 |
| --- | --- |
|



```
COMPOSITE.get(STRING)
COMPOSITE.get(INT)
```



通过名称或索引返回 Flink 复合类型(例如 Tuple, POJO)中的字段的值。例如 `pojo.get('myField')` 或 `tuple.get(0)`。



```
ANY.flatten()
```



 | 返回 Flink 复合类型(例如Tuple, POJO)的平面表示，该复合类型将其每个直接子类型转换为单独的字段。在大多数情况下，平面表示的字段的命名方式与原始字段类似，但使用美元分隔符(例如 `mypojo$mytuple$f0`) |

| Value access functions | Description |
| --- | --- |
|



```
COMPOSITE.get(STRING)
COMPOSITE.get(INT)
```



通过名称或索引返回 Flink 复合类型(例如 Tuple, POJO)中的字段的值。例如 `pojo.get('myField')` 或 `tuple.get(0)`。



```
ANY.flatten()
```



 | 返回 Flink 复合类型(例如Tuple, POJO)的平面表示，该复合类型将其每个直接子类型转换为单独的字段。在大多数情况下，平面表示的字段的命名方式与原始字段类似，但使用美元分隔符(例如 `mypojo$mytuple$f0`) |

### 分组函数(Grouping Functions)

| 分组函数 | 描述 |
| --- | --- |
|



```
GROUP_ID()
```



返回唯一标识分组键组合的整数。



```
GROUPING(expression1 [, expression2]* )
GROUPING_ID(expression1 [, expression2]* )
```



 | 返回给定分组表达式的位向量。 |

| 分组函数 | 描述 |
| --- | --- |

| 分组函数 | 描述 |
| --- | --- |

### Hash 函数(Hash Functions)

| Hash 函数 | 描述 |
| --- | --- |
|



```
MD5(string)
```



以 32 个十六进制数字的字符串返回 _string_ 的 MD5 哈希值;如果 _string_ 为 NULL，则返回NULL。



```
SHA1(string)
```



以 40 个十六进制数字的字符串返回 _string_ 的 SHA-1 哈希值;如果 _string_ 为 NULL，则返回 NULL。



```
SHA224(string)
```



以 56 个十六进制数字的字符串返回 _string_ 的 SHA-224 哈希值;如果 _string_ 为 NULL，则返回NULL。



```
SHA256(string)
```



以 64 个十六进制数字的字符串返回 _string_ 的 SHA-256 哈希值;如果 _string_ 为 NULL，则返回 NULL。



```
SHA384(string)
```



以 96 个十六进制数字的字符串返回 _string_ 的 SHA-384 哈希值;如果 _string_ 为 NULL，则返回 NULL。



```
SHA512(string)
```



以 128 个十六进制数字的字符串返回 _string_ 的 SHA-512 哈希值;如果 _string_ 为 NULL，则返回 NULL。



```
SHA2(string, hashLength)
```



 | 使用 SHA-2 哈希函数家族(SHA-224、SHA-256、SHA-384或SHA-512)返回哈希。第一个参数 _string_ 是要散列的字符串，第二个参数 _hashLength_ 是结果的位长(224、256、384或512)。如果 _string_ 或 _hashLength_ 为空，则返回 NULL。 |

| Hash 函数 | 描述 |
| --- | --- |
|



```
STRING.md5()
```



以 32 个十六进制数字的字符串返回 _STRING_ 的 MD5 哈希值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha1()
```



以 40 个十六进制数字的字符串返回 _STRING_ 的 SHA-1 哈希值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha224()
```



以 56 个十六进制数字的字符串返回 _STRING_ 的 SHA-224 哈希值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha256()
```



以 64 个十六进制数字的字符串返回 _STRING_ 的 SHA-256 哈希值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha384()
```



以 96 个十六进制数字的字符串返回 _STRING_ 的 SHA-384 哈希值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha512()
```



以 128 个十六进制数字的字符串返回 _STRING_ 的 SHA-512 哈希值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha2(INT)
```



 | 返回 _INT_ (可以是224、256、384或512)为 _STRING_ 指定的 SHA-2 族(SHA-224、SHA-256、SHA-384或SHA-512)散列值。如果 _STRING_ 或 _INT_ 为 NULL，则返回 NULL。 |

| Hash 函数 | 描述 |
| --- | --- |
|



```
STRING.md5()
```



以 32 个十六进制数字的字符串返回 _STRING_ 的 MD5 散列值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha1()
```



以 40 个十六进制数字的字符串返回 _STRING_ 的 SHA-1 散列值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha224()
```



以 56 个十六进制数字的字符串返回 _STRING_ 的 SHA-224 散列值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha256()
```



以 64 个十六进制数字的字符串返回 _STRING_ 的 SHA-256 散列值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha384()
```



以 96 个十六进制数字的字符串返回 _STRING_ 的 SHA-384 散列值;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha512()
```



以 128 个十六进制数字的字符串返回 _STRING_ 的 SHA-512 散列;如果 _STRING_ 为 NULL，则返回 NULL。



```
STRING.sha2(INT)
```



 | 返回 _INT_ (可以是224、256、384或512)为 _STRING_ 指定的 SHA-2族(SHA-224、SHA-256、SHA-384或SHA-512)散列值。如果 _STRING_ 或 _INT_ 为空，则返回 NULL。 |

### 辅助函数(Auxiliary Functions)

| 辅助函数 | 描述 |
| --- | --- |

| 辅助函数 | 描述 |
| --- | --- |
|



```
ANY.as(NAME1, NAME2, ...)
```



 | 指定 _ANY_(字段)的名称。如果表达式扩展到多个字段，可以指定其他名称。 |

| 辅助函数 | 描述 |
| --- | --- |
|



```
ANY.as(NAME1, NAME2, ...)
```



 | 指定 _ANY_ (字段)的名称。如果表达式扩展到多个字段，可以指定其他名称。 |

## 聚合函数(Aggregate Functions)

聚合函数接受跨所有行的表达式作为输入，并返回单个聚合值作为结果。

| 聚合函数 | 描述 |
| --- | --- |
|



```
COUNT([ ALL ] expression &#124; DISTINCT expression1 [, expression2]*)
```



默认情况下或使用ALL，返回 _expression_ 不为NULL的输入行数。将 DISTINCT 用于每个值的一个唯一实例。



```
COUNT(*)
COUNT(1)
```



返回输入行数。



```
AVG([ ALL &#124; DISTINCT ] expression)
```



默认情况下或使用关键字ALL，返回所有输入行中 _expression_ 的平均值（算术平均值）。将 DISTINCT 用于每个值的一个唯一实例。



```
SUM([ ALL &#124; DISTINCT ] expression)
```



默认情况下或使用关键字 ALL，在所有输入行中返回 _expression_ 的总和。将 DISTINCT 用于每个值的一个唯一实例。



```
MAX([ ALL &#124; DISTINCT ] expression)
```



默认情况下或使用关键字 ALL，在所有输入行中返回 _expression_ 的最大值。将 DISTINCT 用于每个值的一个唯一实例。



```
MIN([ ALL &#124; DISTINCT ] expression)
```



默认情况下或使用关键字 ALL，在所有输入行中返回 _expression_ 的最小值。将 DISTINCT 用于每个值的一个唯一实例。



```
STDDEV_POP([ ALL &#124; DISTINCT ] expression)
```



默认情况下或使用关键字 ALL，在所有输入行中返回 _expression_ 的总体标准差。将 DISTINCT 用于每个值的一个唯一实例。



```
STDDEV_SAMP([ ALL &#124; DISTINCT ] expression)
```



默认情况下或使用关键字 ALL，在所有输入行中返回 _expression_ 的样本标准差。将 DISTINCT 用于每个值的一个唯一实例。



```
VAR_POP([ ALL &#124; DISTINCT ] expression)
```



默认情况下或使用关键字 ALL，在所有输入行中返回 _expression_ 的总体方差（总体标准差的平方）。将 DISTINCT 用于每个值的一个唯一实例。



```
VAR_SAMP([ ALL &#124; DISTINCT ] expression)
```



默认情况下或使用关键字 ALL，在所有输入行中返回 _expression_ 的样本方差（样本标准差的平方）。将 DISTINCT 用于每个值的一个唯一实例。



```
COLLECT([ ALL &#124; DISTINCT ] expression)
```



 | 默认情况下或使用关键字 ALL，在所有输入行中返回 _expression_ 的多个集合。NULL 值将被忽略。将 DISTINCT 用于每个值的一个唯一实例。 |

| 聚合函数 | 描述 |
| --- | --- |
|



```
FIELD.count
```



返回 _FIELD_ 不为 NULL 的输入行数。



```
FIELD.avg
```



返回所有输入行中 _FIELD_ 的平均值(算术平均值)。



```
FIELD.sum
```



返回所有输入行中数字字段 _FIELD_ 的总和。如果所有值都为 NULL，则返回 NULL。



```
FIELD.sum0
```



返回所有输入行中数字字段 _FIELD_ 的总和。如果所有值都为 NULL，则返回 0。



```
FIELD.max
```



返回所有输入行中数字字段 _FIELD_ 的最大值。



```
FIELD.min
```



返回所有输入行中数字字段 _FIELD_ 的最小值。



```
FIELD.stddevPop
```



返回所有输入行中数字字段 _FIELD_ 的总体标准差。



```
FIELD.stddevSamp
```



返回所有输入行中数字字段 _FIELD_ 的样本标准差。



```
FIELD.varPop
```



返回所有输入行中数字字段 _FIELD_ 的总体方差(总体标准差的平方)。



```
FIELD.varSamp
```



返回所有输入行中数字字段 _FIELD_ 的样本方差(样本标准差的平方)。



```
FIELD.collect
```



 | 在所有输入行中返回 _FIELD_ 的多重集(multiset)。 |

| 聚合函数 | 描述 |
| --- | --- |
|



```
FIELD.count
```



返回 _FIELD_ 不为 NULL 的输入行数。



```
FIELD.avg
```



返回所有输入行中 _FIELD_ 的平均值(算术平均值)。



```
FIELD.sum
```



返回所有输入行中数字字段 _FIELD_ 的总和。如果所有值都为 NULL，则返回 NULL。



```
FIELD.sum0
```



返回所有输入行中数字字段 _FIELD_ 的总和。如果所有值都为 NULL，则返回 0。



```
FIELD.max
```



返回所有输入行中数字字段 _FIELD_ 的最大值。



```
FIELD.min
```



返回所有输入行中数字字段 _FIELD_ 的最小值。



```
FIELD.stddevPop
```



返回所有输入行中数字字段 _FIELD_ 的总体标准差。



```
FIELD.stddevSamp
```



返回所有输入行中数字字段 _FIELD_ 的样本标准差。



```
FIELD.varPop
```



返回所有输入行中数字字段 _FIELD_ 的总体方差(总体标准差的平方)。



```
FIELD.varSamp
```



返回所有输入行中数字字段 _FIELD_ 的样本方差(样本标准差的平方)。



```
FIELD.collect
```



 | 在所有输入行中返回 _FIELD_ 的多重集(multiset)。 |

## 日期格式说明符(Date Format Specifiers)

下表列出了日期格式函数的说明符。

| 说明符 | 描述 |
| --- | --- |
|



```
%a
```



缩写的工作日名称 (`Sun` .. `Sat`)



```
%b
```



缩写的月份名称(`Jan` .. `Dec`)



```
%c
```



月，数字(`1` .. `12`)



```
%D
```



带有英文后缀的月份的某天 (`0th`, `1st`, `2nd`, `3rd`, ...)



```
%d
```



每月的某天，数字 (`01` .. `31`)



```
%e
```



每月的某天，数字(`1` .. `31`)



```
%f
```



秒的分数(打印6位数字:`000000` .. `999000`;1 - 9位数用于解析:`0` .. `999999999`)(时间戳被截断为毫秒。)



```
%H
```



小时 (`00` .. `23`)



```
%h
```



小时 (`01` .. `12`)



```
%I
```



小时 (`01` .. `12`)



```
%i
```



分钟，数字(`00` .. `59`)



```
%j
```



一年中的一天(`001` .. `366`)



```
%k
```



小时 (`0` .. `23`)



```
%l
```



小时 (`1` .. `12`)



```
%M
```



月份名称 (`January` .. `December`)



```
%m
```



月，数字 (`01` .. `12`)



```
%p
```



`AM` 或 `PM`



```
%r
```



时间，12小时 (`hh:mm:ss` 后跟 `AM` or `PM`)



```
%S
```



秒 (`00` .. `59`)



```
%s
```



秒 (`00` .. `59`)



```
%T
```



时间，24小时 (`hh:mm:ss`)



```
%U
```



周 (`00` .. `53`)，星期日是一周的第一天



```
%u
```



周(`00` .. `53`)，星期一是一周的第一天



```
%V
```



周(`01` .. `53`)，星期日是一周的第一天; 与 `%X` 一起使用



```
%v
```



周(`01` .. `53`)，星期一是一周的第一天; 与 `%x` 一起使用



```
%W
```



工作日名称 (`Sunday` .. `Saturday`)



```
%w
```



星期几(`0` .. `6`)，星期日是一周的第一天



```
%X
```



一周的年份，星期一是一周的第一天，数字，四位数; 与 `%V` 一起使用



```
%x
```



一周的年份，星期一是一周的第一天，数字，四位数; 与 `%v` 一起使用



```
%Y
```



年份，数字，四位数



```
%y
```



年份，数字(两位数)



```
%%
```



文字 `%` 字符



```
%x
```



 | `x`，对于上面没有列出的任何 `x` |

## 时间间隔和点单位说明符(Time Interval and Point Unit Specifiers)

下表列出了时间间隔和时间点单位的说明符。

对于 Table API，请使用 `_` 作为空格（例如，`DAY_TO_HOUR`）。

| Time Interval Unit | Time Point Unit |
| --- | --- |
| `MILLENIUM` _(SQL-only)_ |   |
| `CENTURY` _(SQL-only)_ |   |
| `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` |
|   | `MICROSECOND` |
| `DOY` _(SQL-only)_ |   |
| `DOW` _(SQL-only)_ |   |
|   | `SQL_TSI_YEAR` _(SQL-only)_ |
|   | `SQL_TSI_QUARTER` _(SQL-only)_ |
|   | `SQL_TSI_MONTH` _(SQL-only)_ |
|   | `SQL_TSI_WEEK` _(SQL-only)_ |
|   | `SQL_TSI_DAY` _(SQL-only)_ |
|   | `SQL_TSI_HOUR` _(SQL-only)_ |
|   | `SQL_TSI_MINUTE` _(SQL-only)_ |
|   | `SQL_TSI_SECOND` _(SQL-only)_ |
