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');
                    Converts an epoch seconds or epoch milliseconds to a TIMESTAMP_LTZ, the valid precision is 0 or 3, the 0 represents TO_TIMESTAMP_LTZ(epochSeconds, 0), the 3 represents TO_TIMESTAMP_LTZ(epochMilliseconds, 3). If no precision is provided, the default precision is 3. If any input is null, the function will return null.
                    
返回给定时间列属性 rowtime 的当前水印，如果管道中的当前操作没有可用的上游操作的公共水印时则为 NULL。
函数的返回类型被推断为与提供的时间列属性匹配，但调整后的精度为 3。例如时间列属性为 TIMESTAMP_LTZ(9)，则函数将返回
TIMESTAMP_LTZ(3)。
请注意，此函数可以返回 NULL，您可能必须考虑这种情况。例如，如果您想过滤掉迟到数据，您可以使用：
WHERE
  CURRENT_WATERMARK(ts) IS NULL
  OR ts > CURRENT_WATERMARK(ts)
                    CASE value
WHEN value1_1 [, value1_2]* THEN RESULT1
(WHEN value2_1 [, value2_2 ]* THEN result_2)*
(ELSE result_z)
                    当值 value 第一次满足在 (valueX_1, valueX_2, …) 中时，返回对应的结果 resultX。当没有匹配到时，如果提供了 result_z 则返回 result_z，
否则返回 NULL。
                    
｜ 从 value1, value2, … 返回第一个不为 NULL 的值。例如 COALESCE(3, 5, 3) 返回 3。 如果所有参数为 NULL，返回 NULL。返回类型是所有参数的限制最最少的通用类型，如果所有参数是可空的类型，返回类型也是可空的类型。




    

-- 返回 f0，f1中第一个非空的值，如果 f0 和 f1 都是 NULL，则返回 'default' COALESCE(f0, f1, 'default') ```
                    
如果输入为 NULL，则返回 null_replacement；否则返回 input。
与 COALESCE 或 CASE WHEN 相比，此函数返回的数据类型在是否为空方面非常明确。返回的类型是两个参数的公共类型，但只有在 null_replacement 可为空时才能为可空类型。
该函数允许将可空的列传递到使用 NOT NULL 约束声明的函数或表中。
例如 IFNULL(nullable_column, 5) 一定不返回 NULL。
                    
返回 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) 抛出异常且作业失败。
                    返回输入表达式的数据类型的字符串表示。默认情况下返回的字符串是一个摘要字符串，可能会为了可读性而省略某些细节。
如果 force_serializable 设置为 TRUE，则字符串表示可以持久化保存在 catalog 中的完整数据类型。
请注意，特别是匿名的内联数据类型没有可序列化的字符串表示。在这种情况下返回 NULL。
                    Returns an ARRAY that contains the elements from array1 that are not in array2, without duplicates. If no elements remain after excluding the elements in array2 from array1, the function returns an empty ARRAY. If one or both arguments are NULL, the function returns NULL. The order of the elements from array1 is kept.
                    Returns an array of substrings by splitting the input string based on the given delimiter. If the delimiter is not found in the string, the original string is returned as the only element in the array. If the delimiter is empty, every character in the string is split. If the string or delimiter is null, a null value is returned. If the delimiter is found at the beginning or end of the string, or there are contiguous delimiters, then an empty string is added to the array.
JSON 函数使用符合 ISO/IEC TR 19075-6 SQL标准的 JSON 路径表达式。 它们的语法受到 ECMAScript 的启发，并
采用了 ECMAScript 的许多功能，但不是其子集或超集。
路径表达式有宽容模式和严格模式两种模式。 当不指定时，默认使用严格模式。
严格模式旨在从 Schema 的角度检查数据，并且只要数据不符合路径表达式就会抛出错误。 但是像JSON_VALUE的函数
允许定义遇到错误时的后备行为。 另一方面，宽容模式更加宽容，并将错误转换为空序列。
特殊字符$表示 JSON 路径中的根节点。 路径可以访问属性（$.a）， 数组元素 ($.a[0].b)，或遍历数组中的
所有元素 ($.a[*].b)。
已知限制：
目前，并非宽容模式的所有功能都被正确支持。 这是一个上游的错误（CALCITE-4717）。无法保证行为符合标准。
                    
判定给定字符串是否为有效的 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
如果要忽略错误行为，那么将 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 字符串。如果值为 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 EMPTY 或
NULL 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 决定是否将提取的值包装到一个数组中，以及是否无条件地这样做，还是只有当值本身不是数组时才这样做。
onEmpty 和 onError 分别决定路径表达式为空或引发错误时的行为。默认情况下，这两种情况都会返回 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 对象字符串。
注意，键必须是非 NULL 字符串字面值，而值可以是任意表达式。
这个函数返回一个 JSON 字符串。ON NULL 行为定义了如何处理 NULL 值。如果省略，则默认为 NULL ON NULL。
值是由另一个 JSON 构造函数调用 (JSON_OBJECT，JSON_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":{"value":42}}}'
JSON_OBJECT('K1' VALUE JSON('{"K2": {"value": 42}}'))
-- '{"K1":{"K2":"V"}}'
JSON_OBJECT(
  KEY 'K1'
  VALUE JSON_OBJECT(
    KEY 'K2'
    VALUE 'V'
sql: JSON(value)
table: json(value)

description: |
需要的参数是一个原始的、预先格式化的 JSON 字符串，返回值是这个字符串对应的JSON值，而不将其作为字符串转义。
该函数目前只能在“JSON_OBJECT”函数中使用。它允许通过预格式化的 JSON 字符串将直接插入到生成的 JSON 结构中，而不是作为字符串值转义。
该函数通常用来读取外部的Json字符串，将其转成 JSON 结构存储在JSON_OBJECT。如果值为 NULL 或空，则该函数返回 NULL。
-- {"K":{"K2":42}}
JSON_OBJECT('K' VALUE JSON('{"K2": 42}'))
-- {"K":{"K2":{"K3":42}}}
JSON_OBJECT('K' VALUE JSON('{"K2":{"K3":42}}'))
-- {"K": null}
JSON_OBJECT('K' VALUE JSON(''))
-- JSON 函数只能在 JSON_OBJECT 函数中使用
JSON('{"value": 42}')
                    
将数值列表构建为 JSON 数组字符串。
这个函数返回一个 JSON 字符串，值可以是任意表达式。ON NULL 行为定义了如何处理 NULL 值。如果省略，则假定 ABSENT ON NULL 为默认值。
元素是由另一个 JSON 构造函数调用 (JSON_OBJECT，JSON_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))
                    
将 JSON 字符串解析为 Variant。如果 JSON 字符串无效，将抛出错误。如果希望返回 NULL 而不是抛出错误，
请使用 TRY_PARSE_JSON 函数。
如果输入的 JSON 字符串中存在重复的键，当 allowDuplicateKeys 为 true 时，解析器会保留最后一个出现的具有相
同键的字段，否则当 allowDuplicateKeys 为 false 时，它会抛出一个错误。默认情况下，
allowDuplicateKeys 的值为 false。
                    
尽可能将 JSON 字符串解析为 Variant。如果 JSON 字符串无效，则返回 NULL。如果希望抛出错误而不是返回 NULL，
请使用 PARSE_JSON 函数。
如果输入的 JSON 字符串中存在重复的键，当 allowDuplicateKeys 为 true 时，解析器会保留最后一个出现的具有相
同键的字段，否则当 allowDuplicateKeys 为 false 时，它会抛出一个错误。默认情况下，
allowDuplicateKeys 的值为 false。
                    
Returns a literal describing an arbitrary, unvalidated list of column names. Passing a list of columns
can be useful for parameterizing a function. In particular, it enables declaring the on_time argument
for process table functions (PTFs).
f(columns => DESCRIPTOR(`col1`, `col2`), on_time => DESCRIPTOR(`ts`))
                    
Creates a structured object from a list of key-value pairs.
This function creates an instance of a structured type identified by the given class name.
The structured type is created by providing alternating key-value pairs where keys must be
string literals and values can be arbitrary expressions.
Note: The class name is only used for distinguishing two structured types with identical fields.
Structured types are internally handled with suitable data structures. Thus, serialization and equality checks are managed by the system.
In Table API and UDF calls, the system will attempt to resolve the class name to an actual implementation class.
In this case the class name needs to be present in the user classpath. If resolution fails, Row.class is used as a fallback.
-- Creates a User object with complex fields "name", "age", and "address"
OBJECT_OF('com.example.User', 'name', 'Bob', 'age', 21, 'address', OBJECT_OF('com.example.Address', 'street', 'primary', 'city', 'Berlin'))
                    将窗口分区中的所有数据按照顺序划分为 n 个分组，返回分配给各行数据的分组编号（从 1 开始，最大为 n）。
如果不能均匀划分为 n 个分组，则剩余值从第 1 个分组开始，为每一分组分配一个。
比如某个窗口分区有 6 行数据，划分为 4 个分组，则各行的分组编号为：1，1，2，2，3，4。
                    默认情况下或使用关键字ALL，返回输入行中表达式所组成的数组，并且如果没有输入行，则返回 NULL。使用 DISTINCT 则对所有值去重后计算。
默认情况下NULL 值不会被忽略，使用 IGNORE NULLS 忽略 NULL 值。
目前尚不支持 ORDER BY 子句。
                    
通过将 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 对象字符串。
项目表达式可以是任意的，包括其他 JSON 函数。如果值为 NULL，则 ON NULL 行为定义了要执行的操作。如果省略，默认情况下假定为 ABSENT ON NULL。
此函数目前不支持 OVER windows、未绑定的 session windows 或 hop windows。
-- '["Apple","Banana","Orange"]'
SELECT
  JSON_ARRAYAGG(product)
FROM orders
    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)))));
  Scala
  
table
    .groupBy(withColumns(range(1, 3)))
    .select(withColumns('a to 'b), myUDAgg(myUDF(withColumns(5 to 20))))
  Python
  
table
    .group_by(with_columns(range_(1, 3)))
    .select(with_columns(range_('a', 'b')), myUDAgg(myUDF(with_columns(range_(5, 20)))))
 Back to top

  Named Arguments
By default, values and expressions are mapped to a function’s arguments based on the position in the function call,
for example f(42, true). All functions in both SQL and Table API support position-based arguments.
If the function declares a static signature, named arguments are available as a convenient alternative.
The framework is able to reorder named arguments and consider optional arguments accordingly, before passing them
into the function call. Thus, the order of arguments doesn’t matter when calling a function and optional arguments
don’t have to be provided.
In DESCRIBE FUNCTION and documentation a static signature is indicated by the => assignment operator,
for example f(left => INT, right => BOOLEAN). Note that not every function supports named arguments. Named
arguments are not available for signatures that are overloaded, use varargs, or any other kind of input type strategy.
User-defined functions with a single eval() method usually qualify for named arguments.
Named arguments can be used as shown below:
    MyUdf.class,
    $("my_column").asArgument("input"),
    lit(42).asArgument("threshold")
 Back to top