Built-in Functions

aes_decrypt(expr, key[, mode[, padding[, aad]]]) - 返回使用AES在mode模式下使用padding解密expr的值。支持16、24和32位的密钥长度。支持的(mode, padding)组合有('ECB', 'PKCS')、('GCM', 'NONE')和('CBC', 'PKCS')。可选的附加认证数据（AAD）仅支持GCM模式。如果在加密时提供了AAD，解密时必须提供相同的AAD值。默认模式是GCM。

参数:

expr - 要解密的二进制值。
key - 用于解密数据的密码短语。
mode - 指定应使用哪种块密码模式来解密消息。有效模式：ECB、GCM、CBC。
padding - 指定如何填充长度不是块大小倍数的消息。有效值：PKCS、NONE、DEFAULT。DEFAULT填充意味着ECB使用PKCS，GCM使用NONE，CBC使用PKCS。
aad - 可选的额外认证数据。仅支持GCM模式。这可以是任何自由格式的输入，并且在加密和解密时都必须提供。

示例：

> SELECT aes_decrypt(unhex('83F16B2AA704794132802D248E6BFD4E380078182D1544813898AC97E709B28A94'), '0000111122223333');
 Spark
> SELECT aes_decrypt(unhex('6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210'), '0000111122223333', 'GCM');
 Spark SQL
> SELECT aes_decrypt(unbase64('3lmwu+Mw0H3fi5NDvcu9lg=='), '1234567890abcdef', 'ECB', 'PKCS');
 Spark SQL
> SELECT aes_decrypt(unbase64('2NYmDCjgXTbbxGA3/SnJEfFC/JQ7olk2VQWReIAAFKo='), '1234567890abcdef', 'CBC');
 Apache Spark
> SELECT aes_decrypt(unbase64('AAAAAAAAAAAAAAAAAAAAAPSd4mWyMZ5mhvjiAPQJnfg='), 'abcdefghijklmnop12345678ABCDEFGH', 'CBC', 'DEFAULT');
 Spark
> SELECT aes_decrypt(unbase64('AAAAAAAAAAAAAAAAQiYi+sTLm7KD9UcZ2nlRdYDe/PX4'), 'abcdefghijklmnop12345678ABCDEFGH', 'GCM', 'DEFAULT', 'This is an AAD mixed into the input');
 Spark

自: 3.3.0

aes_encrypt

aes_encrypt(expr, key[, mode[, padding[, iv[, aad]]]]) - 返回使用AES在给定的mode和指定的padding下加密的expr值。支持16、24和32位的密钥长度。支持的(mode, padding)组合有('ECB', 'PKCS')、('GCM', 'NONE')和('CBC', 'PKCS')。可选的初始化向量(IVs)仅支持CBC和GCM模式。这些必须是16字节用于CBC和12字节用于GCM。如果未提供，将生成一个随机向量并附加到输出中。可选的附加认证数据(AAD)仅支持GCM。如果加密时提供，解密时必须提供相同的AAD值。默认模式是GCM。

参数:

expr - 要加密的二进制值。
key - 用于加密数据的密码短语。
mode - 指定应使用哪种分组密码模式来加密消息。有效模式：ECB、GCM、CBC。
padding - 指定如何填充长度不是块大小倍数的消息。有效值：PKCS、NONE、DEFAULT。DEFAULT填充意味着ECB的PKCS，GCM的NONE和CBC的PKCS。
iv - 可选的初始化向量。仅支持CBC和GCM模式。有效值：None或''。CBC模式的16字节数组。GCM模式的12字节数组。
aad - 可选的附加认证数据。仅支持GCM模式。这可以是任何自由格式的输入，并且在加密和解密时都必须提供。

示例：

> SELECT hex(aes_encrypt('Spark', '0000111122223333'));
 83F16B2AA704794132802D248E6BFD4E380078182D1544813898AC97E709B28A94
> SELECT hex(aes_encrypt('Spark SQL', '0000111122223333', 'GCM'));
 6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210
> SELECT base64(aes_encrypt('Spark SQL', '1234567890abcdef', 'ECB', 'PKCS'));
 3lmwu+Mw0H3fi5NDvcu9lg==
> SELECT base64(aes_encrypt('Apache Spark', '1234567890abcdef', 'CBC', 'DEFAULT'));
 2NYmDCjgXTbbxGA3/SnJEfFC/JQ7olk2VQWReIAAFKo=
> SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop12345678ABCDEFGH', 'CBC', 'DEFAULT', unhex('00000000000000000000000000000000')));
 AAAAAAAAAAAAAAAAAAAAAPSd4mWyMZ5mhvjiAPQJnfg=
> SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop12345678ABCDEFGH', 'GCM', 'DEFAULT', unhex('000000000000000000000000'), 'This is an AAD mixed into the input'));
 AAAAAAAAAAAAAAAAQiYi+sTLm7KD9UcZ2nlRdYDe/PX4

自: 3.3.0

aggregate

aggregate(expr, start, merge, finish) - 将一个二元运算符应用于初始状态和数组中的所有元素，并将其归约为一个单一状态。通过应用一个完成函数，最终状态被转换为最终结果。

示例：

> SELECT aggregate(array(1, 2, 3), 0, (acc, x) -> acc + x);
 6
> SELECT aggregate(array(1, 2, 3), 0, (acc, x) -> acc + x, acc -> acc * 10);
 60

自: 2.4.0

and

expr1 和 expr2 - 逻辑与。

示例：

> SELECT true and true;
 true
> SELECT true and false;
 false
> SELECT true and NULL;
 NULL
> SELECT false and NULL;
 false

自: 1.0.0

any

any(expr) - 如果expr的至少一个值为真，则返回真。

示例：

> SELECT any(col) FROM VALUES (true), (false), (false) AS tab(col);
 true
> SELECT any(col) FROM VALUES (NULL), (true), (false) AS tab(col);
 true
> SELECT any(col) FROM VALUES (false), (false), (NULL) AS tab(col);
 false

自: 3.0.0

any_value

any_value(expr[, isIgnoreNull]) - 返回一组行中expr的某个值。如果isIgnoreNull为真，则仅返回非空值。

示例：

> SELECT any_value(col) FROM VALUES (10), (5), (20) AS tab(col);
 10
> SELECT any_value(col) FROM VALUES (NULL), (5), (20) AS tab(col);
 NULL
> SELECT any_value(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);
 5

注意：

该函数是非确定性的。

自: 3.4.0

approx_count_distinct

approx_count_distinct(expr[, relativeSD]) - 返回通过HyperLogLog++估计的基数。 relativeSD定义了允许的最大相对标准偏差。

示例：

> SELECT approx_count_distinct(col1) FROM VALUES (1), (1), (2), (2), (3) tab(col1);
 3

自: 1.6.0

approx_percentile

approx_percentile(col, percentage [, accuracy]) - 返回数值或ansi间隔列col的近似百分位数，这是有序col值（从最小到最大排序）中的最小值，使得不超过percentage的col值小于或等于该值。百分比值必须在0.0到1.0之间。 accuracy参数（默认值：10000）是一个控制近似精度的正数，以内存为代价。accuracy值越高，精度越好，1.0/accuracy是近似的相对误差。当percentage是一个数组时，百分比数组中的每个值必须在0.0到1.0之间。在这种情况下，返回列col在给定百分比数组处的近似百分位数数组。

示例：

> SELECT approx_percentile(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col);
 [1,1,0]
> SELECT approx_percentile(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col);
 7
> SELECT approx_percentile(col, 0.5, 100) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '1' MONTH), (INTERVAL '2' MONTH), (INTERVAL '10' MONTH) AS tab(col);
 0-1
> SELECT approx_percentile(col, array(0.5, 0.7), 100) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '1' SECOND), (INTERVAL '2' SECOND), (INTERVAL '10' SECOND) AS tab(col);
 [0 00:00:01.000000000,0 00:00:02.000000000]

自: 2.1.0

array

array(expr, ...) - 返回一个包含给定元素的数组。

示例：

> SELECT array(1, 2, 3);
 [1,2,3]

自: 1.1.0

array_agg

array_agg(expr) - 收集并返回一个非唯一元素的列表。

示例：

> SELECT array_agg(col) FROM VALUES (1), (2), (1) AS tab(col);
 [1,2,1]

注意：

该函数是不确定的，因为收集结果的顺序取决于行的顺序，而在洗牌后行的顺序可能是不确定的。

自: 3.3.0

array_append

array_append(array, element) - 在作为第一个参数传递的数组的末尾添加元素。元素的类型应与数组元素的类型相似。空元素也会被追加到数组中。但如果传递的数组为空，输出也为空

示例：

> SELECT array_append(array('b', 'd', 'c', 'a'), 'd');
 ["b","d","c","a","d"]
> SELECT array_append(array(1, 2, 3, null), null);
 [1,2,3,null,null]
> SELECT array_append(CAST(null as Array<Int>), 2);
 NULL

自: 3.4.0

array_compact

array_compact(array) - 从数组中移除空值。

示例：

> SELECT array_compact(array(1, 2, 3, null));
 [1,2,3]
> SELECT array_compact(array("a", "b", "c"));
 ["a","b","c"]

自: 3.4.0

array_contains

array_contains(array, value) - 如果数组包含该值，则返回true。

示例：

> SELECT array_contains(array(1, 2, 3), 2);
 true

自: 1.5.0

array_distinct

array_distinct(array) - 从数组中移除重复的值。

示例：

> SELECT array_distinct(array(1, 2, 3, null, 3));
 [1,2,3,null]

自: 2.4.0

array_except

array_except(array1, array2) - 返回一个数组，包含在array1中但不在array2中的元素，不包含重复项。

示例：

> SELECT array_except(array(1, 2, 3), array(1, 3, 5));
 [2]

自: 2.4.0

array_insert

array_insert(x, pos, val) - 将 val 插入到数组 x 的索引 pos 位置。数组索引从 1 开始。最大的负索引是 -1，此时函数会在当前最后一个元素之后插入新元素。索引超过数组大小时会追加数组，或者如果索引为负数，则会在数组前添加 'null' 元素。

示例：

> SELECT array_insert(array(1, 2, 3, 4), 5, 5);
 [1,2,3,4,5]
> SELECT array_insert(array(5, 4, 3, 2), -1, 1);
 [5,4,3,2,1]
> SELECT array_insert(array(5, 3, 2, 1), -4, 4);
 [5,4,3,2,1]

自: 3.4.0

array_intersect

array_intersect(array1, array2) - 返回一个数组，包含array1和array2的交集元素，不包含重复项。

示例：

> SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
 [1,3]

自: 2.4.0

array_join

array_join(array, delimiter[, nullReplacement]) - 将给定数组的元素使用分隔符连接，并可选地使用字符串替换空值。如果没有为nullReplacement设置值，任何空值都会被过滤掉。

示例：

> SELECT array_join(array('hello', 'world'), ' ');
 hello world
> SELECT array_join(array('hello', null ,'world'), ' ');
 hello world
> SELECT array_join(array('hello', null ,'world'), ' ', ',');
 hello , world

自: 2.4.0

array_max

array_max(array) - 返回数组中的最大值。对于double/float类型，NaN大于任何非NaN元素。NULL元素被跳过。

示例：

> SELECT array_max(array(1, 20, null, 3));
 20

自: 2.4.0

array_min

array_min(array) - 返回数组中的最小值。对于double/float类型，NaN大于任何非NaN元素。NULL元素会被跳过。

示例：

> SELECT array_min(array(1, 20, null, 3));
 1

自: 2.4.0

array_position

array_position(array, element) - 返回数组中第一个匹配元素的（基于1的）索引，如果未找到匹配项，则返回0。

示例：

> SELECT array_position(array(312, 773, 708, 708), 708);
 3
> SELECT array_position(array(312, 773, 708, 708), 414);
 0

自: 2.4.0

array_prepend

array_prepend(array, element) - 在作为第一个参数传递的数组的开始位置添加元素。元素的类型应与数组元素的类型相同。空元素也会被添加到数组中。但如果传递的数组为空，输出为空

示例：

> SELECT array_prepend(array('b', 'd', 'c', 'a'), 'd');
 ["d","b","d","c","a"]
> SELECT array_prepend(array(1, 2, 3, null), null);
 [null,1,2,3,null]
> SELECT array_prepend(CAST(null as Array<Int>), 2);
 NULL

自: 3.5.0

array_remove

array_remove(array, element) - 从数组中移除所有等于element的元素。

示例：

> SELECT array_remove(array(1, 2, 3, null, 3), 3);
 [1,2,null]

自: 2.4.0

array_repeat

array_repeat(element, count) - 返回包含元素 count 次的数组。

示例：

> SELECT array_repeat('123', 2);
 ["123","123"]

自: 2.4.0

array_size

array_size(expr) - 返回数组的大小。对于空输入，该函数返回空值。

示例：

> SELECT array_size(array('b', 'd', 'c', 'a'));
 4

自: 3.3.0

array_sort

array_sort(expr, func) - 对输入数组进行排序。如果省略了func，则按升序排序。输入数组的元素必须是可排序的。对于double/float类型，NaN大于任何非NaN元素。空元素将放置在返回数组的末尾。自3.0.0版本起，此函数还根据给定的比较器函数对数组进行排序并返回。比较器将接受两个参数，分别代表数组的两个元素。它返回一个负整数、0或正整数，表示第一个元素小于、等于或大于第二个元素。如果比较器函数返回null，函数将失败并引发错误。

示例：

> SELECT array_sort(array(5, 6, 1), (left, right) -> case when left < right then -1 when left > right then 1 else 0 end);
 [1,5,6]
> SELECT array_sort(array('bc', 'ab', 'dc'), (left, right) -> case when left is null and right is null then 0 when left is null then -1 when right is null then 1 when left < right then 1 when left > right then -1 else 0 end);
 ["dc","bc","ab"]
> SELECT array_sort(array('b', 'd', null, 'c', 'a'));
 ["a","b","c","d",null]

自: 2.4.0

array_union

array_union(array1, array2) - 返回array1和array2并集中的元素数组，不包含重复项。

示例：

> SELECT array_union(array(1, 2, 3), array(1, 3, 5));
 [1,2,3,5]

自: 2.4.0

arrays_overlap

arrays_overlap(a1, a2) - 如果 a1 包含至少一个也存在于 a2 中的非空元素，则返回 true。如果数组没有共同元素且它们都非空，并且其中任何一个包含 null 元素，则返回 null，否则返回 false。

示例：

> SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5));
 true

自: 2.4.0

arrays_zip

arrays_zip(a1, a2, ...) - 返回一个合并的结构数组，其中第N个结构包含所有输入数组的第N个值。

示例：

> SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4));
 [{"0":1,"1":2},{"0":2,"1":3},{"0":3,"1":4}]
> SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4));
 [{"0":1,"1":2,"2":3},{"0":2,"1":3,"2":4}]

自: 2.4.0

ascii

ascii(str) - 返回字符串 str 的第一个字符的数值。

示例：

> SELECT ascii('222');
 50
> SELECT ascii(2);
 50

自: 1.5.0

asin

asin(expr) - 返回反正弦（即反正弦）expr 的值，如同通过 java.lang.Math.asin 计算的那样。

示例：

> SELECT asin(0);
 0.0
> SELECT asin(2);
 NaN

自: 1.4.0

asinh

asinh(expr) - 返回 expr 的反双曲正弦值。

示例：

> SELECT asinh(0);
 0.0

自: 3.0.0

assert_true

assert_true(expr) - 如果 expr 不为真，则抛出异常。

示例：

> SELECT assert_true(0 < 1);
 NULL

自: 2.0.0

atan

atan(expr) - 返回 expr 的反正切（也称为反正切），如同由 java.lang.Math.atan 计算的那样

示例：

> SELECT atan(0);
 0.0

自: 1.4.0

atan2

atan2(exprY, exprX) - 返回平面中正x轴与坐标(exprX, exprY)给定的点之间的角度（以弧度为单位），如同由java.lang.Math.atan2计算的那样。

参数:

exprY - y轴上的坐标
exprX - x轴上的坐标

示例：

> SELECT atan2(0, 0);
 0.0

自: 1.4.0

atanh

atanh(expr) - 返回expr的反双曲正切值。

示例：

> SELECT atanh(0);
 0.0
> SELECT atanh(2);
 NaN

自: 3.0.0

avg

avg(expr) - 返回从一组值计算出的平均值。

示例：

> SELECT avg(col) FROM VALUES (1), (2), (3) AS tab(col);
 2.0
> SELECT avg(col) FROM VALUES (1), (2), (NULL) AS tab(col);
 1.5

自: 1.0.0

base64

base64(bin) - 将参数从二进制 bin 转换为 base 64 字符串。

示例：

> SELECT base64('Spark SQL');
 U3BhcmsgU1FM
> SELECT base64(x'537061726b2053514c');
 U3BhcmsgU1FM

自: 1.5.0

between

expr1 [NOT] BETWEEN expr2 AND expr3 - 评估 expr1 是否在 expr2 和 expr3 之间 [不]。

示例：

> SELECT col1 FROM VALUES 1, 3, 5, 7 WHERE col1 BETWEEN 2 AND 5;
 3
 5

自: 1.0.0

bigint

bigint(expr) - 将值 expr 转换为目标数据类型 bigint。

自: 2.0.1

bin

bin(expr) - 返回长值expr在二进制表示中的字符串表示形式。

示例：

> SELECT bin(13);
 1101
> SELECT bin(-13);
 1111111111111111111111111111111111111111111111111111111111110011
> SELECT bin(13.3);
 1101

自: 1.5.0

binary

binary(expr) - 将值 expr 转换为目标数据类型 binary。

自: 2.0.1

bit_and

bit_and(expr) - 返回所有非空输入值的按位与结果，如果没有输入值则返回null。

示例：

> SELECT bit_and(col) FROM VALUES (3), (5) AS tab(col);
 1

自: 3.0.0

bit_count

bit_count(expr) - 返回参数 expr 中设置的位数，作为一个无符号的 64 位整数，如果参数为 NULL，则返回 NULL。

示例：

> SELECT bit_count(0);
 0

自: 3.0.0

bit_get

bit_get(expr, pos) - 返回指定位置的位值（0 或 1）。位置从右到左编号，从零开始。位置参数不能为负数。

示例：

> SELECT bit_get(11, 0);
 1
> SELECT bit_get(11, 2);
 0

自: 3.2.0

bit_length

bit_length(expr) - 返回字符串数据的位长度或二进制数据的位数。

示例：

> SELECT bit_length('Spark SQL');
 72
> SELECT bit_length(x'537061726b2053514c');
 72

自: 2.3.0

bit_or

bit_or(expr) - 返回所有非空输入值的按位或结果，如果没有输入值则返回null。

示例：

> SELECT bit_or(col) FROM VALUES (3), (5) AS tab(col);
 7

自: 3.0.0

bit_xor

bit_xor(expr) - 返回所有非空输入值的按位异或，如果没有输入值则返回null。

示例：

> SELECT bit_xor(col) FROM VALUES (3), (5) AS tab(col);
 6

自: 3.0.0

bitmap_bit_position

bitmap_bit_position(child) - 返回给定输入子表达式的位位置。

示例：

> SELECT bitmap_bit_position(1);
 0
> SELECT bitmap_bit_position(123);
 122

自: 3.5.0

bitmap_bucket_number

bitmap_bucket_number(child) - 返回给定输入子表达式的桶号。

示例：

> SELECT bitmap_bucket_number(123);
 1
> SELECT bitmap_bucket_number(0);
 0

自: 3.5.0

bitmap_construct_agg

bitmap_construct_agg(child) - 返回一个位图，其中包含从子表达式中的所有值设置的位的位置。子表达式很可能是 bitmap_bit_position()。

示例：

> SELECT substring(hex(bitmap_construct_agg(bitmap_bit_position(col))), 0, 6) FROM VALUES (1), (2), (3) AS tab(col);
 070000
> SELECT substring(hex(bitmap_construct_agg(bitmap_bit_position(col))), 0, 6) FROM VALUES (1), (1), (1) AS tab(col);
 010000

自: 3.5.0

bitmap_count

bitmap_count(child) - 返回子位图中设置位的数量。

示例：

> SELECT bitmap_count(X '1010');
 2
> SELECT bitmap_count(X 'FFFF');
 16
> SELECT bitmap_count(X '0');
 0

自: 3.5.0

bitmap_or_agg

bitmap_or_agg(child) - 返回一个位图，该位图是来自子表达式的所有位图的按位或结果。输入应为由bitmap_construct_agg()创建的位图。

示例：

> SELECT substring(hex(bitmap_or_agg(col)), 0, 6) FROM VALUES (X '10'), (X '20'), (X '40') AS tab(col);
 700000
> SELECT substring(hex(bitmap_or_agg(col)), 0, 6) FROM VALUES (X '10'), (X '10'), (X '10') AS tab(col);
 100000

自: 3.5.0

bool_and

bool_and(expr) - 如果expr的所有值都为真，则返回真。

示例：

> SELECT bool_and(col) FROM VALUES (true), (true), (true) AS tab(col);
 true
> SELECT bool_and(col) FROM VALUES (NULL), (true), (true) AS tab(col);
 true
> SELECT bool_and(col) FROM VALUES (true), (false), (true) AS tab(col);
 false

自: 3.0.0

bool_or

bool_or(expr) - 如果expr的至少一个值为真，则返回真。

示例：

> SELECT bool_or(col) FROM VALUES (true), (false), (false) AS tab(col);
 true
> SELECT bool_or(col) FROM VALUES (NULL), (true), (false) AS tab(col);
 true
> SELECT bool_or(col) FROM VALUES (false), (false), (NULL) AS tab(col);
 false

自: 3.0.0

boolean

boolean(expr) - 将值 expr 转换为目标数据类型 boolean。

自: 2.0.1

bround

bround(expr, d) - 返回使用HALF_EVEN舍入模式将expr舍入到d个小数位。

示例：

> SELECT bround(2.5, 0);
 2
> SELECT bround(25, -1);
 20

自: 2.0.0

btrim

btrim(str) - 移除str的前导和尾随空格字符。

btrim(str, trimStr) - 移除str字符串中前后的trimStr字符。

参数:

str - 一个字符串表达式
trimStr - 要修剪的修剪字符串字符，默认值是一个空格

示例：

> SELECT btrim('    SparkSQL   ');
 SparkSQL
> SELECT btrim(encode('    SparkSQL   ', 'utf-8'));
 SparkSQL
> SELECT btrim('SSparkSQLS', 'SL');
 parkSQ
> SELECT btrim(encode('SSparkSQLS', 'utf-8'), encode('SL', 'utf-8'));
 parkSQ

自: 3.2.0

cardinality

cardinality(expr) - 返回数组或映射的大小。如果 spark.sql.legacy.sizeOfNull 设置为 false 或 spark.sql.ansi.enabled 设置为 true，则对于空输入，函数返回 null。否则，对于空输入，函数返回 -1。在默认设置下，函数对于空输入返回 -1。

示例：

> SELECT cardinality(array('b', 'd', 'c', 'a'));
 4
> SELECT cardinality(map('a', 1, 'b', 2));
 2

自: 1.5.0

case

CASE expr1 WHEN expr2 THEN expr3 [WHEN expr4 THEN expr5]* [ELSE expr6] END - 当 expr1 = expr2 时，返回 expr3；当 expr1 = expr4 时，返回 expr5；否则返回 expr6。

参数:

expr1 - 比较的一个操作数表达式。
expr2, expr4 - 每个表达式都是比较的另一个操作数。
expr3, expr5, expr6 - 分支值表达式和else值表达式都应该是相同类型或可强制转换为通用类型。

示例：

> SELECT CASE col1 WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE '?' END FROM VALUES 1, 2, 3;
 one
 two
 ?
> SELECT CASE col1 WHEN 1 THEN 'one' WHEN 2 THEN 'two' END FROM VALUES 1, 2, 3;
 one
 two
 NULL

自: 1.0.1

cast

cast(expr AS type) - 将值 expr 转换为目标数据类型 type。

示例：

> SELECT cast('10' as int);
 10

自: 1.0.0

cbrt

cbrt(expr) - 返回 expr 的立方根。

示例：

> SELECT cbrt(27.0);
 3.0

自: 1.4.0

ceil

ceil(expr[, scale]) - 返回向上取整后的最小数，该数不小于expr。可以选择指定一个scale参数来控制取整行为。

示例：

> SELECT ceil(-0.1);
 0
> SELECT ceil(5);
 5
> SELECT ceil(3.1411, 3);
 3.142
> SELECT ceil(3.1411, -3);
 1000

自: 3.3.0

ceiling

ceiling(expr[, scale]) - 返回向上取整后的最小数，该数不小于expr。可以选择指定一个scale参数来控制取整行为。

示例：

> SELECT ceiling(-0.1);
 0
> SELECT ceiling(5);
 5
> SELECT ceiling(3.1411, 3);
 3.142
> SELECT ceiling(3.1411, -3);
 1000

自: 3.3.0

char

char(expr) - 返回具有与expr二进制等效的ASCII字符。如果n大于256，则结果等效于chr(n % 256)

示例：

> SELECT char(65);
 A

自: 2.3.0

char_length

char_length(expr) - 返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括尾随空格。二进制数据的长度包括二进制零。

示例：

> SELECT char_length('Spark SQL ');
 10
> SELECT char_length(x'537061726b2053514c');
 9
> SELECT CHAR_LENGTH('Spark SQL ');
 10
> SELECT CHARACTER_LENGTH('Spark SQL ');
 10

自: 1.5.0

character_length

character_length(expr) - 返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括尾随空格。二进制数据的长度包括二进制零。

示例：

> SELECT character_length('Spark SQL ');
 10
> SELECT character_length(x'537061726b2053514c');
 9
> SELECT CHAR_LENGTH('Spark SQL ');
 10
> SELECT CHARACTER_LENGTH('Spark SQL ');
 10

自: 1.5.0

chr

chr(expr) - 返回具有与expr的二进制等效的ASCII字符。如果n大于256，则结果等同于chr(n % 256)

示例：

> SELECT chr(65);
 A

自: 2.3.0

coalesce

coalesce(expr1, expr2, ...) - 如果存在，返回第一个非空参数。否则，返回null。

示例：

> SELECT coalesce(NULL, 1, NULL);
 1

自: 1.0.0

collect_list

collect_list(expr) - 收集并返回一个非唯一元素的列表。

示例：

> SELECT collect_list(col) FROM VALUES (1), (2), (1) AS tab(col);
 [1,2,1]

注意：

该函数是不确定的，因为收集结果的顺序取决于行的顺序，而在洗牌后行的顺序可能是不确定的。

自: 2.0.0

collect_set

collect_set(expr) - 收集并返回一组唯一元素。

示例：

> SELECT collect_set(col) FROM VALUES (1), (2), (1) AS tab(col);
 [1,2]

注意：

该函数是不确定的，因为收集结果的顺序取决于行的顺序，而在洗牌后行的顺序可能是不确定的。

自: 2.0.0

concat

concat(col1, col2, ..., colN) - 返回 col1, col2, ..., colN 的连接结果。

示例：

> SELECT concat('Spark', 'SQL');
 SparkSQL
> SELECT concat(array(1, 2, 3), array(4, 5), array(6));
 [1,2,3,4,5,6]

注意：

自2.4.0版本起，数组的连接逻辑已可用。

自: 1.5.0

concat_ws

concat_ws(sep[, str | array(str)]+) - 返回由sep分隔的字符串的连接，跳过空值。

示例：

> SELECT concat_ws(' ', 'Spark', 'SQL');
  Spark SQL
> SELECT concat_ws('s');

> SELECT concat_ws('/', 'foo', null, 'bar');
  foo/bar
> SELECT concat_ws(null, 'Spark', 'SQL');
  NULL

自: 1.5.0

contains

contains(left, right) - 返回一个布尔值。如果 right 在 left 中找到，则值为 True。如果任一输入表达式为 NULL，则返回 NULL。否则，返回 False。 left 或 right 必须为 STRING 或 BINARY 类型。

示例：

> SELECT contains('Spark SQL', 'Spark');
 true
> SELECT contains('Spark SQL', 'SPARK');
 false
> SELECT contains('Spark SQL', null);
 NULL
> SELECT contains(x'537061726b2053514c', x'537061726b');
 true

自: 3.3.0

conv

conv(num, from_base, to_base) - 将num从from_base转换为to_base。

示例：

> SELECT conv('100', 2, 10);
 4
> SELECT conv(-10, 16, -10);
 -16

自: 1.5.0

convert_timezone

convert_timezone([sourceTz, ]targetTz, sourceTs) - 将没有时区的时间戳 sourceTs 从 sourceTz 时区转换为 targetTz 时区。

参数:

sourceTz - 输入时间戳的时区。如果未指定，则使用当前会话时区作为源时区。
targetTz - 输入时间戳应转换到的时区
sourceTs - 不带时区的时间戳

示例：

> SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00');
 2021-12-05 15:00:00
> SELECT convert_timezone('Europe/Brussels', timestamp_ntz'2021-12-05 15:00:00');
 2021-12-06 00:00:00

自: 3.4.0

corr

corr(expr1, expr2) - 返回一组数字对的皮尔逊相关系数。

示例：

> SELECT corr(c1, c2) FROM VALUES (3, 2), (3, 3), (6, 4) as tab(c1, c2);
 0.8660254037844387

自: 1.6.0

cos

cos(expr) - 返回 expr 的余弦值，如同由 java.lang.Math.cos 计算的那样。

参数:

expr - 弧度角

示例：

> SELECT cos(0);
 1.0

自: 1.4.0

cosh

cosh(expr) - 返回 expr 的双曲余弦值，如同通过 java.lang.Math.cosh 计算的那样。

参数:

expr - 双曲角

示例：

> SELECT cosh(0);
 1.0

自: 1.4.0

cot

cot(expr) - 返回 expr 的余切值，如同通过 1/java.lang.Math.tan 计算得到。

参数:

expr - 角度（弧度）

示例：

> SELECT cot(1);
 0.6420926159343306

自: 2.3.0

count

count(*) - 返回检索到的总行数，包括包含null的行。

count(expr[, expr...]) - 返回所有提供的表达式均为非空的行数。

count(DISTINCT expr[, expr...]) - 返回所提供的表达式唯一且非空的行数。

示例：

> SELECT count(*) FROM VALUES (NULL), (5), (5), (20) AS tab(col);
 4
> SELECT count(col) FROM VALUES (NULL), (5), (5), (20) AS tab(col);
 3
> SELECT count(DISTINCT col) FROM VALUES (NULL), (5), (5), (10) AS tab(col);
 2

自: 1.0.0

count_if

count_if(expr) - 返回表达式中TRUE值的数量。

示例：

> SELECT count_if(col % 2 = 0) FROM VALUES (NULL), (0), (1), (2), (3) AS tab(col);
 2
> SELECT count_if(col IS NULL) FROM VALUES (NULL), (0), (1), (2), (3) AS tab(col);
 1

自: 3.0.0

count_min_sketch

count_min_sketch(col, eps, confidence, seed) - 返回具有给定eps、confidence和seed的列的计数最小草图。结果是一个字节数组，可以在使用前反序列化为CountMinSketch。计数最小草图是一种用于使用次线性空间进行基数估计的概率数据结构。

示例：

> SELECT hex(count_min_sketch(col, 0.5d, 0.5d, 1)) FROM VALUES (1), (2), (1) AS tab(col);
 0000000100000000000000030000000100000004000000005D8D6AB90000000000000000000000000000000200000000000000010000000000000000

自: 2.2.0

covar_pop

covar_pop(expr1, expr2) - 返回一组数值对的总体协方差。

示例：

> SELECT covar_pop(c1, c2) FROM VALUES (1,1), (2,2), (3,3) AS tab(c1, c2);
 0.6666666666666666

自: 2.0.0

covar_samp

covar_samp(expr1, expr2) - 返回一组数值对的样本协方差。

示例：

> SELECT covar_samp(c1, c2) FROM VALUES (1,1), (2,2), (3,3) AS tab(c1, c2);
 1.0

自: 2.0.0

crc32

crc32(expr) - 返回expr的循环冗余校验值，类型为bigint。

示例：

> SELECT crc32('Spark');
 1557323817

自: 1.5.0

csc

csc(expr) - 返回 expr 的余割，如同通过 1/java.lang.Math.sin 计算的那样。

参数:

expr - 角度（弧度制）

示例：

> SELECT csc(1);
 1.1883951057781212

自: 3.3.0

cume_dist

cume_dist() - 计算一个值相对于分区中所有值的位置。

示例：

> SELECT a, b, cume_dist() OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
 A1 1   0.6666666666666666
 A1 1   0.6666666666666666
 A1 2   1.0
 A2 3   1.0

自: 2.0.0

curdate

curdate() - 返回查询评估开始时的当前日期。同一查询中所有对curdate的调用都返回相同的值。

示例：

> SELECT curdate();
 2022-09-06

自: 3.4.0

current_catalog

current_catalog() - 返回当前目录。

示例：

> SELECT current_catalog();
 spark_catalog

自: 3.1.0

current_database

current_database() - 返回当前数据库。

示例：

> SELECT current_database();
 default

自: 1.6.0

current_date

current_date() - 返回查询评估开始时的当前日期。在同一查询中，所有对 current_date 的调用都返回相同的值。

current_date - 返回查询评估开始时的当前日期。

示例：

> SELECT current_date();
 2020-04-25
> SELECT current_date;
 2020-04-25

注意：

自2.0.1版本起，已支持不带大括号的语法。

自: 1.5.0

current_schema

current_schema() - 返回当前数据库。

示例：

> SELECT current_schema();
 default

自: 1.6.0

current_timestamp

current_timestamp() - 返回查询评估开始时的当前时间戳。在同一查询中，所有对 current_timestamp 的调用都返回相同的值。

current_timestamp - 返回查询评估开始时的当前时间戳。

示例：

> SELECT current_timestamp();
 2020-04-25 15:49:11.914
> SELECT current_timestamp;
 2020-04-25 15:49:11.914

注意：

自2.0.1版本起，已支持不带大括号的语法。

自: 1.5.0

current_timezone

current_timezone() - 返回当前会话本地时区。

示例：

> SELECT current_timezone();
 Asia/Shanghai

自: 3.1.0

current_user

current_user() - 当前执行上下文的用户名。

示例：

> SELECT current_user();
 mockingjay

自: 3.2.0

date

date(expr) - 将值 expr 转换为目标数据类型 date。

自: 2.0.1

date_add

date_add(start_date, num_days) - 返回从start_date开始后的num_days的日期。

示例：

> SELECT date_add('2016-07-30', 1);
 2016-07-31

自: 1.5.0

date_diff

date_diff(endDate, startDate) - 返回从startDate到endDate的天数。

示例：

> SELECT date_diff('2009-07-31', '2009-07-30');
 1

> SELECT date_diff('2009-07-30', '2009-07-31');
 -1

自: 3.4.0

date_format

date_format(timestamp, fmt) - 将 timestamp 转换为指定日期格式 fmt 的字符串值。

参数:

timestamp - 要转换为给定格式的日期/时间戳或字符串。
fmt - 要遵循的日期/时间格式模式。有关有效的日期和时间格式模式，请参见日期时间模式。

示例：

> SELECT date_format('2016-04-08', 'y');
 2016

自: 1.5.0

date_from_unix_date

date_from_unix_date(days) - 从1970-01-01以来的天数创建日期。

示例：

> SELECT date_from_unix_date(1);
 1970-01-02

自: 3.1.0

date_part

date_part(field, source) - 提取日期/时间戳或时间间隔源的一部分。

参数:

field - 选择应提取源的哪一部分，支持的字符串值与等效函数 EXTRACT 的字段相同。
source - 一个日期/时间戳或间隔列，从中提取 field

示例：

> SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');
 2019
> SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456');
 33
> SELECT date_part('doy', DATE'2019-08-12');
 224
> SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001');
 1.000001
> SELECT date_part('days', interval 5 days 3 hours 7 minutes);
 5
> SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
 30.001001
> SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH);
 11
> SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);
 55

注意：

date_part 函数等同于 SQL 标准函数 EXTRACT(field FROM source)

自: 3.0.0

date_sub

date_sub(start_date, num_days) - 返回在 start_date 之前的 num_days 的日期。

示例：

> SELECT date_sub('2016-07-30', 1);
 2016-07-29

自: 1.5.0

date_trunc

date_trunc(fmt, ts) - 返回时间戳 ts 截断为格式模型 fmt 指定的单位。

参数:

fmt - 表示要截断到的单位的格式
- "YEAR", "YYYY", "YY" - 截断到ts所在年份的第一天，时间部分将被清零
- "QUARTER" - 截断到ts所在季度的第一天，时间部分将被清零
- "MONTH", "MM", "MON" - 截断到ts所在月份的第一天，时间部分将被清零
- "WEEK" - 截断到ts所在周的星期一，时间部分将被清零
- "DAY", "DD" - 清零时间部分
- "HOUR" - 清零分钟和秒及小数部分
- "MINUTE" - 清零秒及小数部分
- "SECOND" - 清零秒的小数部分
- "MILLISECOND" - 清零微秒
- "MICROSECOND" - 保持不变
ts - 日期时间值或有效的日期时间字符串

示例：

> SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359');
 2015-01-01 00:00:00
> SELECT date_trunc('MM', '2015-03-05T09:32:05.359');
 2015-03-01 00:00:00
> SELECT date_trunc('DD', '2015-03-05T09:32:05.359');
 2015-03-05 00:00:00
> SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359');
 2015-03-05 09:00:00
> SELECT date_trunc('MILLISECOND', '2015-03-05T09:32:05.123456');
 2015-03-05 09:32:05.123

自: 2.3.0

dateadd

dateadd(start_date, num_days) - 返回从start_date开始后的num_days的日期。

示例：

> SELECT dateadd('2016-07-30', 1);
 2016-07-31

自: 3.4.0

datediff

datediff(endDate, startDate) - 返回从startDate到endDate的天数。

示例：

> SELECT datediff('2009-07-31', '2009-07-30');
 1

> SELECT datediff('2009-07-30', '2009-07-31');
 -1

自: 1.5.0

datepart

datepart(field, source) - 提取日期/时间戳或时间间隔源的一部分。

参数:

field - 选择应提取源的哪一部分，支持的字符串值与等效函数 EXTRACT 的字段相同。
source - 一个日期/时间戳或间隔列，从中提取 field

示例：

> SELECT datepart('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');
 2019
> SELECT datepart('week', timestamp'2019-08-12 01:00:00.123456');
 33
> SELECT datepart('doy', DATE'2019-08-12');
 224
> SELECT datepart('SECONDS', timestamp'2019-10-01 00:00:01.000001');
 1.000001
> SELECT datepart('days', interval 5 days 3 hours 7 minutes);
 5
> SELECT datepart('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
 30.001001
> SELECT datepart('MONTH', INTERVAL '2021-11' YEAR TO MONTH);
 11
> SELECT datepart('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);
 55

注意：

datepart 函数等同于 SQL 标准函数 EXTRACT(field FROM source)

自: 3.4.0

day

day(date) - 返回日期/时间戳的月份中的天数。

示例：

> SELECT day('2009-07-30');
 30

自: 1.5.0

dayofmonth

dayofmonth(date) - 返回日期/时间戳的月份中的天数。

示例：

> SELECT dayofmonth('2009-07-30');
 30

自: 1.5.0

dayofweek

dayofweek(date) - 返回日期/时间戳的星期几（1 = 星期日, 2 = 星期一, ..., 7 = 星期六）。

示例：

> SELECT dayofweek('2009-07-30');
 5

自: 2.3.0

dayofyear

dayofyear(date) - 返回日期/时间戳的年中的天数。

示例：

> SELECT dayofyear('2016-04-09');
 100

自: 1.5.0

decimal

decimal(expr) - 将值 expr 转换为目标数据类型 decimal。

自: 2.0.1

decode

decode(bin, charset) - 使用第二个参数的字符集解码第一个参数。

decode(expr, search, result [, search, result ] ... [, default]) - 将 expr 与每个 search 值按顺序进行比较。如果 expr 等于某个 search 值，decode 返回相应的结果。如果没有找到匹配项，则返回 default。如果省略 default，则返回 null。

示例：

> SELECT decode(encode('abc', 'utf-8'), 'utf-8');
 abc
> SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
 San Francisco
> SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
 Non domestic
> SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle');
 NULL
> SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, 'rocks');
 SQL

自: 3.2.0

degrees

degrees(expr) - 将弧度转换为度数。

参数:

expr - 角度（弧度制）

示例：

> SELECT degrees(3.141592653589793);
 180.0

自: 1.4.0

dense_rank

dense_rank() - 计算一组值中某个值的排名。结果是前一个分配的排名值加一。与函数 rank 不同，dense_rank 不会在排名序列中产生间隙。

参数:

children - 这是用于排名的基础；其中一个子值的变化将触发排名的变化。这是一个内部参数，将由分析器分配。

示例：

> SELECT a, b, dense_rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
 A1 1   1
 A1 1   1
 A1 2   2
 A2 3   1

自: 2.0.0

div

expr1 div expr2 - 将 expr1 除以 expr2。如果操作数为 NULL 或 expr2 为 0，则返回 NULL。结果被转换为 long 类型。

示例：

> SELECT 3 div 2;
 1
> SELECT INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH;
 -13

自: 3.0.0

double

double(expr) - 将值 expr 转换为目标数据类型 double。

自: 2.0.1

e

e() - 返回欧拉数，e。

示例：

> SELECT e();
 2.718281828459045

自: 1.5.0

element_at

element_at(array, index) - 返回数组在给定（基于1的）索引处的元素。如果索引为0， Spark将抛出错误。如果索引小于0，则从最后一个元素访问到第一个元素。如果索引超过数组的长度且spark.sql.ansi.enabled设置为false，函数返回NULL。如果spark.sql.ansi.enabled设置为true，对于无效索引将抛出ArrayIndexOutOfBoundsException。

element_at(map, key) - 返回给定键的值。如果键不包含在映射中，函数返回NULL。

示例：

> SELECT element_at(array(1, 2, 3), 2);
 2
> SELECT element_at(map(1, 'a', 2, 'b'), 2);
 b

自: 2.4.0

elt

elt(n, input1, input2, ...) - 返回第n个输入，例如，当n为2时返回input2。如果索引超出数组长度且spark.sql.ansi.enabled设置为false，函数返回NULL。如果spark.sql.ansi.enabled设置为true，对于无效索引会抛出ArrayIndexOutOfBoundsException。

示例：

> SELECT elt(1, 'scala', 'java');
 scala
> SELECT elt(2, 'a', 1);
 1

自: 2.0.0

encode

encode(str, charset) - 使用第二个参数的字符集对第一个参数进行编码。

示例：

> SELECT encode('abc', 'utf-8');
 abc

自: 1.5.0

endswith

endswith(left, right) - 返回一个布尔值。如果左边的值以右边的值结尾，则返回True。如果任一输入表达式为NULL，则返回NULL。否则，返回False。左或右必须为STRING或BINARY类型。

示例：

> SELECT endswith('Spark SQL', 'SQL');
 true
> SELECT endswith('Spark SQL', 'Spark');
 false
> SELECT endswith('Spark SQL', null);
 NULL
> SELECT endswith(x'537061726b2053514c', x'537061726b');
 false
> SELECT endswith(x'537061726b2053514c', x'53514c');
 true

自: 3.3.0

equal_null

equal_null(expr1, expr2) - 对于非空操作数，返回与EQUAL(=)运算符相同的结果，但如果两者都为空，则返回true，如果其中一个为空，则返回false。

参数:

expr1, expr2 - 这两个表达式必须是相同类型或可以转换为通用类型，并且必须是可用于相等比较的类型。不支持Map类型。对于复杂类型如数组/结构体，字段的数据类型必须是可排序的。

示例：

> SELECT equal_null(3, 3);
 true
> SELECT equal_null(1, '11');
 false
> SELECT equal_null(true, NULL);
 false
> SELECT equal_null(NULL, 'abc');
 false
> SELECT equal_null(NULL, NULL);
 true

自: 3.4.0

every

every(expr) - 如果expr的所有值都为真，则返回真。

示例：

> SELECT every(col) FROM VALUES (true), (true), (true) AS tab(col);
 true
> SELECT every(col) FROM VALUES (NULL), (true), (true) AS tab(col);
 true
> SELECT every(col) FROM VALUES (true), (false), (true) AS tab(col);
 false

自: 3.0.0

exists

exists(expr, pred) - 测试谓词是否对数组中的一个或多个元素成立。

示例：

> SELECT exists(array(1, 2, 3), x -> x % 2 == 0);
 true
> SELECT exists(array(1, 2, 3), x -> x % 2 == 10);
 false
> SELECT exists(array(1, null, 3), x -> x % 2 == 0);
 NULL
> SELECT exists(array(0, null, 2, 3, null), x -> x IS NULL);
 true
> SELECT exists(array(1, 2, 3), x -> x IS NULL);
 false

自: 2.4.0

exp

exp(expr) - 返回 e 的 expr 次方。

示例：

> SELECT exp(0);
 1.0

自: 1.4.0

explode

explode(expr) - 将数组 expr 的元素分隔为多行，或将映射 expr 的元素分隔为多行和多列。除非另有指定，否则使用默认列名 col 表示数组的元素，或使用 key 和 value 表示映射的元素。

示例：

> SELECT explode(array(10, 20));
 10
 20
> SELECT explode(collection => array(10, 20));
 10
 20
> SELECT * FROM explode(collection => array(10, 20));
 10
 20

自: 1.0.0

explode_outer

explode_outer(expr) - 将数组 expr 的元素拆分为多行，或将映射 expr 的元素拆分为多行和多列。除非另有指定，否则使用默认列名 col 表示数组的元素，或使用 key 和 value 表示映射的元素。

示例：

> SELECT explode_outer(array(10, 20));
 10
 20
> SELECT explode_outer(collection => array(10, 20));
 10
 20
> SELECT * FROM explode_outer(collection => array(10, 20));
 10
 20

自: 1.0.0

expm1

expm1(expr) - 返回 exp(expr) - 1。

示例：

> SELECT expm1(0);
 0.0

自: 1.4.0

extract

extract(field FROM source) - 从日期/时间戳或时间间隔源中提取一部分。

参数:

字段 - 选择应提取源的哪一部分
- 日期和时间戳支持的 field 字符串值（不区分大小写）：
  - "YEAR", ("Y", "YEARS", "YR", "YRS") - 年字段
  - "YEAROFWEEK" - 日期时间所在的 ISO 8601 周编号年份。例如，2005-01-02 是 2004 年的第 53 周，因此结果是 2004
  - "QUARTER", ("QTR") - 日期时间所在的季度（1 - 4）
  - "MONTH", ("MON", "MONS", "MONTHS") - 月份字段（1 - 12）
  - "WEEK", ("W", "WEEKS") - ISO 8601 周编号年份的周数。一周被认为从星期一开始，第 1 周是包含超过 3 天的第一周。在 ISO 周编号系统中，一月初的日期可能是前一年的第 52 或 53 周，而十二月底的日期可能是下一年的第一周。例如，2005-01-02 是 2004 年的第 53 周，而 2012-12-31 是 2013 年的第一周
  - "DAY", ("D", "DAYS") - 月份中的天字段（1 - 31）
  - "DAYOFWEEK",("DOW") - 日期时间对应的星期几，从星期日（1）到星期六（7）
  - "DAYOFWEEK_ISO",("DOW_ISO") - 基于 ISO 8601 的日期时间对应的星期几，从星期一（1）到星期日（7）
  - "DOY" - 一年中的天数（1 - 365/366）
  - "HOUR", ("H", "HOURS", "HR", "HRS") - 小时字段（0 - 23）
  - "MINUTE", ("M", "MIN", "MINS", "MINUTES") - 分钟字段（0 - 59）
  - "SECOND", ("S", "SEC", "SECONDS", "SECS") - 秒字段，包括小数部分
- 间隔（由 months、days、microseconds 组成）支持的 field 字符串值（不区分大小写）：
  - "YEAR", ("Y", "YEARS", "YR", "YRS") - 总 months / 12
  - "MONTH", ("MON", "MONS", "MONTHS") - 总 months % 12
  - "DAY", ("D", "DAYS") - 间隔的 days 部分
  - "HOUR", ("H", "HOURS", "HR", "HRS") - microseconds 包含的小时数
  - "MINUTE", ("M", "MIN", "MINS", "MINUTES") - 从 microseconds 中扣除小时后剩余的分钟数
  - "SECOND", ("S", "SEC", "SECONDS", "SECS") - 从 microseconds 中扣除小时和分钟后剩余的秒数，包括小数部分
源 - 从中提取 field 的日期/时间戳或间隔列

示例：

> SELECT extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456');
 2019
> SELECT extract(week FROM timestamp'2019-08-12 01:00:00.123456');
 33
> SELECT extract(doy FROM DATE'2019-08-12');
 224
> SELECT extract(SECONDS FROM timestamp'2019-10-01 00:00:01.000001');
 1.000001
> SELECT extract(days FROM interval 5 days 3 hours 7 minutes);
 5
> SELECT extract(seconds FROM interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
 30.001001
> SELECT extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH);
 11
> SELECT extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND);
 55

注意：

extract 函数等同于 date_part(field, source)。

自: 3.0.0

factorial

factorial(expr) - 返回 expr 的阶乘。expr 的取值范围是 [0..20]。否则，返回 null。

示例：

> SELECT factorial(5);
 120

自: 1.5.0

filter

filter(expr, func) - 使用给定的谓词过滤输入数组。

示例：

> SELECT filter(array(1, 2, 3), x -> x % 2 == 1);
 [1,3]
> SELECT filter(array(0, 2, 3), (x, i) -> x > i);
 [2,3]
> SELECT filter(array(0, null, 2, 3, null), x -> x IS NOT NULL);
 [0,2,3]

注意：

自3.0.0版本起，内部函数可以使用index参数。

自: 2.4.0

find_in_set

find_in_set(str, str_array) - 返回给定字符串（str）在逗号分隔列表（str_array）中的索引（从1开始）。如果未找到字符串或给定字符串（str）包含逗号，则返回0。

示例：

> SELECT find_in_set('ab','abc,b,ab,c,def');
 3

自: 1.5.0

first

first(expr[, isIgnoreNull]) - 返回一组行中expr的第一个值。如果isIgnoreNull为true，则仅返回非空值。

示例：

> SELECT first(col) FROM VALUES (10), (5), (20) AS tab(col);
 10
> SELECT first(col) FROM VALUES (NULL), (5), (20) AS tab(col);
 NULL
> SELECT first(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);
 5

注意：

该函数是非确定性的，因为其结果取决于行的顺序，而在洗牌后顺序可能是不确定的。

自: 2.0.0

first_value

first_value(expr[, isIgnoreNull]) - 返回一组行中expr的第一个值。如果isIgnoreNull为true，则仅返回非空值。

示例：

> SELECT first_value(col) FROM VALUES (10), (5), (20) AS tab(col);
 10
> SELECT first_value(col) FROM VALUES (NULL), (5), (20) AS tab(col);
 NULL
> SELECT first_value(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);
 5

注意：

该函数是不确定的，因为其结果取决于行的顺序，而在混洗后顺序可能是不确定的。

自: 2.0.0

flatten

flatten(arrayOfArrays) - 将数组数组转换为单个数组。

示例：

> SELECT flatten(array(array(1, 2), array(3, 4)));
 [1,2,3,4]

自: 2.4.0

float

float(expr) - 将值 expr 转换为目标数据类型 float。

自: 2.0.1

floor

floor(expr[, scale]) - 返回不大于expr的最大整数。可以选择指定scale参数来控制舍入行为。

示例：

> SELECT floor(-0.1);
 -1
> SELECT floor(5);
 5
> SELECT floor(3.1411, 3);
 3.141
> SELECT floor(3.1411, -3);
 0

自: 3.3.0

forall

forall(expr, pred) - 测试谓词是否对数组中的所有元素成立。

示例：

> SELECT forall(array(1, 2, 3), x -> x % 2 == 0);
 false
> SELECT forall(array(2, 4, 8), x -> x % 2 == 0);
 true
> SELECT forall(array(1, null, 3), x -> x % 2 == 0);
 false
> SELECT forall(array(2, null, 8), x -> x % 2 == 0);
 NULL

自: 3.0.0

format_number

format_number(expr1, expr2) - 将数字 expr1 格式化为 '#,###,###.##' 的形式，并四舍五入到 expr2 个小数位。如果 expr2 为 0，结果将没有小数点或小数部分。expr2 也接受用户指定的格式。这应该像 MySQL 的 FORMAT 函数一样工作。

示例：

> SELECT format_number(12332.123456, 4);
 12,332.1235
> SELECT format_number(12332.123456, '##################.###');
 12332.123

自: 1.5.0

format_string

format_string(strfmt, obj, ...) - 返回从printf样式格式字符串格式化的字符串。

示例：

> SELECT format_string("Hello World %d %s", 100, "days");
 Hello World 100 days

自: 1.5.0

from_csv

from_csv(csvStr, schema[, options]) - 返回一个具有给定 csvStr 和 schema 的结构值。

示例：

> SELECT from_csv('1, 0.8', 'a INT, b DOUBLE');
 {"a":1,"b":0.8}
> SELECT from_csv('26/08/2015', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
 {"time":2015-08-26 00:00:00}

自: 3.0.0

from_json

from_json(jsonStr, schema[, options]) - 返回一个具有给定 jsonStr 和 schema 的结构值。

示例：

> SELECT from_json('{"a":1, "b":0.8}', 'a INT, b DOUBLE');
 {"a":1,"b":0.8}
> SELECT from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
 {"time":2015-08-26 00:00:00}
> SELECT from_json('{"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}', 'STRUCT<teacher: STRING, student: ARRAY<STRUCT<name: STRING, rank: INT>>>');
 {"teacher":"Alice","student":[{"name":"Bob","rank":1},{"name":"Charlie","rank":2}]}

自: 2.2.0

from_unixtime

from_unixtime(unix_time[, fmt]) - 返回指定格式 fmt 中的 unix_time。

参数:

unix_time - 要转换为指定格式的UNIX时间戳。
fmt - 遵循的日期/时间格式模式。请参阅日期时间模式以获取有效的日期和时间格式模式。如果省略，则使用'yyyy-MM-dd HH:mm:ss'模式。

示例：

> SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss');
 1969-12-31 16:00:00

> SELECT from_unixtime(0);
 1969-12-31 16:00:00

自: 1.5.0

from_utc_timestamp

from_utc_timestamp(timestamp, timezone) - 给定一个时间戳，如 '2017-07-14 02:40:00.0'，将其解释为UTC时间，并在给定时区中显示该时间。例如，'GMT+1' 将产生 '2017-07-14 03:40:00.0'。

示例：

> SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul');
 2016-08-31 09:00:00

自: 1.5.0

get

get(array, index) - 返回数组中给定（基于0的）索引位置的元素。如果索引指向数组边界之外，则此函数返回NULL。

示例：

> SELECT get(array(1, 2, 3), 0);
 1
> SELECT get(array(1, 2, 3), 3);
 NULL
> SELECT get(array(1, 2, 3), -1);
 NULL

自: 3.4.0

get_json_object

get_json_object(json_txt, path) - 从 path 中提取一个 json 对象。

示例：

> SELECT get_json_object('{"a":"b"}', '$.a');
 b

自: 1.5.0

getbit

getbit(expr, pos) - 返回指定位置的位值（0 或 1）。位置从右到左编号，从零开始。位置参数不能为负数。

示例：

> SELECT getbit(11, 0);
 1
> SELECT getbit(11, 2);
 0

自: 3.2.0

greatest

greatest(expr, ...) - 返回所有参数中的最大值，跳过null值。

示例：

> SELECT greatest(10, 9, 2, 4, 3);
 10

自: 1.5.0

grouping

grouping(col) - 指示在 GROUP BY 中指定的列是否被聚合，在结果集中返回 1 表示聚合，0 表示未聚合。

示例：

> SELECT name, grouping(name), sum(age) FROM VALUES (2, 'Alice'), (5, 'Bob') people(age, name) GROUP BY cube(name);
  Alice 0   2
  Bob   0   5
  NULL  1   7

自: 2.0.0

grouping_id

grouping_id([col1[, col2 ..]]) - 返回分组的级别，等于 (grouping(c1) << (n-1)) + (grouping(c2) << (n-2)) + ... + grouping(cn)

示例：

> SELECT name, grouping_id(), sum(age), avg(height) FROM VALUES (2, 'Alice', 165), (5, 'Bob', 180) people(age, name, height) GROUP BY cube(name, height);
  Alice 0   2   165.0
  Alice 1   2   165.0
  NULL  3   7   172.5
  Bob   0   5   180.0
  Bob   1   5   180.0
  NULL  2   2   165.0
  NULL  2   5   180.0

注意：

输入列应与分组列完全匹配，或者为空（表示所有分组列）。

自: 2.0.0

hash

hash(expr1, expr2, ...) - 返回参数的哈希值。

示例：

> SELECT hash('Spark', array(123), 2);
 -1321691492

自: 2.0.0

hex

hex(expr) - 将 expr 转换为十六进制。

示例：

> SELECT hex(17);
 11
> SELECT hex('Spark SQL');
 537061726B2053514C

自: 1.5.0

histogram_numeric

histogram_numeric(expr, nb) - 计算数值'expr'的直方图，使用nb个区间。返回值是一个(x,y)对的数组，表示直方图区间的中心。随着'nb'值的增加，直方图的近似变得更细粒度，但可能在离群值周围产生伪影。在实践中，20-40个直方图区间似乎工作得很好，对于偏斜或较小的数据集可能需要更多的区间。请注意，此函数创建的直方图具有非均匀的区间宽度。它不提供关于直方图的均方误差的保证，但在实践中与R/S-Plus统计计算包生成的直方图相当。注意：返回值中'x'字段的输出类型是从聚合函数中消耗的输入值传播的。

示例：

> SELECT histogram_numeric(col, 5) FROM VALUES (0), (1), (2), (10) AS tab(col);
 [{"x":0,"y":1.0},{"x":1,"y":1.0},{"x":2,"y":1.0},{"x":10,"y":1.0}]

自: 3.3.0

hll_sketch_agg

hll_sketch_agg(expr, lgConfigK) - 返回HllSketch的可更新二进制表示。 lgConfigK（可选）是K的对数基2，其中K是HllSketch的桶或槽的数量。

示例：

> SELECT hll_sketch_estimate(hll_sketch_agg(col, 12)) FROM VALUES (1), (1), (2), (2), (3) tab(col);
 3

自: 3.5.0

hll_sketch_estimate

hll_sketch_estimate(expr) - 返回给定Datasketches HllSketch二进制表示的唯一值的估计数量。

示例：

> SELECT hll_sketch_estimate(hll_sketch_agg(col)) FROM VALUES (1), (1), (2), (2), (3) tab(col);
 3

自: 3.5.0

hll_union

hll_union(first, second, allowDifferentLgConfigK) - 合并两个Datasketches HllSketch对象的二进制表示，使用Datasketches Union对象。将allowDifferentLgConfigK设置为true以允许合并具有不同lgConfigK值的草图（默认为false）。

示例：

> SELECT hll_sketch_estimate(hll_union(hll_sketch_agg(col1), hll_sketch_agg(col2))) FROM VALUES (1, 4), (1, 4), (2, 5), (2, 5), (3, 6) tab(col1, col2);
 6

自: 3.5.0

hll_union_agg

hll_union_agg(expr, allowDifferentLgConfigK) - 返回估计的唯一值数量。 allowDifferentLgConfigK（可选）允许具有不同 lgConfigK 值的草图进行联合（默认为 false）。

示例：

> SELECT hll_sketch_estimate(hll_union_agg(sketch, true)) FROM (SELECT hll_sketch_agg(col) as sketch FROM VALUES (1) tab(col) UNION ALL SELECT hll_sketch_agg(col, 20) as sketch FROM VALUES (1) tab(col));
 1

自: 3.5.0

hour

hour(timestamp) - 返回字符串/时间戳的小时部分。

示例：

> SELECT hour('2009-07-30 12:58:59');
 12

自: 1.5.0

hypot

hypot(expr1, expr2) - 返回 sqrt(expr12 + expr22)。

示例：

> SELECT hypot(3, 4);
 5.0

自: 1.4.0

if

if(expr1, expr2, expr3) - 如果 expr1 计算为真，则返回 expr2；否则返回 expr3。

示例：

> SELECT if(1 < 2, 'a', 'b');
 a

自: 1.0.0

ifnull

ifnull(expr1, expr2) - 如果 expr1 为空，则返回 expr2，否则返回 expr1。

示例：

> SELECT ifnull(NULL, array('2'));
 ["2"]

自: 2.0.0

ilike

str ilike pattern[ ESCAPE escape] - 如果 str 与 pattern 使用 escape 不区分大小写地匹配，则返回 true；如果任何参数为 null，则返回 null；否则返回 false。

参数:

str - 一个字符串表达式
pattern - 一个字符串表达式。模式是一个字符串，它按字面匹配并且不区分大小写，但以下特殊符号除外：

_ 匹配输入中的任何一个字符（类似于 posix 正则表达式中的 .）

% 匹配输入中的零个或多个字符（类似于 posix 正则表达式中的 .*）

从 Spark 2.0 开始，字符串字面量在我们的 SQL 解析器中不再转义。例如，为了匹配 "\abc"，模式应该是 "\abc"。

当 SQL 配置 'spark.sql.parser.escapedStringLiterals' 启用时，它会回退到 Spark 1.6 的字符串字面量解析行为。例如，如果配置启用，匹配 "\abc" 的模式应该是 "\abc"。
escape - 自 Spark 3.0 起添加的字符。默认的转义字符是 '\'。如果一个转义字符位于一个特殊符号或另一个转义字符之前，则以下字符按字面匹配。转义任何其他字符是无效的。

示例：

> SELECT ilike('Spark', '_Park');
true
> SET spark.sql.parser.escapedStringLiterals=true;
spark.sql.parser.escapedStringLiterals  true
> SELECT '%SystemDrive%\Users\John' ilike '\%SystemDrive\%\\users%';
true
> SET spark.sql.parser.escapedStringLiterals=false;
spark.sql.parser.escapedStringLiterals  false
> SELECT '%SystemDrive%\\USERS\\John' ilike '\%SystemDrive\%\\\\Users%';
true
> SELECT '%SystemDrive%/Users/John' ilike '/%SYSTEMDrive/%//Users%' ESCAPE '/';
true

注意：

使用 RLIKE 来匹配标准正则表达式。

自: 3.3.0

in

expr1 in(expr2, expr3, ...) - 如果 expr 等于任何 valN，则返回 true。

参数:

expr1, expr2, expr3, ... - 参数必须是相同类型。

示例：

> SELECT 1 in(1, 2, 3);
 true
> SELECT 1 in(2, 3, 4);
 false
> SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 1), named_struct('a', 1, 'b', 3));
 false
> SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 3));
 true

自: 1.0.0

initcap

initcap(str) - 返回str，其中每个单词的首字母大写。所有其他字母均为小写。单词由空格分隔。

示例：

> SELECT initcap('sPark sql');
 Spark Sql

自: 1.5.0

inline

inline(expr) - 将一个结构数组的数组展开成一个表。默认使用列名 col1, col2 等，除非另有指定。

示例：

> SELECT inline(array(struct(1, 'a'), struct(2, 'b')));
 1  a
 2  b

自: 2.0.0

inline_outer

inline_outer(expr) - 将一个结构数组展开成一个表。默认使用列名 col1, col2 等，除非另有指定。

示例：

> SELECT inline_outer(array(struct(1, 'a'), struct(2, 'b')));
 1  a
 2  b

自: 2.0.0

input_file_block_length

input_file_block_length() - 返回正在读取的块的长度，如果不可用则返回-1。

示例：

> SELECT input_file_block_length();
 -1

自: 2.2.0

input_file_block_start

input_file_block_start() - 返回正在读取的块的起始偏移量，如果不可用则返回-1。

示例：

> SELECT input_file_block_start();
 -1

自: 2.2.0

input_file_name

input_file_name() - 返回正在读取的文件的名称，如果不可用则返回空字符串。

示例：

> SELECT input_file_name();

自: 1.5.0

instr

instr(str, substr) - 返回 substr 在 str 中首次出现的（基于1的）索引。

示例：

> SELECT instr('SparkSQL', 'SQL');
 6

自: 1.5.0

int

int(expr) - 将值 expr 转换为目标数据类型 int。

自: 2.0.1

isnan

isnan(expr) - 如果 expr 是 NaN，则返回 true，否则返回 false。

示例：

> SELECT isnan(cast('NaN' as double));
 true

自: 1.5.0

isnotnull

isnotnull(expr) - 如果expr不为空，则返回true，否则返回false。

示例：

> SELECT isnotnull(1);
 true

自: 1.0.0

isnull

isnull(expr) - 如果expr为空，则返回true，否则返回false。

示例：

> SELECT isnull(1);
 false

自: 1.0.0

java_method

java_method(class, method[, arg1[, arg2 ..]]) - 使用反射调用一个方法。

示例：

> SELECT java_method('java.util.UUID', 'randomUUID');
 c33fb387-8500-4bfa-81d2-6e0e3e930df2
> SELECT java_method('java.util.UUID', 'fromString', 'a5cf6c42-0c85-418f-af6c-3e4e5b1328f2');
 a5cf6c42-0c85-418f-af6c-3e4e5b1328f2

自: 2.0.0

json_array_length

json_array_length(jsonArray) - 返回最外层JSON数组中的元素数量。

参数:

jsonArray - 一个JSON数组。如果输入是其他有效的JSON字符串、NULL或无效的JSON，则返回NULL。

示例：

> SELECT json_array_length('[1,2,3,4]');
  4
> SELECT json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]');
  5
> SELECT json_array_length('[1,2');
  NULL

自: 3.1.0

json_object_keys

json_object_keys(json_object) - 返回最外层JSON对象的所有键作为数组。

参数:

json_object - 一个JSON对象。如果给定的是一个有效的JSON对象，所有最外层对象的键将被返回为一个数组。如果它是其他有效的JSON字符串、无效的JSON字符串或空字符串，函数将返回null。

示例：

> SELECT json_object_keys('{}');
  []
> SELECT json_object_keys('{"key": "value"}');
  ["key"]
> SELECT json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}');
  ["f1","f2"]

自: 3.1.0

json_tuple

json_tuple(jsonStr, p1, p2, ..., pn) - 返回一个元组，类似于函数 get_json_object，但它接受多个名称。所有输入参数和输出列类型都是字符串。

示例：

> SELECT json_tuple('{"a":1, "b":2}', 'a', 'b');
 1  2

自: 1.6.0

kurtosis

kurtosis(expr) - 返回从一组值计算出的峰度值。

示例：

> SELECT kurtosis(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
 -0.7014368047529627
> SELECT kurtosis(col) FROM VALUES (1), (10), (100), (10), (1) as tab(col);
 0.19432323191699075

自: 1.6.0

lag

lag(input[, offset[, default]]) - 返回窗口中当前行之前的第offset行的input值。offset的默认值是1，default的默认值是null。如果input在第offset行的值为null，则返回null。如果没有这样的偏移行（例如，当偏移量为1时，窗口的第一行没有任何前一行），则返回default。

参数:

input - 一个字符串表达式，用于在当前行之前计算offset行。
offset - 一个整数表达式，表示在分区中要回跳的行数。
default - 一个字符串表达式，用于在偏移行不存在时使用。

示例：

> SELECT a, b, lag(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
 A1 1   NULL
 A1 1   1
 A1 2   1
 A2 3   NULL

自: 2.0.0

last

last(expr[, isIgnoreNull]) - 返回一组行中expr的最后一个值。如果isIgnoreNull为true，则仅返回非空值

示例：

> SELECT last(col) FROM VALUES (10), (5), (20) AS tab(col);
 20
> SELECT last(col) FROM VALUES (10), (5), (NULL) AS tab(col);
 NULL
> SELECT last(col, true) FROM VALUES (10), (5), (NULL) AS tab(col);
 5

注意：

该函数是不确定的，因为其结果取决于行的顺序，而在混洗后顺序可能是不确定的。

自: 2.0.0

last_day

last_day(date) - 返回日期所属月份的最后一天。

示例：

> SELECT last_day('2009-01-12');
 2009-01-31

自: 1.5.0

last_value

last_value(expr[, isIgnoreNull]) - 返回一组行中expr的最后一个值。如果isIgnoreNull为true，则仅返回非空值

示例：

> SELECT last_value(col) FROM VALUES (10), (5), (20) AS tab(col);
 20
> SELECT last_value(col) FROM VALUES (10), (5), (NULL) AS tab(col);
 NULL
> SELECT last_value(col, true) FROM VALUES (10), (5), (NULL) AS tab(col);
 5

注意：

该函数是不确定的，因为其结果取决于行的顺序，而在混洗后顺序可能是不确定的。

自: 2.0.0

lcase

lcase(str) - 返回将所有字符转换为小写的str。

示例：

> SELECT lcase('SparkSql');
 sparksql

自: 1.0.1

lead

lead(input[, offset[, default]]) - 返回窗口中当前行之后的第offset行的input值。offset的默认值为1，default的默认值为null。如果input在第offset行的值为null，则返回null。如果没有这样的偏移行（例如，当偏移量为1时，窗口的最后一行没有任何后续行），则返回default。

参数:

input - 一个字符串表达式，用于计算当前行之后的offset行。
offset - 一个整数表达式，表示在分区中要跳过的行数。
default - 一个字符串表达式，当偏移量大于窗口时使用。默认值为null。

示例：

> SELECT a, b, lead(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
 A1 1   1
 A1 1   2
 A1 2   NULL
 A2 3   NULL

自: 2.0.0

least

least(expr, ...) - 返回所有参数中的最小值，跳过null值。

示例：

> SELECT least(10, 9, 2, 4, 3);
 2

自: 1.5.0

left

left(str, len) - 返回字符串 str 中最左边的 len(len 可以是字符串类型) 个字符，如果 len 小于或等于 0，则结果为空字符串。

示例：

> SELECT left('Spark SQL', 3);
 Spa
> SELECT left(encode('Spark SQL', 'utf-8'), 3);
 Spa

自: 2.3.0

len

len(expr) - 返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括尾随空格。二进制数据的长度包括二进制零。

示例：

> SELECT len('Spark SQL ');
 10
> SELECT len(x'537061726b2053514c');
 9
> SELECT CHAR_LENGTH('Spark SQL ');
 10
> SELECT CHARACTER_LENGTH('Spark SQL ');
 10

自: 3.4.0

length

length(expr) - 返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括尾随空格。二进制数据的长度包括二进制零。

示例：

> SELECT length('Spark SQL ');
 10
> SELECT length(x'537061726b2053514c');
 9
> SELECT CHAR_LENGTH('Spark SQL ');
 10
> SELECT CHARACTER_LENGTH('Spark SQL ');
 10

自: 1.5.0

levenshtein

levenshtein(str1, str2[, threshold]) - 返回两个给定字符串之间的Levenshtein距离。如果设置了阈值且距离超过它，则返回-1。

示例：

> SELECT levenshtein('kitten', 'sitting');
 3
> SELECT levenshtein('kitten', 'sitting', 2);
 -1

自: 1.5.0

like

str like pattern[ ESCAPE escape] - 如果str与带有escape的pattern匹配，则返回true；如果任何参数为null，则返回null；否则返回false。

参数:

str - 一个字符串表达式
pattern - 一个字符串表达式。模式是一个字符串，按字面匹配，但以下特殊符号除外：

_ 匹配输入中的任意一个字符（类似于 posix 正则表达式中的 .）\ % 匹配输入中的零个或多个字符（类似于 posix 正则表达式中的 .*）

从 Spark 2.0 开始，字符串字面量在我们的 SQL 解析器中不再转义。例如，为了匹配 "\abc"，模式应该是 "\abc"。

当 SQL 配置 'spark.sql.parser.escapedStringLiterals' 启用时，它会回退到 Spark 1.6 的字符串字面量解析行为。例如，如果配置启用，匹配 "\abc" 的模式应该是 "\abc"。
escape - 自 Spark 3.0 起添加的字符。默认的转义字符是 '\'。如果转义字符位于特殊符号或其他转义字符之前，则以下字符按字面匹配。转义任何其他字符是无效的。

示例：

> SELECT like('Spark', '_park');
true
> SET spark.sql.parser.escapedStringLiterals=true;
spark.sql.parser.escapedStringLiterals  true
> SELECT '%SystemDrive%\Users\John' like '\%SystemDrive\%\\Users%';
true
> SET spark.sql.parser.escapedStringLiterals=false;
spark.sql.parser.escapedStringLiterals  false
> SELECT '%SystemDrive%\\Users\\John' like '\%SystemDrive\%\\\\Users%';
true
> SELECT '%SystemDrive%/Users/John' like '/%SystemDrive/%//Users%' ESCAPE '/';
true

注意：

使用 RLIKE 来匹配标准正则表达式。

自: 1.0.0

ln

ln(expr) - 返回expr的自然对数（以e为底）。

示例：

> SELECT ln(1);
 0.0

自: 1.4.0

localtimestamp

localtimestamp() - 返回查询评估开始时的当前时间戳，不带时区。同一查询中所有对localtimestamp的调用都返回相同的值。

localtimestamp - 返回查询评估开始时会话时区中的当前本地日期时间。

示例：

> SELECT localtimestamp();
 2020-04-25 15:49:11.914

自: 3.4.0

locate

locate(substr, str[, pos]) - 返回在str中从位置pos开始第一次出现substr的位置。给定的pos和返回值都是基于1的。

示例：

> SELECT locate('bar', 'foobarbar');
 4
> SELECT locate('bar', 'foobarbar', 5);
 7
> SELECT POSITION('bar' IN 'foobarbar');
 4

自: 1.5.0

log

log(base, expr) - 返回以base为底expr的对数。

示例：

> SELECT log(10, 100);
 2.0

自: 1.5.0

log10

log10(expr) - 返回以10为底的expr的对数。

示例：

> SELECT log10(10);
 1.0

自: 1.4.0

log1p

log1p(expr) - 返回 log(1 + expr)。

示例：

> SELECT log1p(0);
 0.0

自: 1.4.0

log2

log2(expr) - 返回以2为底的expr的对数。

示例：

> SELECT log2(2);
 1.0

自: 1.4.0

lower

lower(str) - 返回将所有字符转换为小写的str。

示例：

> SELECT lower('SparkSql');
 sparksql

自: 1.0.1

lpad

lpad(str, len[, pad]) - 返回 str，左侧填充 pad 到长度为 len。如果 str 比 len 长，返回值将被截断为 len 个字符或字节。如果未指定 pad，str 将在左侧填充空格字符（如果是字符串），或者填充零（如果是字节序列）。

示例：

> SELECT lpad('hi', 5, '??');
 ???hi
> SELECT lpad('hi', 1, '??');
 h
> SELECT lpad('hi', 5);
    hi
> SELECT hex(lpad(unhex('aabb'), 5));
 000000AABB
> SELECT hex(lpad(unhex('aabb'), 5, unhex('1122')));
 112211AABB

自: 1.5.0

ltrim

ltrim(str) - 从str中移除前导空格字符。

参数:

str - 一个字符串表达式
trimStr - 要修剪的修剪字符串字符，默认值是一个空格

示例：

> SELECT ltrim('    SparkSQL   ');
 SparkSQL

自: 1.5.0

luhn_check

luhn_check(str) - 根据Luhn算法检查一串数字是否有效。这个校验和函数广泛应用于信用卡号码和政府识别号码，以区分有效号码与输入错误、不正确的号码。

示例：

> SELECT luhn_check('8112189876');
 true
> SELECT luhn_check('79927398713');
 true
> SELECT luhn_check('79927398714');
 false

自: 3.5.0

make_date

make_date(year, month, day) - 从年、月和日字段创建日期。如果配置 spark.sql.ansi.enabled 为 false，函数在输入无效时返回 NULL。否则，它将抛出一个错误。

参数:

year - 要表示的年份，从1到9999
month - 要表示的月份，从1（一月）到12（十二月）
day - 要表示的日期，从1到31

示例：

> SELECT make_date(2013, 7, 15);
 2013-07-15
> SELECT make_date(2019, 7, NULL);
 NULL

自: 3.0.0

make_dt_interval

make_dt_interval([days[, hours[, mins[, secs]]]]) - 从天数、小时数、分钟数和秒数创建DayTimeIntervalType持续时间。

参数:

days - 天数，正数或负数
hours - 小时数，正数或负数
mins - 分钟数，正数或负数
secs - 秒数，包含微秒精度的分数部分。

示例：

> SELECT make_dt_interval(1, 12, 30, 01.001001);
 1 12:30:01.001001000
> SELECT make_dt_interval(2);
 2 00:00:00.000000000
> SELECT make_dt_interval(100, null, 3);
 NULL

自: 3.2.0

make_interval

make_interval([years[, months[, weeks[, days[, hours[, mins[, secs]]]]]]]) - 从年、月、周、天、小时、分钟和秒创建间隔。

参数:

years - 年数，正数或负数
months - 月数，正数或负数
weeks - 周数，正数或负数
days - 天数，正数或负数
hours - 小时数，正数或负数
mins - 分钟数，正数或负数
secs - 秒数，包含微秒精度的分数部分。

示例：

> SELECT make_interval(100, 11, 1, 1, 12, 30, 01.001001);
 100 years 11 months 8 days 12 hours 30 minutes 1.001001 seconds
> SELECT make_interval(100, null, 3);
 NULL
> SELECT make_interval(0, 1, 0, 1, 0, 0, 100.000001);
 1 months 1 days 1 minutes 40.000001 seconds

自: 3.0.0

make_timestamp

make_timestamp(year, month, day, hour, min, sec[, timezone]) - 从年、月、日、时、分、秒和时区字段创建时间戳。结果数据类型与配置spark.sql.timestampType的值一致。如果配置spark.sql.ansi.enabled为false，函数在输入无效时返回NULL。否则，它将抛出一个错误。

参数:

year - 要表示的年份，从1到9999
month - 要表示的月份，从1（一月）到12（十二月）
day - 要表示的月份中的天数，从1到31
hour - 要表示的一天中的小时，从0到23
min - 要表示的小时中的分钟，从0到59
sec - 要表示的分钟中的秒数及其微小数部分，从0到60。该值可以是整数，如13，或小数，如13.123。如果sec参数等于60，则秒字段设置为0，并向最终时间戳添加1分钟。
timezone - 时区标识符。例如，CET、UTC等。

示例：

> SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887);
 2014-12-28 06:30:45.887
> SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET');
 2014-12-27 21:30:45.887
> SELECT make_timestamp(2019, 6, 30, 23, 59, 60);
 2019-07-01 00:00:00
> SELECT make_timestamp(2019, 6, 30, 23, 59, 1);
 2019-06-30 23:59:01
> SELECT make_timestamp(null, 7, 22, 15, 30, 0);
 NULL

自: 3.0.0

make_timestamp_ltz

make_timestamp_ltz(year, month, day, hour, min, sec[, timezone]) - 从年、月、日、小时、分钟、秒和时区字段创建当前带本地时区的时间戳。如果配置 spark.sql.ansi.enabled 为 false，函数在输入无效时返回 NULL。否则，它将抛出一个错误。

参数:

year - 要表示的年份，从1到9999
month - 要表示的月份，从1（一月）到12（十二月）
day - 要表示的月份中的天数，从1到31
hour - 要表示的一天中的小时，从0到23
min - 要表示的小时中的分钟，从0到59
sec - 要表示的分钟中的秒及其微小数部分，从0到60。如果sec参数等于60，则秒字段设置为0，并向最终时间戳添加1分钟。
timezone - 时区标识符。例如，CET、UTC等。

示例：

> SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887);
 2014-12-28 06:30:45.887
> SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, 'CET');
 2014-12-27 21:30:45.887
> SELECT make_timestamp_ltz(2019, 6, 30, 23, 59, 60);
 2019-07-01 00:00:00
> SELECT make_timestamp_ltz(null, 7, 22, 15, 30, 0);
 NULL

自: 3.4.0

make_timestamp_ntz

make_timestamp_ntz(year, month, day, hour, min, sec) - 从年、月、日、小时、分钟、秒字段创建本地日期时间。如果配置spark.sql.ansi.enabled为false，函数在输入无效时返回NULL。否则，它将抛出一个错误。

参数:

year - 要表示的年份，从1到9999
month - 要表示的月份，从1（一月）到12（十二月）
day - 要表示的月份中的天数，从1到31
hour - 要表示的一天中的小时，从0到23
min - 要表示的小时中的分钟，从0到59
sec - 要表示的分钟中的秒及其微小数部分，从0到60。如果sec参数等于60，则秒字段设置为0，并向最终时间戳添加1分钟。

示例：

> SELECT make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887);
 2014-12-28 06:30:45.887
> SELECT make_timestamp_ntz(2019, 6, 30, 23, 59, 60);
 2019-07-01 00:00:00
> SELECT make_timestamp_ntz(null, 7, 22, 15, 30, 0);
 NULL

自: 3.4.0

make_ym_interval

make_ym_interval([years[, months]]) - 从年份和月份创建年-月间隔。

参数:

years - 年数，正数或负数
months - 月数，正数或负数

示例：

> SELECT make_ym_interval(1, 2);
 1-2
> SELECT make_ym_interval(1, 0);
 1-0
> SELECT make_ym_interval(-1, 1);
 -0-11
> SELECT make_ym_interval(2);
 2-0

自: 3.2.0

map

map(key0, value0, key1, value1, ...) - 创建一个包含给定键/值对的映射。

示例：

> SELECT map(1.0, '2', 3.0, '4');
 {1.0:"2",3.0:"4"}

自: 2.0.0

map_concat

map_concat(map, ...) - 返回所有给定映射的并集

示例：

> SELECT map_concat(map(1, 'a', 2, 'b'), map(3, 'c'));
 {1:"a",2:"b",3:"c"}

自: 2.4.0

map_contains_key

map_contains_key(map, key) - 如果映射包含该键，则返回true。

示例：

> SELECT map_contains_key(map(1, 'a', 2, 'b'), 1);
 true
> SELECT map_contains_key(map(1, 'a', 2, 'b'), 3);
 false

自: 3.3.0

map_entries

map_entries(map) - 返回给定映射中的所有条目的无序数组。

示例：

> SELECT map_entries(map(1, 'a', 2, 'b'));
 [{"key":1,"value":"a"},{"key":2,"value":"b"}]

自: 3.0.0

map_filter

map_filter(expr, func) - 使用函数过滤映射中的条目。

示例：

> SELECT map_filter(map(1, 0, 2, 2, 3, -1), (k, v) -> k > v);
 {1:0,3:-1}

自: 3.0.0

map_from_arrays

map_from_arrays(keys, values) - 使用给定的键/值数组创建一个映射。所有键中的元素都不应为空

示例：

> SELECT map_from_arrays(array(1.0, 3.0), array('2', '4'));
 {1.0:"2",3.0:"4"}

自: 2.4.0

map_from_entries

map_from_entries(arrayOfEntries) - 返回从给定数组条目创建的映射。

示例：

> SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b')));
 {1:"a",2:"b"}

自: 2.4.0

map_keys

map_keys(map) - 返回一个包含映射键的无序数组。

示例：

> SELECT map_keys(map(1, 'a', 2, 'b'));
 [1,2]

自: 2.0.0

map_values

map_values(map) - 返回一个包含映射值的无序数组。

示例：

> SELECT map_values(map(1, 'a', 2, 'b'));
 ["a","b"]

自: 2.0.0

map_zip_with

map_zip_with(map1, map2, function) - 将两个给定的映射合并为一个映射，通过将函数应用于具有相同键的一对值。对于仅在一个映射中出现的键，将传递NULL作为缺失键的值。如果输入映射包含重复的键，则仅将重复键的第一个条目传递给lambda函数。

示例：

> SELECT map_zip_with(map(1, 'a', 2, 'b'), map(1, 'x', 2, 'y'), (k, v1, v2) -> concat(v1, v2));
 {1:"ax",2:"by"}
> SELECT map_zip_with(map('a', 1, 'b', 2), map('b', 3, 'c', 4), (k, v1, v2) -> coalesce(v1, 0) + coalesce(v2, 0));
 {"a":1,"b":5,"c":4}

自: 3.0.0

mask

mask(input[, upperChar, lowerChar, digitChar, otherChar]) - 对给定的字符串值进行掩码处理。该函数将字符替换为'X'或'x'，将数字替换为'n'。这对于创建移除了敏感信息的表格副本非常有用。

参数:

input - 要屏蔽的字符串值。支持的类型：STRING, VARCHAR, CHAR
upperChar - 用于替换大写字符的字符。指定NULL以保留原始字符。默认值：'X'
lowerChar - 用于替换小写字符的字符。指定NULL以保留原始字符。默认值：'x'
digitChar - 用于替换数字字符的字符。指定NULL以保留原始字符。默认值：'n'
otherChar - 用于替换所有其他字符的字符。指定NULL以保留原始字符。默认值：NULL

示例：

> SELECT mask('abcd-EFGH-8765-4321');
  xxxx-XXXX-nnnn-nnnn
> SELECT mask('abcd-EFGH-8765-4321', 'Q');
  xxxx-QQQQ-nnnn-nnnn
> SELECT mask('AbCD123-@$#', 'Q', 'q');
  QqQQnnn-@$#
> SELECT mask('AbCD123-@$#');
  XxXXnnn-@$#
> SELECT mask('AbCD123-@$#', 'Q');
  QxQQnnn-@$#
> SELECT mask('AbCD123-@$#', 'Q', 'q');
  QqQQnnn-@$#
> SELECT mask('AbCD123-@$#', 'Q', 'q', 'd');
  QqQQddd-@$#
> SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o');
  QqQQdddoooo
> SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o');
  AqCDdddoooo
> SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o');
  AbCDdddoooo
> SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o');
  AbCD123oooo
> SELECT mask(NULL, NULL, NULL, NULL, 'o');
  NULL
> SELECT mask(NULL);
  NULL
> SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL);
  AbCD123-@$#

自: 3.4.0

max

max(expr) - 返回expr的最大值。

示例：

> SELECT max(col) FROM VALUES (10), (50), (20) AS tab(col);
 50

自: 1.0.0

max_by

max_by(x, y) - 返回与y的最大值相关联的x的值。

示例：

> SELECT max_by(x, y) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y);
 b

自: 3.0.0

md5

md5(expr) - 返回expr的MD5 128位校验和，以十六进制字符串表示。

示例：

> SELECT md5('Spark');
 8cde774d6f7333752ed72cacddb05126

自: 1.5.0

mean

mean(expr) - 返回从一组值计算出的平均值。

示例：

> SELECT mean(col) FROM VALUES (1), (2), (3) AS tab(col);
 2.0
> SELECT mean(col) FROM VALUES (1), (2), (NULL) AS tab(col);
 1.5

自: 1.0.0

median

median(col) - 返回数值或ANSI区间列col的中位数。

示例：

> SELECT median(col) FROM VALUES (0), (10) AS tab(col);
 5.0
> SELECT median(col) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH) AS tab(col);
 0-5

自: 3.4.0

min

min(expr) - 返回expr的最小值。

示例：

> SELECT min(col) FROM VALUES (10), (-1), (20) AS tab(col);
 -1

自: 1.0.0

min_by

min_by(x, y) - 返回与y的最小值相关联的x的值。

示例：

> SELECT min_by(x, y) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y);
 a

自: 3.0.0

minute

minute(timestamp) - 返回字符串/时间戳的分钟部分。

示例：

> SELECT minute('2009-07-30 12:58:59');
 58

自: 1.5.0

mod

expr1 mod expr2 - 返回 expr1/expr2 后的余数。

示例：

> SELECT 2 % 1.8;
 0.2
> SELECT MOD(2, 1.8);
 0.2

自: 1.0.0

mode

mode(col) - 返回col中出现频率最高的值。忽略NULL值。如果所有值都是NULL，或者没有行，则返回NULL。

示例：

> SELECT mode(col) FROM VALUES (0), (10), (10) AS tab(col);
 10
> SELECT mode(col) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH), (INTERVAL '10' MONTH) AS tab(col);
 0-10
> SELECT mode(col) FROM VALUES (0), (10), (10), (null), (null), (null) AS tab(col);
 10

自: 3.4.0

monotonically_increasing_id

monotonically_increasing_id() - 返回单调递增的64位整数。生成的ID保证是单调递增且唯一的，但不是连续的。当前的实现将分区ID放在高31位，低33位表示每个分区内的记录号。假设数据框的分区数少于10亿个，并且每个分区内的记录数少于80亿条。该函数是非确定性的，因为其结果取决于分区ID。

示例：

> SELECT monotonically_increasing_id();
 0

自: 1.4.0

month

month(date) - 返回日期/时间戳的月份部分。

示例：

> SELECT month('2016-07-30');
 7

自: 1.5.0

months_between

months_between(timestamp1, timestamp2[, roundOff]) - 如果 timestamp1 晚于 timestamp2，则结果为正。如果 timestamp1 和 timestamp2 是同一个月的同一天，或者都是该月的最后一天，则忽略时间。否则，差异基于每月31天计算，并四舍五入到8位数字，除非 roundOff=false。

示例：

> SELECT months_between('1997-02-28 10:30:00', '1996-10-30');
 3.94959677
> SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false);
 3.9495967741935485

自: 1.5.0

named_struct

named_struct(name1, val1, name2, val2, ...) - 创建一个具有给定字段名称和值的结构。

示例：

> SELECT named_struct("a", 1, "b", 2, "c", 3);
 {"a":1,"b":2,"c":3}

自: 1.5.0

nanvl

nanvl(expr1, expr2) - 如果 expr1 不是 NaN，则返回 expr1，否则返回 expr2。

示例：

> SELECT nanvl(cast('NaN' as double), 123);
 123.0

自: 1.5.0

negative

negative(expr) - 返回 expr 的负值。

示例：

> SELECT negative(1);
 -1

自: 1.0.0

next_day

next_day(start_date, day_of_week) - 返回第一个比start_date晚且名为指定名称的日期。如果至少有一个输入参数为NULL，函数返回NULL。当两个输入参数都不为NULL且day_of_week是无效输入时，如果spark.sql.ansi.enabled设置为true，函数会抛出IllegalArgumentException，否则返回NULL。

示例：

> SELECT next_day('2015-01-14', 'TU');
 2015-01-20

自: 1.5.0

not

not expr - 逻辑非。

示例：

> SELECT not true;
 false
> SELECT not false;
 true
> SELECT not NULL;
 NULL

自: 1.0.0

now

now() - 返回查询评估开始时的当前时间戳。

示例：

> SELECT now();
 2020-04-25 15:49:11.914

自: 1.6.0

nth_value

nth_value(input[, offset]) - 返回窗口框架中从开始算起的第offset行处的input值。偏移量从1开始。如果ignoreNulls=true，我们在查找第offset行时会跳过空值。否则，每一行都计入offset。如果没有这样的第offset行（例如，当偏移量为10，窗口框架的大小小于10时），则返回空值。

参数:

input - 函数操作的目标列或表达式。
offset - 一个正整数文字，用于指示窗口框架中的偏移量。它从1开始。
ignoreNulls - 一个可选的规范，指示NthValue应在确定要使用的行时跳过空值。

示例：

> SELECT a, b, nth_value(b, 2) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
 A1 1   1
 A1 1   1
 A1 2   1
 A2 3   NULL

自: 3.1.0

ntile

ntile(n) - 将每个窗口分区的行划分为n个桶，范围从1到最多n。

参数:

buckets - 一个整数表达式，表示要将行分成的桶的数量。默认值是1。

示例：

> SELECT a, b, ntile(2) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
 A1 1   1
 A1 1   1
 A1 2   2
 A2 3   1

自: 2.0.0

nullif

nullif(expr1, expr2) - 如果 expr1 等于 expr2，则返回 null，否则返回 expr1。

示例：

> SELECT nullif(2, 2);
 NULL

自: 2.0.0

nvl

nvl(expr1, expr2) - 如果 expr1 为空，则返回 expr2，否则返回 expr1。

示例：

> SELECT nvl(NULL, array('2'));
 ["2"]

自: 2.0.0

nvl2

nvl2(expr1, expr2, expr3) - 如果 expr1 不为空，则返回 expr2，否则返回 expr3。

示例：

> SELECT nvl2(NULL, 2, 1);
 1

自: 2.0.0

octet_length

octet_length(expr) - 返回字符串数据的字节长度或二进制数据的字节数。

示例：

> SELECT octet_length('Spark SQL');
 9
> SELECT octet_length(x'537061726b2053514c');
 9

自: 2.3.0

or

expr1 或 expr2 - 逻辑或。

示例：

> SELECT true or false;
 true
> SELECT false or false;
 false
> SELECT true or NULL;
 true
> SELECT false or NULL;
 NULL

自: 1.0.0

overlay

overlay(input, replace, pos[, len]) - 将 input 从 pos 位置开始替换为长度为 len 的 replace。

示例：

> SELECT overlay('Spark SQL' PLACING '_' FROM 6);
 Spark_SQL
> SELECT overlay('Spark SQL' PLACING 'CORE' FROM 7);
 Spark CORE
> SELECT overlay('Spark SQL' PLACING 'ANSI ' FROM 7 FOR 0);
 Spark ANSI SQL
> SELECT overlay('Spark SQL' PLACING 'tructured' FROM 2 FOR 4);
 Structured SQL
> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('_', 'utf-8') FROM 6);
 Spark_SQL
> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('CORE', 'utf-8') FROM 7);
 Spark CORE
> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('ANSI ', 'utf-8') FROM 7 FOR 0);
 Spark ANSI SQL
> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('tructured', 'utf-8') FROM 2 FOR 4);
 Structured SQL

自: 3.0.0

parse_url

parse_url(url, partToExtract[, key]) - 从URL中提取部分内容。

示例：

> SELECT parse_url('http://spark.apache.org/path?query=1', 'HOST');
 spark.apache.org
> SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY');
 query=1
> SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', 'query');
 1

自: 2.0.0

percent_rank

percent_rank() - 计算一个值在一组值中的百分比排名。

参数:

children - 这是用于排名的基础；其中一个子值的变化将触发排名的变化。这是一个内部参数，将由分析器分配。

示例：

> SELECT a, b, percent_rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
 A1 1   0.0
 A1 1   0.0
 A1 2   1.0
 A2 3   0.0

自: 2.0.0

percentile

percentile(col, percentage [, frequency]) - 返回数值或ANSI间隔列col在给定百分比下的精确百分位值。百分比的值必须在0.0到1.0之间。频率的值应为正整数

percentile(col, array(percentage1 [, percentage2]...) [, frequency]) - 返回数值列col在给定百分比处的精确百分位值数组。百分比数组中的每个值必须在0.0到1.0之间。频率值应为正整数

示例：

> SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);
 3.0
> SELECT percentile(col, array(0.25, 0.75)) FROM VALUES (0), (10) AS tab(col);
 [2.5,7.5]
> SELECT percentile(col, 0.5) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH) AS tab(col);
 0-5
> SELECT percentile(col, array(0.2, 0.5)) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '10' SECOND) AS tab(col);
 [0 00:00:02.000000000,0 00:00:05.000000000]

自: 2.1.0

percentile_approx

percentile_approx(col, percentage [, accuracy]) - 返回数值或ansi间隔列col的近似percentile，即在有序col值（从最小到最大排序）中，不超过percentage的col值小于或等于该值的最小值。百分比值必须在0.0到1.0之间。 accuracy参数（默认值：10000）是一个控制近似精度的正数，以内存为代价。accuracy值越高，精度越好，1.0/accuracy是近似的相对误差。当percentage是一个数组时，百分比数组的每个值必须在0.0到1.0之间。在这种情况下，返回列col在给定百分比数组处的近似百分位数数组。

示例：

> SELECT percentile_approx(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col);
 [1,1,0]
> SELECT percentile_approx(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col);
 7
> SELECT percentile_approx(col, 0.5, 100) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '1' MONTH), (INTERVAL '2' MONTH), (INTERVAL '10' MONTH) AS tab(col);
 0-1
> SELECT percentile_approx(col, array(0.5, 0.7), 100) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '1' SECOND), (INTERVAL '2' SECOND), (INTERVAL '10' SECOND) AS tab(col);
 [0 00:00:01.000000000,0 00:00:02.000000000]

自: 2.1.0

pi

pi() - 返回圆周率π。

示例：

> SELECT pi();
 3.141592653589793

自: 1.5.0

pmod

pmod(expr1, expr2) - 返回 expr1 mod expr2 的正值。

示例：

> SELECT pmod(10, 3);
 1
> SELECT pmod(-10, 3);
 2

自: 1.5.0

posexplode

posexplode(expr) - 将数组 expr 的元素分离成带有位置的多行，或将映射 expr 的元素分离成带有位置的多行和多列。除非另有指定，否则使用列名 pos 表示位置，col 表示数组的元素，或 key 和 value 表示映射的元素。

示例：

> SELECT posexplode(array(10,20));
 0  10
 1  20
> SELECT * FROM posexplode(array(10,20));
 0  10
 1  20

自: 2.0.0

posexplode_outer

posexplode_outer(expr) - 将数组 expr 的元素分离成多个带有位置的行，或将映射 expr 的元素分离成多个带有位置的行和列。除非另有指定，否则使用列名 pos 表示位置，col 表示数组的元素，或 key 和 value 表示映射的元素。

示例：

> SELECT posexplode_outer(array(10,20));
 0  10
 1  20
> SELECT * FROM posexplode_outer(array(10,20));
 0  10
 1  20

自: 2.0.0

position

position(substr, str[, pos]) - 返回在str中从位置pos开始第一次出现substr的位置。给定的pos和返回值都是基于1的。

示例：

> SELECT position('bar', 'foobarbar');
 4
> SELECT position('bar', 'foobarbar', 5);
 7
> SELECT POSITION('bar' IN 'foobarbar');
 4

自: 1.5.0

positive

positive(expr) - 返回 expr 的值。

示例：

> SELECT positive(1);
 1

自: 1.5.0

pow

pow(expr1, expr2) - 将 expr1 提升为 expr2 的幂。

示例：

> SELECT pow(2, 3);
 8.0

自: 1.4.0

power

power(expr1, expr2) - 将expr1提升到expr2的幂。

示例：

> SELECT power(2, 3);
 8.0

自: 1.4.0

printf

printf(strfmt, obj, ...) - 返回从printf风格格式字符串格式化的字符串。

示例：

> SELECT printf("Hello World %d %s", 100, "days");
 Hello World 100 days

自: 1.5.0

quarter

quarter(date) - 返回日期在一年中的季度，范围为1到4。

示例：

> SELECT quarter('2016-08-31');
 3

自: 1.5.0

radians

radians(expr) - 将度数转换为弧度。

参数:

expr - 角度（度）

示例：

> SELECT radians(180);
 3.141592653589793

自: 1.4.0

raise_error

raise_error(expr) - 抛出一个带有expr的异常。

示例：

> SELECT raise_error('custom error message');
 java.lang.RuntimeException
 custom error message

自: 3.1.0

rand

rand([seed]) - 返回一个在 [0, 1) 区间内均匀分布的独立同分布随机值。

示例：

> SELECT rand();
 0.9629742951434543
> SELECT rand(0);
 0.7604953758285915
> SELECT rand(null);
 0.7604953758285915

注意：

该函数在一般情况下是非确定性的。

自: 1.5.0

randn

randn([seed]) - 返回一个从标准正态分布中抽取的独立同分布（i.i.d.）随机值。

示例：

> SELECT randn();
 -0.3254147983080288
> SELECT randn(0);
 1.6034991609278433
> SELECT randn(null);
 1.6034991609278433

注意：

该函数在一般情况下是非确定性的。

自: 1.5.0

random

random([seed]) - 返回一个在[0, 1)区间内均匀分布的独立同分布（i.i.d.）随机值。

示例：

> SELECT random();
 0.9629742951434543
> SELECT random(0);
 0.7604953758285915
> SELECT random(null);
 0.7604953758285915

注意：

该函数在一般情况下是非确定性的。

自: 1.5.0

rank

rank() - 计算一个值在一组值中的排名。结果是分区中按顺序排列的当前行之前或等于当前行的行数加一。这些值将在序列中产生间隙。

参数:

children - 这是用于排名的基础；其中一个子值的变化将触发排名的变化。这是一个内部参数，将由分析器分配。

示例：

> SELECT a, b, rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
 A1 1   1
 A1 1   1
 A1 2   3
 A2 3   1

自: 2.0.0

reduce

reduce(expr, start, merge, finish) - 将一个二元运算符应用于初始状态和数组中的所有元素，并将其归约为一个单一状态。最终状态通过应用一个finish函数转换为最终结果。

示例：

> SELECT reduce(array(1, 2, 3), 0, (acc, x) -> acc + x);
 6
> SELECT reduce(array(1, 2, 3), 0, (acc, x) -> acc + x, acc -> acc * 10);
 60

自: 3.4.0

reflect

reflect(class, method[, arg1[, arg2 ..]]) - 使用反射调用一个方法。

示例：

> SELECT reflect('java.util.UUID', 'randomUUID');
 c33fb387-8500-4bfa-81d2-6e0e3e930df2
> SELECT reflect('java.util.UUID', 'fromString', 'a5cf6c42-0c85-418f-af6c-3e4e5b1328f2');
 a5cf6c42-0c85-418f-af6c-3e4e5b1328f2

自: 2.0.0

regexp

regexp(str, regexp) - 如果 str 匹配 regexp，则返回 true，否则返回 false。

参数:

str - 一个字符串表达式
regexp - 一个字符串表达式。正则表达式字符串应该是Java正则表达式。

自Spark 2.0以来，字符串字面量（包括正则表达式模式）在我们的SQL解析器中未被转义。例如，要匹配"\abc"，正则表达式可以为regexp设置为"^\abc$"。

有一个SQL配置项'spark.sql.parser.escapedStringLiterals'可以用来回退到Spark 1.6关于字符串字面量解析的行为。例如，如果启用了该配置，可以匹配"\abc"的regexp是"^\abc$"。

示例：

> SET spark.sql.parser.escapedStringLiterals=true;
spark.sql.parser.escapedStringLiterals  true
> SELECT regexp('%SystemDrive%\Users\John', '%SystemDrive%\\Users.*');
true
> SET spark.sql.parser.escapedStringLiterals=false;
spark.sql.parser.escapedStringLiterals  false
> SELECT regexp('%SystemDrive%\\Users\\John', '%SystemDrive%\\\\Users.*');
true

注意：

使用 LIKE 来匹配简单的字符串模式。

自: 3.2.0

regexp_count

regexp_count(str, regexp) - 返回正则表达式模式regexp在字符串str中匹配的次数。

参数:

str - 一个字符串表达式。
regexp - 一个表示正则表达式的字符串。正则表达式字符串应为Java正则表达式。

示例：

> SELECT regexp_count('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');
 2
> SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
 8

自: 3.4.0

regexp_extract

regexp_extract(str, regexp[, idx]) - 从 str 中提取与 regexp 表达式匹配的第一个字符串，并对应于正则表达式组索引。

参数:

str - 一个字符串表达式。
regexp - 一个表示正则表达式的字符串。正则表达式字符串应该是Java正则表达式。

从Spark 2.0开始，字符串字面量（包括正则表达式模式）在我们的SQL解析器中不再进行转义。例如，要匹配"\abc"，正则表达式可以为regexp的"^\abc$"。

有一个SQL配置项'spark.sql.parser.escapedStringLiterals'可以用来回退到Spark 1.6关于字符串字面量解析的行为。例如，如果启用了该配置项，可以匹配"\abc"的regexp是"^\abc$"。
idx - 一个表示组索引的整数表达式。正则表达式可能包含多个组。idx指示要提取的正则表达式组。组索引应为非负数。idx的最小值是0，表示匹配整个正则表达式。如果未指定idx，默认的组索引值是1。idx参数是Java正则表达式Matcher group()方法的索引。

示例：

> SELECT regexp_extract('100-200', '(\\d+)-(\\d+)', 1);
 100

自: 1.5.0

regexp_extract_all

regexp_extract_all(str, regexp[, idx]) - 从 str 中提取所有匹配 regexp 表达式并对应于正则表达式组索引的字符串。

参数:

str - 一个字符串表达式。
regexp - 一个表示正则表达式的字符串。正则表达式字符串应该是Java正则表达式。

自Spark 2.0起，字符串字面量（包括正则表达式模式）在我们的SQL解析器中不再进行转义。例如，要匹配"\abc"，正则表达式可以为regexp的"^\abc$"。

有一个SQL配置项'spark.sql.parser.escapedStringLiterals'可以用来回退到Spark 1.6关于字符串字面量解析的行为。例如，如果启用了该配置，可以匹配"\abc"的regexp是"^\abc$"。
idx - 一个表示组索引的整数表达式。正则表达式可能包含多个组。idx指示要提取哪个正则表达式组。组索引应为非负数。idx的最小值是0，表示匹配整个正则表达式。如果未指定idx，默认的组索引值是1。idx参数是Java正则表达式Matcher group()方法的索引。

示例：

> SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)', 1);
 ["100","300"]

自: 3.1.0

regexp_instr

regexp_instr(str, regexp) - 搜索字符串中的正则表达式，并返回一个整数，该整数表示匹配子字符串的起始位置。位置是基于1的，而不是基于0的。如果没有找到匹配项，则返回0。

参数:

str - 一个字符串表达式。
regexp - 一个表示正则表达式的字符串。正则表达式字符串应该是Java正则表达式。

从Spark 2.0开始，字符串字面量（包括正则表达式模式）在我们的SQL解析器中不再进行转义。例如，要匹配"\abc"，正则表达式可以为regexp的"^\abc$"。

有一个SQL配置项'spark.sql.parser.escapedStringLiterals'可以用来回退到Spark 1.6关于字符串字面量解析的行为。例如，如果启用了该配置，可以匹配"\abc"的regexp是"^\abc$"。

示例：

> SELECT regexp_instr('user@spark.apache.org', '@[^.]*');
 5

自: 3.4.0

regexp_like

regexp_like(str, regexp) - 如果 str 匹配 regexp，则返回 true，否则返回 false。

参数:

str - 一个字符串表达式
regexp - 一个字符串表达式。正则表达式字符串应该是Java正则表达式。

自Spark 2.0以来，字符串字面量（包括正则表达式模式）在我们的SQL解析器中未被转义。例如，要匹配"\abc"，正则表达式可以为regexp设置为"^\abc$"。

有一个SQL配置项'spark.sql.parser.escapedStringLiterals'可以用来回退到Spark 1.6关于字符串字面量解析的行为。例如，如果启用了该配置，可以匹配"\abc"的regexp是"^\abc$"。

示例：

> SET spark.sql.parser.escapedStringLiterals=true;
spark.sql.parser.escapedStringLiterals  true
> SELECT regexp_like('%SystemDrive%\Users\John', '%SystemDrive%\\Users.*');
true
> SET spark.sql.parser.escapedStringLiterals=false;
spark.sql.parser.escapedStringLiterals  false
> SELECT regexp_like('%SystemDrive%\\Users\\John', '%SystemDrive%\\\\Users.*');
true

注意：

使用 LIKE 来匹配简单的字符串模式。

自: 3.2.0

regexp_replace

regexp_replace(str, regexp, rep[, position]) - 将 str 中与 regexp 匹配的所有子字符串替换为 rep。

参数:

str - 要搜索正则表达式模式匹配的字符串表达式。
regexp - 表示正则表达式的字符串。正则表达式字符串应为Java正则表达式。

自Spark 2.0起，字符串字面量（包括正则表达式模式）在我们的SQL解析器中不再进行转义。例如，要匹配"\abc"，正则表达式可以为"^\abc$"。

有一个SQL配置项'spark.sql.parser.escapedStringLiterals'可用于回退到Spark 1.6关于字符串字面量解析的行为。例如，如果启用了该配置，可以匹配"\abc"的正则表达式为"^\abc$"。
rep - 用于替换匹配子字符串的字符串表达式。
position - 一个正整数字面量，指示在str中开始搜索的位置。默认值为1。如果position大于str中的字符数，结果为str。

示例：

> SELECT regexp_replace('100-200', '(\\d+)', 'num');
 num-num

自: 1.5.0

regexp_substr

regexp_substr(str, regexp) - 返回字符串 str 中与正则表达式 regexp 匹配的子字符串。如果未找到正则表达式，则结果为 null。

参数:

str - 一个字符串表达式。
regexp - 一个表示正则表达式的字符串。正则表达式字符串应为Java正则表达式。

示例：

> SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');
 Steven
> SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Jeck');
 NULL

自: 3.4.0

regr_avgx

regr_avgx(y, x) - 返回组中非空对的自变量的平均值，其中 y 是因变量，x 是自变量。

示例：

> SELECT regr_avgx(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
 2.75
> SELECT regr_avgx(y, x) FROM VALUES (1, null) AS tab(y, x);
 NULL
> SELECT regr_avgx(y, x) FROM VALUES (null, 1) AS tab(y, x);
 NULL
> SELECT regr_avgx(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
 3.0
> SELECT regr_avgx(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
 3.0

自: 3.3.0

regr_avgy

regr_avgy(y, x) - 返回组中非空对的相关变量的平均值，其中 y 是相关变量，x 是独立变量。

示例：

> SELECT regr_avgy(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
 1.75
> SELECT regr_avgy(y, x) FROM VALUES (1, null) AS tab(y, x);
 NULL
> SELECT regr_avgy(y, x) FROM VALUES (null, 1) AS tab(y, x);
 NULL
> SELECT regr_avgy(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
 1.6666666666666667
> SELECT regr_avgy(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
 1.5

自: 3.3.0

regr_count

regr_count(y, x) - 返回组中非空数值对的数目，其中 y 是因变量，x 是自变量。

示例：

> SELECT regr_count(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
 4
> SELECT regr_count(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
 3
> SELECT regr_count(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
 2

自: 3.3.0

regr_intercept

regr_intercept(y, x) - 返回组中非空对的双变量线性回归线的截距，其中 y 是因变量，x 是自变量。

示例：

> SELECT regr_intercept(y, x) FROM VALUES (1,1), (2,2), (3,3) AS tab(y, x);
 0.0
> SELECT regr_intercept(y, x) FROM VALUES (1, null) AS tab(y, x);
 NULL
> SELECT regr_intercept(y, x) FROM VALUES (null, 1) AS tab(y, x);
 NULL

自: 3.4.0

regr_r2

regr_r2(y, x) - 返回组中非空对的确定系数，其中 y 是因变量，x 是自变量。

示例：

> SELECT regr_r2(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
 0.2727272727272727
> SELECT regr_r2(y, x) FROM VALUES (1, null) AS tab(y, x);
 NULL
> SELECT regr_r2(y, x) FROM VALUES (null, 1) AS tab(y, x);
 NULL
> SELECT regr_r2(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
 0.7500000000000001
> SELECT regr_r2(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
 1.0

自: 3.3.0

regr_slope

regr_slope(y, x) - 返回组中非空对线性回归线的斜率，其中y是因变量，x是自变量。

示例：

> SELECT regr_slope(y, x) FROM VALUES (1,1), (2,2), (3,3) AS tab(y, x);
 1.0
> SELECT regr_slope(y, x) FROM VALUES (1, null) AS tab(y, x);
 NULL
> SELECT regr_slope(y, x) FROM VALUES (null, 1) AS tab(y, x);
 NULL

自: 3.4.0

regr_sxx

regr_sxx(y, x) - 返回组中非空对的 REGR_COUNT(y, x) * VAR_POP(x)，其中 y 是因变量，x 是自变量。

示例：

> SELECT regr_sxx(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
 2.75
> SELECT regr_sxx(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
 2.0
> SELECT regr_sxx(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
 2.0

自: 3.4.0

regr_sxy

regr_sxy(y, x) - 返回组中非空对的 REGR_COUNT(y, x) * COVAR_POP(y, x)，其中 y 是因变量，x 是自变量。

示例：

> SELECT regr_sxy(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
 0.75
> SELECT regr_sxy(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
 1.0
> SELECT regr_sxy(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
 1.0

自: 3.4.0

regr_syy

regr_syy(y, x) - 返回组中非空对的 REGR_COUNT(y, x) * VAR_POP(y)，其中 y 是因变量，x 是自变量。

示例：

> SELECT regr_syy(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
 0.75
> SELECT regr_syy(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
 0.6666666666666666
> SELECT regr_syy(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
 0.5

自: 3.4.0

repeat

repeat(str, n) - 返回重复给定字符串值n次的字符串。

示例：

> SELECT repeat('123', 2);
 123123

自: 1.5.0

replace

replace(str, search[, replace]) - 将所有出现的search替换为replace。

参数:

str - 一个字符串表达式
search - 一个字符串表达式。如果 search 在 str 中找不到，str 将保持不变返回。
replace - 一个字符串表达式。如果未指定 replace 或为空字符串，则从 str 中移除的字符串将不会被替换。

示例：

> SELECT replace('ABCabc', 'abc', 'DEF');
 ABCDEF

自: 2.3.0

reverse

reverse(array) - 返回一个反转的字符串或数组，元素顺序反转。

示例：

> SELECT reverse('Spark SQL');
 LQS krapS
> SELECT reverse(array(2, 1, 4, 3));
 [3,4,1,2]

注意：

自2.4.0版本起，数组的逆向逻辑已可用。

自: 1.5.0

right

right(str, len) - 返回字符串 str 中最右边的 len(len 可以是字符串类型) 个字符，如果 len 小于或等于 0，则结果为空字符串。

示例：

> SELECT right('Spark SQL', 3);
 SQL

自: 2.3.0

rint

rint(expr) - 返回最接近参数值且等于数学整数的double值。

示例：

> SELECT rint(12.3456);
 12.0

自: 1.4.0

rlike

rlike(str, regexp) - 如果 str 匹配 regexp，则返回 true，否则返回 false。

参数:

str - 一个字符串表达式
regexp - 一个字符串表达式。正则表达式字符串应该是Java正则表达式。

自Spark 2.0以来，字符串字面量（包括正则表达式模式）在我们的SQL解析器中未被转义。例如，要匹配"\abc"，正则表达式可以为regexp设置为"^\abc$"。

有一个SQL配置项'spark.sql.parser.escapedStringLiterals'可以用来回退到Spark 1.6关于字符串字面量解析的行为。例如，如果启用了该配置，可以匹配"\abc"的regexp是"^\abc$"。

示例：

> SET spark.sql.parser.escapedStringLiterals=true;
spark.sql.parser.escapedStringLiterals  true
> SELECT rlike('%SystemDrive%\Users\John', '%SystemDrive%\\Users.*');
true
> SET spark.sql.parser.escapedStringLiterals=false;
spark.sql.parser.escapedStringLiterals  false
> SELECT rlike('%SystemDrive%\\Users\\John', '%SystemDrive%\\\\Users.*');
true

注意：

使用 LIKE 来匹配简单的字符串模式。

自: 1.0.0

round

round(expr, d) - 返回 expr 使用 HALF_UP 舍入模式四舍五入到 d 个小数位。

示例：

> SELECT round(2.5, 0);
 3

自: 1.5.0

row_number

row_number() - 为每个行分配一个唯一的、顺序的数字，从一开始，根据窗口分区内的行顺序。

示例：

> SELECT a, b, row_number() OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
 A1 1   1
 A1 1   2
 A1 2   3
 A2 3   1

自: 2.0.0

rpad

rpad(str, len[, pad]) - 返回 str，右侧填充 pad 到长度为 len。如果 str 比 len 长，返回值将被截断为 len 个字符。如果未指定 pad，str 将被右侧填充空格字符（如果是字符串），或者填充零（如果是二进制字符串）。

示例：

> SELECT rpad('hi', 5, '??');
 hi???
> SELECT rpad('hi', 1, '??');
 h
> SELECT rpad('hi', 5);
 hi
> SELECT hex(rpad(unhex('aabb'), 5));
 AABB000000
> SELECT hex(rpad(unhex('aabb'), 5, unhex('1122')));
 AABB112211

自: 1.5.0

rtrim

rtrim(str) - 从str中移除尾随的空格字符。

参数:

str - 一个字符串表达式
trimStr - 要修剪的修剪字符串字符，默认值是一个空格

示例：

> SELECT rtrim('    SparkSQL   ');
 SparkSQL

自: 1.5.0

schema_of_csv

schema_of_csv(csv[, options]) - 返回CSV字符串的DDL格式模式。

示例：

> SELECT schema_of_csv('1,abc');
 STRUCT<_c0: INT, _c1: STRING>

自: 3.0.0

schema_of_json

schema_of_json(json[, options]) - 返回JSON字符串的DDL格式模式。

示例：

> SELECT schema_of_json('[{"col":0}]');
 ARRAY<STRUCT<col: BIGINT>>
> SELECT schema_of_json('[{"col":01}]', map('allowNumericLeadingZeros', 'true'));
 ARRAY<STRUCT<col: BIGINT>>

自: 2.4.0

sec

sec(expr) - 返回 expr 的正割，如同通过 1/java.lang.Math.cos 计算的那样。

参数:

expr - 角度（弧度制）

示例：

> SELECT sec(0);
 1.0

自: 3.3.0

second

second(timestamp) - 返回字符串/时间戳的秒部分。

示例：

> SELECT second('2009-07-30 12:58:59');
 59

自: 1.5.0

sentences

sentences(str[, lang, country]) - 将 str 分割成一个单词数组的数组。

示例：

> SELECT sentences('Hi there! Good morning.');
 [["Hi","there"],["Good","morning"]]

自: 2.0.0

sequence

sequence(start, stop, step) - 生成从 start 到 stop（包含）的元素数组，增量为 step。返回元素的类型与参数表达式的类型相同。

支持的类型有：字节、短整型、整型、长整型、日期、时间戳。

开始和结束表达式必须解析为相同类型。如果开始和结束表达式解析为'date'或'timestamp'类型那么步长表达式必须解析为'interval'或'year-month interval'或 'day-time interval'类型，否则解析为与开始和结束表达式相同的类型。

参数:

start - 一个表达式。范围的起始值。
stop - 一个表达式。范围的结束值（包含）。
step - 一个可选的表达式。范围的步长。默认情况下，如果 start 小于或等于 stop，则 step 为 1，否则为 -1。对于时间序列，分别为 1 天和 -1 天。如果 start 大于 stop，则 step 必须为负数，反之亦然。

示例：

> SELECT sequence(1, 5);
 [1,2,3,4,5]
> SELECT sequence(5, 1);
 [5,4,3,2,1]
> SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month);
 [2018-01-01,2018-02-01,2018-03-01]
> SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval '0-1' year to month);
 [2018-01-01,2018-02-01,2018-03-01]

自: 2.4.0

session_window

session_window(time_column, gap_duration) - 给定时间戳指定列和间隙持续时间，生成会话窗口。请参阅结构化流指南文档中的'时间窗口类型'，以获取详细解释和示例。

参数:

time_column - 用于按时间进行窗口化的列或表达式。时间列必须是TimestampType类型。
gap_duration - 一个字符串，指定会话的超时时间，表示为“间隔值”（有关更多详细信息，请参阅间隔字面量），用于固定间隔持续时间，或一个应用于每个输入并评估为“间隔值”的表达式，用于动态间隔持续时间。

示例：

> SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, session_window(b, '5 minutes') ORDER BY a, start;
  A1    2021-01-01 00:00:00 2021-01-01 00:09:30 2
  A1    2021-01-01 00:10:00 2021-01-01 00:15:00 1
  A2    2021-01-01 00:01:00 2021-01-01 00:06:00 1
> SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00'), ('A2', '2021-01-01 00:04:30') AS tab(a, b) GROUP by a, session_window(b, CASE WHEN a = 'A1' THEN '5 minutes' WHEN a = 'A2' THEN '1 minute' ELSE '10 minutes' END) ORDER BY a, start;
  A1    2021-01-01 00:00:00 2021-01-01 00:09:30 2
  A1    2021-01-01 00:10:00 2021-01-01 00:15:00 1
  A2    2021-01-01 00:01:00 2021-01-01 00:02:00 1
  A2    2021-01-01 00:04:30 2021-01-01 00:05:30 1

自: 3.2.0

sha

sha(expr) - 返回一个作为十六进制字符串的sha1哈希值。

示例：

> SELECT sha('Spark');
 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c

自: 1.5.0

sha1

sha1(expr) - 返回一个作为十六进制字符串的sha1哈希值。

示例：

> SELECT sha1('Spark');
 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c

自: 1.5.0

sha2

sha2(expr, bitLength) - 返回SHA-2系列的校验和作为expr的十六进制字符串。支持SHA-224、SHA-256、SHA-384和SHA-512。位长度为0等同于256。

示例：

> SELECT sha2('Spark', 256);
 529bc3b07127ecb7e53a4dcf1991d9152c24537d919178022b2c42657f79a26b

自: 1.5.0

shiftleft

shiftleft(base, expr) - 按位左移。

示例：

> SELECT shiftleft(2, 1);
 4

自: 1.5.0

shiftright

shiftright(base, expr) - 按位（有符号）右移。

示例：

> SELECT shiftright(4, 1);
 2

自: 1.5.0

shiftrightunsigned

shiftrightunsigned(base, expr) - 按位无符号右移。

示例：

> SELECT shiftrightunsigned(4, 1);
 2

自: 1.5.0

shuffle

shuffle(array) - 返回给定数组的随机排列。

示例：

> SELECT shuffle(array(1, 20, 3, 5));
 [3,1,5,20]
> SELECT shuffle(array(1, 20, null, 3));
 [20,null,3,1]

注意：

该函数是非确定性的。

自: 2.4.0

sign

sign(expr) - 返回 -1.0、0.0 或 1.0，表示 expr 为负数、0 或正数。

示例：

> SELECT sign(40);
 1.0
> SELECT sign(INTERVAL -'100' YEAR);
 -1.0

自: 1.4.0

signum

signum(expr) - 返回 -1.0、0.0 或 1.0，表示 expr 为负数、0 或正数。

示例：

> SELECT signum(40);
 1.0
> SELECT signum(INTERVAL -'100' YEAR);
 -1.0

自: 1.4.0

sin

sin(expr) - 返回 expr 的正弦值，如同由 java.lang.Math.sin 计算的那样。

参数:

expr - 角度（弧度制）

示例：

> SELECT sin(0);
 0.0

自: 1.4.0

sinh

sinh(expr) - 返回expr的双曲正弦值，如同通过java.lang.Math.sinh计算的那样。

参数:

expr - 双曲角

示例：

> SELECT sinh(0);
 0.0

自: 1.4.0

size

size(expr) - 返回数组或映射的大小。如果 spark.sql.legacy.sizeOfNull 设置为 false 或 spark.sql.ansi.enabled 设置为 true，则对于 null 输入，函数返回 null。否则，对于 null 输入，函数返回 -1。在默认设置下，函数对于 null 输入返回 -1。

示例：

> SELECT size(array('b', 'd', 'c', 'a'));
 4
> SELECT size(map('a', 1, 'b', 2));
 2

自: 1.5.0

skewness

skewness(expr) - 返回从一组值计算出的偏度值。

示例：

> SELECT skewness(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
 1.1135657469022011
> SELECT skewness(col) FROM VALUES (-1000), (-100), (10), (20) AS tab(col);
 -1.1135657469022011

自: 1.6.0

slice

slice(x, start, length) - 从索引 start 开始（数组索引从 1 开始，如果 start 为负数则从末尾开始）对数组 x 进行子集操作，指定长度。

示例：

> SELECT slice(array(1, 2, 3, 4), 2, 2);
 [2,3]
> SELECT slice(array(1, 2, 3, 4), -2, 2);
 [3,4]

自: 2.4.0

smallint

smallint(expr) - 将值 expr 转换为目标数据类型 smallint。

自: 2.0.1

some

some(expr) - 如果expr中至少有一个值为真，则返回真。

示例：

> SELECT some(col) FROM VALUES (true), (false), (false) AS tab(col);
 true
> SELECT some(col) FROM VALUES (NULL), (true), (false) AS tab(col);
 true
> SELECT some(col) FROM VALUES (false), (false), (NULL) AS tab(col);
 false

自: 3.0.0

sort_array

sort_array(array[, ascendingOrder]) - 根据数组元素的自然顺序对输入数组进行升序或降序排序。对于double/float类型，NaN大于任何非NaN元素。Null元素将在升序时放置在返回数组的开头，或在降序时放置在返回数组的末尾。

示例：

> SELECT sort_array(array('b', 'd', null, 'c', 'a'), true);
 [null,"a","b","c","d"]

自: 1.5.0

soundex

soundex(str) - 返回字符串的Soundex代码。

示例：

> SELECT soundex('Miller');
 M460

自: 1.5.0

space

space(n) - 返回一个由n个空格组成的字符串。

示例：

> SELECT concat(space(2), '1');
   1

自: 1.5.0

spark_partition_id

spark_partition_id() - 返回当前分区ID。

示例：

> SELECT spark_partition_id();
 0

自: 1.4.0

split

split(str, regex, limit) - 将 str 按照匹配 regex 的出现位置进行分割，并返回一个长度最多为 limit 的数组

参数:

str - 要分割的字符串表达式。
regex - 表示正则表达式的字符串。regex 字符串应该是 Java 正则表达式。
limit - 控制正则表达式应用次数的整数表达式。
- limit > 0: 结果数组的长度不会超过 limit，并且结果数组的最后一个条目将包含所有超出最后一个匹配正则表达式的输入。
- limit <= 0: regex 将被尽可能多次地应用，并且结果数组可以是任意大小。

示例：

> SELECT split('oneAtwoBthreeC', '[ABC]');
 ["one","two","three",""]
> SELECT split('oneAtwoBthreeC', '[ABC]', -1);
 ["one","two","three",""]
> SELECT split('oneAtwoBthreeC', '[ABC]', 2);
 ["one","twoBthreeC"]

自: 1.5.0

split_part

split_part(str, delimiter, partNum) - 通过分隔符分割str并返回请求的部分（从1开始）。如果任何输入为null，则返回null。如果partNum超出分割部分的范围，则返回空字符串。如果partNum为0，则抛出错误。如果partNum为负数，则从字符串末尾开始反向计数。如果delimiter为空字符串，则str不会被分割。

示例：

> SELECT split_part('11.12.13', '.', 3);
 13

自: 3.3.0

sqrt

sqrt(expr) - 返回 expr 的平方根。

示例：

> SELECT sqrt(4);
 2.0

自: 1.1.1

stack

stack(n, expr1, ..., exprk) - 将 expr1, ..., exprk 分隔成 n 行。默认使用列名 col0, col1 等，除非另有指定。

示例：

> SELECT stack(2, 1, 2, 3);
 1  2
 3  NULL

自: 2.0.0

startswith

startswith(left, right) - 返回一个布尔值。如果左边的值以右边的值开头，则返回True。如果任一输入表达式为NULL，则返回NULL。否则，返回False。左或右都必须为STRING或BINARY类型。

示例：

> SELECT startswith('Spark SQL', 'Spark');
 true
> SELECT startswith('Spark SQL', 'SQL');
 false
> SELECT startswith('Spark SQL', null);
 NULL
> SELECT startswith(x'537061726b2053514c', x'537061726b');
 true
> SELECT startswith(x'537061726b2053514c', x'53514c');
 false

自: 3.3.0

std

std(expr) - 返回根据一组值计算的样本标准差。

示例：

> SELECT std(col) FROM VALUES (1), (2), (3) AS tab(col);
 1.0

自: 1.6.0

stddev

stddev(expr) - 返回从一组值计算出的样本标准差。

示例：

> SELECT stddev(col) FROM VALUES (1), (2), (3) AS tab(col);
 1.0

自: 1.6.0

stddev_pop

stddev_pop(expr) - 返回从一组值计算得出的总体标准差。

示例：

> SELECT stddev_pop(col) FROM VALUES (1), (2), (3) AS tab(col);
 0.816496580927726

自: 1.6.0

stddev_samp

stddev_samp(expr) - 返回根据一组值计算的样本标准差。

示例：

> SELECT stddev_samp(col) FROM VALUES (1), (2), (3) AS tab(col);
 1.0

自: 1.6.0

str_to_map

str_to_map(text[, pairDelim[, keyValueDelim]]) - 使用分隔符将文本拆分为键/值对后创建一个映射。默认分隔符是 ',' 用于 pairDelim 和 ':' 用于 keyValueDelim。pairDelim 和 keyValueDelim 都被视为正则表达式。

示例：

> SELECT str_to_map('a:1,b:2,c:3', ',', ':');
 {"a":"1","b":"2","c":"3"}
> SELECT str_to_map('a');
 {"a":null}

自: 2.0.1

string

string(expr) - 将值 expr 转换为目标数据类型 string。

自: 2.0.1

struct

struct(col1, col2, col3, ...) - 使用给定的字段值创建一个结构。

示例：

> SELECT struct(1, 2, 3);
 {"col1":1,"col2":2,"col3":3}

自: 1.4.0

substr

substr(str, pos[, len]) - 返回从pos开始且长度为len的str的子字符串，或从pos开始且长度为len的字节数组的切片。

substr(str FROM pos[ FOR len]]) - 返回从pos开始且长度为len的str的子字符串，或从pos开始且长度为len的字节数组切片。

示例：

> SELECT substr('Spark SQL', 5);
 k SQL
> SELECT substr('Spark SQL', -3);
 SQL
> SELECT substr('Spark SQL', 5, 1);
 k
> SELECT substr('Spark SQL' FROM 5);
 k SQL
> SELECT substr('Spark SQL' FROM -3);
 SQL
> SELECT substr('Spark SQL' FROM 5 FOR 1);
 k
> SELECT substr(encode('Spark SQL', 'utf-8'), 5);
 k SQL

自: 1.5.0

substring

substring(str, pos[, len]) - 返回从pos开始且长度为len的str的子字符串，或从pos开始且长度为len的字节数组的切片。

substring(str FROM pos[ FOR len]]) - 返回从pos开始且长度为len的str的子字符串，或从pos开始且长度为len的字节数组切片。

示例：

> SELECT substring('Spark SQL', 5);
 k SQL
> SELECT substring('Spark SQL', -3);
 SQL
> SELECT substring('Spark SQL', 5, 1);
 k
> SELECT substring('Spark SQL' FROM 5);
 k SQL
> SELECT substring('Spark SQL' FROM -3);
 SQL
> SELECT substring('Spark SQL' FROM 5 FOR 1);
 k
> SELECT substring(encode('Spark SQL', 'utf-8'), 5);
 k SQL

自: 1.5.0

substring_index

substring_index(str, delim, count) - 返回从str中在分隔符delim出现count次之前的子字符串。如果count为正数，则返回从左边数起最后一个分隔符左边的所有内容。如果count为负数，则返回从右边数起最后一个分隔符右边的所有内容。函数substring_index在搜索delim时执行区分大小写的匹配。

示例：

> SELECT substring_index('www.apache.org', '.', 2);
 www.apache

自: 1.5.0

sum

sum(expr) - 返回从一组值计算出的总和。

示例：

> SELECT sum(col) FROM VALUES (5), (10), (15) AS tab(col);
 30
> SELECT sum(col) FROM VALUES (NULL), (10), (15) AS tab(col);
 25
> SELECT sum(col) FROM VALUES (NULL), (NULL) AS tab(col);
 NULL

自: 1.0.0

tan

tan(expr) - 返回 expr 的正切值，如同由 java.lang.Math.tan 计算的那样。

参数:

expr - 角度（弧度制）

示例：

> SELECT tan(0);
 0.0

自: 1.4.0

tanh

tanh(expr) - 返回expr的双曲正切值，如同由java.lang.Math.tanh计算的那样。

参数:

expr - 双曲角

示例：

> SELECT tanh(0);
 0.0

自: 1.4.0

timestamp

timestamp(expr) - 将值 expr 转换为目标数据类型 timestamp。

自: 2.0.1

timestamp_micros

timestamp_micros(microseconds) - 从自UTC纪元以来的微秒数创建时间戳。

示例：

> SELECT timestamp_micros(1230219000123123);
 2008-12-25 07:30:00.123123

自: 3.1.0

timestamp_millis

timestamp_millis(milliseconds) - 从自UTC纪元以来的毫秒数创建时间戳。

示例：

> SELECT timestamp_millis(1230219000123);
 2008-12-25 07:30:00.123

自: 3.1.0

timestamp_seconds

timestamp_seconds(seconds) - 从自UTC纪元以来的秒数（可以是分数）创建时间戳。

示例：

> SELECT timestamp_seconds(1230219000);
 2008-12-25 07:30:00
> SELECT timestamp_seconds(1230219000.123);
 2008-12-25 07:30:00.123

自: 3.1.0

tinyint

tinyint(expr) - 将值 expr 转换为目标数据类型 tinyint。

自: 2.0.1

to_binary

to_binary(str[, fmt]) - 将输入的 str 根据提供的 fmt 转换为二进制值。 fmt 可以是 "hex"、"utf-8"、"utf8" 或 "base64" 的不区分大小写的字符串字面量。如果省略 fmt，默认的转换二进制格式为 "hex"。如果至少有一个输入参数为 NULL，函数返回 NULL。

示例：

> SELECT to_binary('abc', 'utf-8');
 abc

自: 3.3.0

to_char

to_char(numberExpr, formatExpr) - 将 numberExpr 根据 formatExpr 转换为字符串。如果转换失败，则抛出异常。格式可以由以下字符组成，不区分大小写： '0' 或 '9'：指定 0 到 9 之间的预期数字。格式字符串中的 0 或 9 序列匹配输入值中的数字序列，生成与格式字符串中相应序列长度相同的结果字符串。如果 0/9 序列包含的数字多于匹配的小数值部分，则结果字符串以 0 开头并在小数点之前，左侧填充零。否则，它将填充空格。 '.' 或 'D'：指定小数点的位置（可选，仅允许一次）。 ',' 或 'G'：指定分组（千位）分隔符（,）的位置。每个分组分隔符的左右两侧必须有一个 0 或 9。 '$'：指定 $ 货币符号的位置。此字符只能指定一次。 'S' 或 'MI'：指定 '-' 或 '+' 符号的位置（可选，只能在格式字符串的开头或结尾指定一次）。请注意，'S' 对正值打印 '+'，但 'MI' 打印空格。 'PR'：只能在格式字符串的末尾指定；指定如果输入值为负数，则结果字符串将被尖括号包围。 ('<1>')。

示例：

> SELECT to_char(454, '999');
 454
> SELECT to_char(454.00, '000D00');
 454.00
> SELECT to_char(12454, '99G999');
 12,454
> SELECT to_char(78.12, '$99.99');
 $78.12
> SELECT to_char(-12454.8, '99G999D9S');
 12,454.8-

自: 3.4.0

to_csv

to_csv(expr[, options]) - 返回一个包含给定结构值的CSV字符串

示例：

> SELECT to_csv(named_struct('a', 1, 'b', 2));
 1,2
> SELECT to_csv(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
 26/08/2015

自: 3.0.0

to_date

to_date(date_str[, fmt]) - 将 date_str 表达式与 fmt 表达式解析为日期。对于无效输入返回 null。默认情况下，如果省略 fmt，它遵循转换为日期的规则。

参数:

date_str - 要解析为日期的字符串。
fmt - 要遵循的日期格式模式。请参阅日期时间模式以获取有效的日期和时间格式模式。

示例：

> SELECT to_date('2009-07-30 04:17:52');
 2009-07-30
> SELECT to_date('2016-12-31', 'yyyy-MM-dd');
 2016-12-31

自: 1.5.0

to_json

to_json(expr[, options]) - 返回一个给定结构值的JSON字符串

示例：

> SELECT to_json(named_struct('a', 1, 'b', 2));
 {"a":1,"b":2}
> SELECT to_json(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
 {"time":"26/08/2015"}
> SELECT to_json(array(named_struct('a', 1, 'b', 2)));
 [{"a":1,"b":2}]
> SELECT to_json(map('a', named_struct('b', 1)));
 {"a":{"b":1}}
> SELECT to_json(map(named_struct('a', 1),named_struct('b', 2)));
 {"[1]":{"b":2}}
> SELECT to_json(map('a', 1));
 {"a":1}
> SELECT to_json(array(map('a', 1)));
 [{"a":1}]

自: 2.2.0

to_number

to_number(expr, fmt) - 将字符串 'expr' 基于字符串格式 'fmt' 转换为数字。如果转换失败，则抛出异常。格式可以由以下字符组成，不区分大小写： '0' 或 '9'：指定 0 到 9 之间的预期数字。格式字符串中的 0 或 9 序列匹配输入字符串中的数字序列。如果 0/9 序列以 0 开头并且在小数点之前，它只能匹配相同大小的数字序列。否则，如果序列以 9 开头或在小数点之后，它可以匹配相同或更小大小的数字序列。 '.' 或 'D'：指定小数点的位置（可选，仅允许一次）。 ',' 或 'G'：指定分组（千位）分隔符 (,) 的位置。每个分组分隔符的左右必须有 0 或 9。'expr' 必须匹配与数字大小相关的分组分隔符。 '$'：指定 $ 货币符号的位置。此字符只能指定一次。 'S' 或 'MI'：指定 '-' 或 '+' 符号的位置（可选，只能在格式字符串的开头或结尾指定一次）。请注意，'S' 允许 '-' 但 'MI' 不允许。 'PR'：只能在格式字符串的末尾指定；指定 'expr' 以带角括号的负数表示（例如 '<1>'）。

示例：

> SELECT to_number('454', '999');
 454
> SELECT to_number('454.00', '000.00');
 454.00
> SELECT to_number('12,454', '99,999');
 12454
> SELECT to_number('$78.12', '$99.99');
 78.12
> SELECT to_number('12,454.8-', '99,999.9S');
 -12454.8

自: 3.3.0

to_timestamp

to_timestamp(timestamp_str[, fmt]) - 使用 fmt 表达式解析 timestamp_str 表达式为时间戳。对于无效输入返回 null。默认情况下，如果省略 fmt，它遵循转换为时间戳的规则。结果数据类型与配置 spark.sql.timestampType 的值一致。

参数:

timestamp_str - 要解析为时间戳的字符串。
fmt - 遵循的时间戳格式模式。有关有效的日期和时间格式模式，请参阅日期时间模式。

示例：

> SELECT to_timestamp('2016-12-31 00:12:00');
 2016-12-31 00:12:00
> SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd');
 2016-12-31 00:00:00

自: 2.2.0

to_timestamp_ltz

to_timestamp_ltz(timestamp_str[, fmt]) - 将 timestamp_str 表达式与 fmt 表达式解析为带本地时区的时间戳。对于无效输入返回 null。默认情况下，如果省略 fmt，它遵循转换为时间戳的规则。

参数:

timestamp_str - 一个要解析为带本地时区的时间戳的字符串。
fmt - 遵循的时间戳格式模式。请参阅日期时间模式以获取有效的日期和时间格式模式。

示例：

> SELECT to_timestamp_ltz('2016-12-31 00:12:00');
 2016-12-31 00:12:00
> SELECT to_timestamp_ltz('2016-12-31', 'yyyy-MM-dd');
 2016-12-31 00:00:00

自: 3.4.0

to_timestamp_ntz

to_timestamp_ntz(timestamp_str[, fmt]) - 将 timestamp_str 表达式与 fmt 表达式解析为不带时区的时间戳。对于无效输入返回 null。默认情况下，如果省略 fmt，它遵循转换为时间戳的规则。

参数:

timestamp_str - 一个要解析为不带时区的时间戳的字符串。
fmt - 遵循的时间戳格式模式。请参阅日期时间模式以获取有效的日期和时间格式模式。

示例：

> SELECT to_timestamp_ntz('2016-12-31 00:12:00');
 2016-12-31 00:12:00
> SELECT to_timestamp_ntz('2016-12-31', 'yyyy-MM-dd');
 2016-12-31 00:00:00

自: 3.4.0

to_unix_timestamp

to_unix_timestamp(timeExp[, fmt]) - 返回给定时间的UNIX时间戳。

参数:

timeExp - 一个日期/时间戳或字符串，返回为UNIX时间戳。
fmt - 遵循的日期/时间格式模式。如果timeExp不是字符串，则忽略。默认值是"yyyy-MM-dd HH:mm:ss"。有关有效的日期和时间格式模式，请参见日期时间模式。

示例：

> SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd');
 1460098800

自: 1.6.0

to_utc_timestamp

to_utc_timestamp(timestamp, timezone) - 给定一个时间戳，如 '2017-07-14 02:40:00.0'，将其解释为给定时区中的时间，并以UTC时间戳的形式呈现该时间。例如，'GMT+1' 将产生 '2017-07-14 01:40:00.0'。

示例：

> SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul');
 2016-08-30 15:00:00

自: 1.5.0

to_varchar

to_varchar(numberExpr, formatExpr) - 将 numberExpr 根据 formatExpr 转换为字符串。如果转换失败，将抛出异常。格式可以由以下字符组成，不区分大小写： '0' 或 '9'：指定 0 到 9 之间的预期数字。格式字符串中的 0 或 9 序列匹配输入值中的数字序列，生成与格式字符串中相应序列长度相同的结果字符串。如果 0/9 序列包含的数字多于匹配的小数值部分，则结果字符串以 0 开头并在小数点之前，用零左填充。否则，用空格填充。 '.' 或 'D'：指定小数点的位置（可选，仅允许一次）。 ',' 或 'G'：指定分组（千位）分隔符（,）的位置。每个分组分隔符的左右两侧必须有一个 0 或 9。 '$'：指定 $ 货币符号的位置。此字符只能指定一次。 'S' 或 'MI'：指定 '-' 或 '+' 符号的位置（可选，只能在格式字符串的开头或结尾指定一次）。请注意，'S' 对正数值打印 '+'，但 'MI' 打印空格。 'PR'：只能在格式字符串的末尾指定；指定如果输入值为负数，则结果字符串将被尖括号包围。 ('<1>')。

示例：

> SELECT to_varchar(454, '999');
 454
> SELECT to_varchar(454.00, '000D00');
 454.00
> SELECT to_varchar(12454, '99G999');
 12,454
> SELECT to_varchar(78.12, '$99.99');
 $78.12
> SELECT to_varchar(-12454.8, '99G999D9S');
 12,454.8-

自: 3.5.0

transform

transform(expr, func) - 使用函数转换数组中的元素。

示例：

> SELECT transform(array(1, 2, 3), x -> x + 1);
 [2,3,4]
> SELECT transform(array(1, 2, 3), (x, i) -> x + i);
 [1,3,5]

自: 2.4.0

transform_keys

transform_keys(expr, func) - 使用函数转换映射中的元素。

示例：

> SELECT transform_keys(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), (k, v) -> k + 1);
 {2:1,3:2,4:3}
> SELECT transform_keys(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), (k, v) -> k + v);
 {2:1,4:2,6:3}

自: 3.0.0

transform_values

transform_values(expr, func) - 使用函数转换映射中的值。

示例：

> SELECT transform_values(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), (k, v) -> v + 1);
 {1:2,2:3,3:4}
> SELECT transform_values(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), (k, v) -> k + v);
 {1:2,2:4,3:6}

自: 3.0.0

translate

translate(input, from, to) - 通过将input字符串中出现在from字符串中的字符替换为to字符串中对应的字符来翻译该字符串。

示例：

> SELECT translate('AaBbCc', 'abc', '123');
 A1B2C3

自: 1.5.0

trim

trim(str) - 移除str的前导和尾随空格字符。

trim(BOTH FROM str) - 从str中移除前导和尾随的空格字符。

trim(LEADING FROM str) - 从str中移除前导空格字符。

trim(TRAILING FROM str) - 从str中移除尾随的空格字符。

trim(trimStr FROM str) - 从str中移除前导和尾随的trimStr字符。

trim(BOTH trimStr FROM str) - 从str中移除前导和尾随的trimStr字符。

trim(LEADING trimStr FROM str) - 从str中移除前导的trimStr字符。

trim(TRAILING trimStr FROM str) - 从str中移除尾随的trimStr字符。

参数:

str - 一个字符串表达式
trimStr - 要修剪的字符串字符，默认值是一个空格
BOTH, FROM - 这些是关键字，用于指定从字符串的两端修剪字符串字符
LEADING, FROM - 这些是关键字，用于指定从字符串的左端修剪字符串字符
TRAILING, FROM - 这些是关键字，用于指定从字符串的右端修剪字符串字符

示例：

> SELECT trim('    SparkSQL   ');
 SparkSQL
> SELECT trim(BOTH FROM '    SparkSQL   ');
 SparkSQL
> SELECT trim(LEADING FROM '    SparkSQL   ');
 SparkSQL
> SELECT trim(TRAILING FROM '    SparkSQL   ');
     SparkSQL
> SELECT trim('SL' FROM 'SSparkSQLS');
 parkSQ
> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');
 parkSQ
> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');
 parkSQLS
> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');
 SSparkSQ

自: 1.5.0

trunc

trunc(date, fmt) - 返回date，其中日期的时间部分被截断为格式模型fmt指定的单位。

参数:

date - 日期值或有效的日期字符串
fmt - 表示要截断到的单位的格式
- "YEAR", "YYYY", "YY" - 截断到date所在年份的第一天
- "QUARTER" - 截断到date所在季度的第一天
- "MONTH", "MM", "MON" - 截断到date所在月份的第一天
- "WEEK" - 截断到date所在周的星期一

示例：

> SELECT trunc('2019-08-04', 'week');
 2019-07-29
> SELECT trunc('2019-08-04', 'quarter');
 2019-07-01
> SELECT trunc('2009-02-12', 'MM');
 2009-02-01
> SELECT trunc('2015-10-27', 'YEAR');
 2015-01-01

自: 1.5.0

try_add

try_add(expr1, expr2) - 返回 expr1 和 expr2 的和，如果溢出则结果为 null。可接受的输入类型与 + 运算符相同。

示例：

> SELECT try_add(1, 2);
 3
> SELECT try_add(2147483647, 1);
 NULL
> SELECT try_add(date'2021-01-01', 1);
 2021-01-02
> SELECT try_add(date'2021-01-01', interval 1 year);
 2022-01-01
> SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day);
 2021-01-02 00:00:00
> SELECT try_add(interval 1 year, interval 2 year);
 3-0

自: 3.2.0

try_aes_decrypt

try_aes_decrypt(expr, key[, mode[, padding[, aad]]]) - 这是aes_decrypt的一个特殊版本，执行相同的操作，但如果解密无法执行，则返回NULL值而不是引发错误。

示例：

> SELECT try_aes_decrypt(unhex('6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210'), '0000111122223333', 'GCM');
 Spark SQL
> SELECT try_aes_decrypt(unhex('----------468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210'), '0000111122223333', 'GCM');
 NULL

自: 3.5.0

try_avg

try_avg(expr) - 返回从一组值计算出的平均值，结果在溢出时为空。

示例：

> SELECT try_avg(col) FROM VALUES (1), (2), (3) AS tab(col);
 2.0
> SELECT try_avg(col) FROM VALUES (1), (2), (NULL) AS tab(col);
 1.5
> SELECT try_avg(col) FROM VALUES (interval '2147483647 months'), (interval '1 months') AS tab(col);
 NULL

自: 3.3.0

try_divide

try_divide(dividend, divisor) - 返回 dividend/divisor。它总是执行浮点数除法。如果 expr2 为 0，其结果总是为空。dividend 必须是一个数值或一个区间。divisor 必须是一个数值。

示例：

> SELECT try_divide(3, 2);
 1.5
> SELECT try_divide(2L, 2L);
 1.0
> SELECT try_divide(1, 0);
 NULL
> SELECT try_divide(interval 2 month, 2);
 0-1
> SELECT try_divide(interval 2 month, 0);
 NULL

自: 3.2.0

try_element_at

try_element_at(array, index) - 返回数组中给定（基于1）索引位置的元素。如果索引为0， Spark将抛出错误。如果索引小于0，则从最后一个元素开始访问。如果索引超出数组长度，该函数始终返回NULL。

try_element_at(map, key) - 返回给定键的值。如果键不包含在映射中，该函数总是返回NULL。

示例：

> SELECT try_element_at(array(1, 2, 3), 2);
 2
> SELECT try_element_at(map(1, 'a', 2, 'b'), 2);
 b

自: 3.3.0

try_multiply

try_multiply(expr1, expr2) - 返回 expr1*expr2，如果溢出则结果为空。可接受的输入类型与 * 运算符相同。

示例：

> SELECT try_multiply(2, 3);
 6
> SELECT try_multiply(-2147483648, 10);
 NULL
> SELECT try_multiply(interval 2 year, 3);
 6-0

自: 3.3.0

try_subtract

try_subtract(expr1, expr2) - 返回 expr1-expr2，如果溢出则结果为空。可接受的输入类型与 - 运算符相同。

示例：

> SELECT try_subtract(2, 1);
 1
> SELECT try_subtract(-2147483648, 1);
 NULL
> SELECT try_subtract(date'2021-01-02', 1);
 2021-01-01
> SELECT try_subtract(date'2021-01-01', interval 1 year);
 2020-01-01
> SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day);
 2021-01-01 00:00:00
> SELECT try_subtract(interval 2 year, interval 1 year);
 1-0

自: 3.3.0

try_sum

try_sum(expr) - 返回从一组值计算出的总和，并在溢出时返回null。

示例：

> SELECT try_sum(col) FROM VALUES (5), (10), (15) AS tab(col);
 30
> SELECT try_sum(col) FROM VALUES (NULL), (10), (15) AS tab(col);
 25
> SELECT try_sum(col) FROM VALUES (NULL), (NULL) AS tab(col);
 NULL
> SELECT try_sum(col) FROM VALUES (9223372036854775807L), (1L) AS tab(col);
 NULL

自: 3.3.0

try_to_binary

try_to_binary(str[, fmt]) - 这是 to_binary 的一个特殊版本，执行相同的操作，但如果转换无法执行，则返回 NULL 值而不是引发错误。

示例：

> SELECT try_to_binary('abc', 'utf-8');
 abc
> select try_to_binary('a!', 'base64');
 NULL
> select try_to_binary('abc', 'invalidFormat');
 NULL

自: 3.3.0

try_to_number

try_to_number(expr, fmt) - 将字符串 'expr' 基于字符串格式 fmt 转换为数字。如果字符串 'expr' 不符合预期的格式，则返回 NULL。格式遵循与 to_number 函数相同的语义。

示例：

> SELECT try_to_number('454', '999');
 454
> SELECT try_to_number('454.00', '000.00');
 454.00
> SELECT try_to_number('12,454', '99,999');
 12454
> SELECT try_to_number('$78.12', '$99.99');
 78.12
> SELECT try_to_number('12,454.8-', '99,999.9S');
 -12454.8

自: 3.3.0

try_to_timestamp

try_to_timestamp(timestamp_str[, fmt]) - 将 timestamp_str 表达式与 fmt 表达式解析为时间戳。无论是否启用了ANSI SQL模式，该函数在输入无效时总是返回null。默认情况下，如果省略了 fmt，它遵循转换为时间戳的规则。结果数据类型与配置 spark.sql.timestampType 的值一致。

参数:

timestamp_str - 要解析为时间戳的字符串。
fmt - 遵循的时间戳格式模式。有关有效的日期和时间格式模式，请参阅日期时间模式。

示例：

> SELECT try_to_timestamp('2016-12-31 00:12:00');
 2016-12-31 00:12:00
> SELECT try_to_timestamp('2016-12-31', 'yyyy-MM-dd');
 2016-12-31 00:00:00
> SELECT try_to_timestamp('foo', 'yyyy-MM-dd');
 NULL

自: 3.4.0

typeof

typeof(expr) - 返回输入数据类型的DDL格式类型字符串。

示例：

> SELECT typeof(1);
 int
> SELECT typeof(array(1));
 array<int>

自: 3.0.0

ucase

ucase(str) - 返回将所有字符转换为大写的str。

示例：

> SELECT ucase('SparkSql');
 SPARKSQL

自: 1.0.1

unbase64

unbase64(str) - 将参数从 base 64 字符串 str 转换为二进制。

示例：

> SELECT unbase64('U3BhcmsgU1FM');
 Spark SQL

自: 1.5.0

unhex

unhex(expr) - 将十六进制的 expr 转换为二进制。

示例：

> SELECT decode(unhex('537061726B2053514C'), 'UTF-8');
 Spark SQL

自: 1.5.0

unix_date

unix_date(date) - 返回自1970-01-01以来的天数。

示例：

> SELECT unix_date(DATE("1970-01-02"));
 1

自: 3.1.0

unix_micros

unix_micros(timestamp) - 返回自1970-01-01 00:00:00 UTC以来的微秒数。

示例：

> SELECT unix_micros(TIMESTAMP('1970-01-01 00:00:01Z'));
 1000000

自: 3.1.0

unix_millis

unix_millis(timestamp) - 返回自1970-01-01 00:00:00 UTC以来的毫秒数。截断更高级别的精度。

示例：

> SELECT unix_millis(TIMESTAMP('1970-01-01 00:00:01Z'));
 1000

自: 3.1.0

unix_seconds

unix_seconds(timestamp) - 返回自1970-01-01 00:00:00 UTC以来的秒数。截断更高级别的精度。

示例：

> SELECT unix_seconds(TIMESTAMP('1970-01-01 00:00:01Z'));
 1

自: 3.1.0

unix_timestamp

unix_timestamp([timeExp[, fmt]]) - 返回当前或指定时间的UNIX时间戳。

参数:

timeExp - 一个日期/时间戳或字符串。如果未提供，默认为当前时间。
fmt - 遵循的日期/时间格式模式。如果 timeExp 不是字符串，则忽略。默认值是 "yyyy-MM-dd HH:mm:ss"。有关有效的日期和时间格式模式，请参见日期时间模式。

示例：

> SELECT unix_timestamp();
 1476884637
> SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd');
 1460041200

自: 1.5.0

upper

upper(str) - 返回将所有字符转换为大写的str。

示例：

> SELECT upper('SparkSql');
 SPARKSQL

自: 1.0.1

url_decode

url_decode(str) - 使用特定的编码方案解码一个以'application/x-www-form-urlencoded'格式编码的str。

参数:

str - 要解码的字符串表达式

示例：

> SELECT url_decode('https%3A%2F%2Fspark.apache.org');
 https://spark.apache.org

自: 3.4.0

url_encode

url_encode(str) - 将字符串转换为使用特定编码方案的'application/x-www-form-urlencoded'格式。

参数:

str - 要翻译的字符串表达式

示例：

> SELECT url_encode('https://spark.apache.org');
 https%3A%2F%2Fspark.apache.org

自: 3.4.0

user

user() - 当前执行上下文的用户名。

示例：

> SELECT user();
 mockingjay

自: 3.2.0

uuid

uuid() - 返回一个通用唯一标识符（UUID）字符串。该值以规范的UUID 36字符串形式返回。

示例：

> SELECT uuid();
 46707d92-02f4-4817-8116-a4c3b23e6266

注意：

该函数是非确定性的。

自: 2.3.0

var_pop

var_pop(expr) - 返回根据一组值计算的总体方差。

示例：

> SELECT var_pop(col) FROM VALUES (1), (2), (3) AS tab(col);
 0.6666666666666666

自: 1.6.0

var_samp

var_samp(expr) - 返回从一组值计算出的样本方差。

示例：

> SELECT var_samp(col) FROM VALUES (1), (2), (3) AS tab(col);
 1.0

自: 1.6.0

variance

variance(expr) - 返回从一组值计算出的样本方差。

示例：

> SELECT variance(col) FROM VALUES (1), (2), (3) AS tab(col);
 1.0

自: 1.6.0

version

version() - 返回 Spark 版本。该字符串包含 2 个字段，第一个是发布版本，第二个是 git 修订版。

示例：

> SELECT version();
 3.1.0 a6d6ea3efedbad14d99c24143834cd4e2e52fb40

自: 3.0.0

weekday

weekday(date) - 返回日期/时间戳的星期几（0 = 星期一, 1 = 星期二, ..., 6 = 星期日）。

示例：

> SELECT weekday('2009-07-30');
 3

自: 2.4.0

weekofyear

weekofyear(date) - 返回给定日期的一年中的周数。一周被认为从星期一开始，第1周是包含超过3天的第一周。

示例：

> SELECT weekofyear('2008-02-20');
 8

自: 1.5.0

when

CASE WHEN expr1 THEN expr2 [WHEN expr3 THEN expr4]* [ELSE expr5] END - 当 expr1 = true 时，返回 expr2；否则当 expr3 = true 时，返回 expr4；否则返回 expr5。

参数:

expr1, expr3 - 分支条件表达式都应为布尔类型。
expr2, expr4, expr5 - 分支值表达式和else值表达式都应为相同类型或可强制转换为通用类型。

示例：

> SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
 1.0
> SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
 2.0
> SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END;
 NULL

自: 1.0.1

width_bucket

width_bucket(value, min_value, max_value, num_bucket) - 返回在范围min_value到max_value内，具有num_bucket个桶的等宽直方图中，value将被分配到的桶号。"

示例：

> SELECT width_bucket(5.3, 0.2, 10.6, 5);
 3
> SELECT width_bucket(-2.1, 1.3, 3.4, 3);
 0
> SELECT width_bucket(8.1, 0.0, 5.7, 4);
 5
> SELECT width_bucket(-0.9, 5.2, 0.5, 2);
 3
> SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
 1
> SELECT width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
 2
> SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
 1
> SELECT width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
 2

自: 3.1.0

window

window(time_column, window_duration[, slide_duration[, start_time]]) - 根据指定的时间戳列将行分组到一个或多个时间窗口中。窗口的开始是包含的，但窗口的结束是排他的，例如，12:05 将包含在窗口 [12:05,12:10) 中，但不包含在 [12:00,12:05) 中。窗口支持微秒精度。不支持按月顺序的窗口。请参阅结构化流指南文档中的 '事件时间上的窗口操作' 以获取详细解释和示例。

参数:

time_column - 用于按时间进行窗口化的列或表达式。时间列必须是TimestampType类型。
window_duration - 一个字符串，指定窗口的宽度，表示为“间隔值”。（有关更多详细信息，请参阅间隔字面量。）请注意，持续时间是固定长度的时间，不会根据日历随时间变化。
slide_duration - 一个字符串，指定窗口的滑动间隔，表示为“间隔值”。每隔slide_duration将生成一个新窗口。必须小于或等于window_duration。此持续时间同样是绝对的，不会根据日历变化。
start_time - 相对于1970-01-01 00:00:00 UTC的偏移量，用于开始窗口间隔。例如，为了拥有从每小时15分钟开始的滚动窗口，例如12:15-13:15, 13:15-14:15... 提供start_time为15分钟。

示例：

> SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, start;
  A1    2021-01-01 00:00:00 2021-01-01 00:05:00 2
  A1    2021-01-01 00:05:00 2021-01-01 00:10:00 1
  A2    2021-01-01 00:00:00 2021-01-01 00:05:00 1
> SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '10 minutes', '5 minutes') ORDER BY a, start;
  A1    2020-12-31 23:55:00 2021-01-01 00:05:00 2
  A1    2021-01-01 00:00:00 2021-01-01 00:10:00 3
  A1    2021-01-01 00:05:00 2021-01-01 00:15:00 1
  A2    2020-12-31 23:55:00 2021-01-01 00:05:00 1
  A2    2021-01-01 00:00:00 2021-01-01 00:10:00 1

自: 2.0.0

window_time

window_time(window_column) - 从时间/会话窗口列中提取时间值，该值可用于窗口的事件时间值。提取的时间是 (window.end - 1)，这反映了聚合窗口具有独占上界的事实 - [start, end) 请参阅结构化流指南文档中的'事件时间上的窗口操作'以获取详细解释和示例。

参数:

window_column - 表示时间/会话窗口的列。

示例：

> SELECT a, window.start as start, window.end as end, window_time(window), cnt FROM (SELECT a, window, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, window.start);
  A1    2021-01-01 00:00:00 2021-01-01 00:05:00 2021-01-01 00:04:59.999999  2
  A1    2021-01-01 00:05:00 2021-01-01 00:10:00 2021-01-01 00:09:59.999999  1
  A2    2021-01-01 00:00:00 2021-01-01 00:05:00 2021-01-01 00:04:59.999999  1

自: 3.4.0

xpath

xpath(xml, xpath) - 返回与XPath表达式匹配的xml节点中的字符串数组值。

示例：

> SELECT xpath('<a><b>b1</b><b>b2</b><b>b3</b><c>c1</c><c>c2</c></a>','a/b/text()');
 ["b1","b2","b3"]
> SELECT xpath('<a><b>b1</b><b>b2</b><b>b3</b><c>c1</c><c>c2</c></a>','a/b');
 [null,null,null]

自: 2.0.0

xpath_boolean

xpath_boolean(xml, xpath) - 如果XPath表达式计算为true，或者找到匹配的节点，则返回true。

示例：

> SELECT xpath_boolean('<a><b>1</b></a>','a/b');
 true

自: 2.0.0

xpath_double

xpath_double(xml, xpath) - 返回一个双精度值，如果没有找到匹配项则返回零，如果找到匹配项但值为非数字则返回NaN。

示例：

> SELECT xpath_double('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3.0

自: 2.0.0

xpath_float

xpath_float(xml, xpath) - 返回一个浮点值，如果没有找到匹配项则返回零，如果找到匹配项但值为非数字则返回NaN。

示例：

> SELECT xpath_float('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3.0

自: 2.0.0

xpath_int

xpath_int(xml, xpath) - 返回一个整数值，如果没有找到匹配项则返回零，或者找到匹配项但值为非数字。

示例：

> SELECT xpath_int('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3

自: 2.0.0

xpath_long

xpath_long(xml, xpath) - 返回一个长整型值，如果没有找到匹配项则返回零，或者找到匹配项但值为非数字。

示例：

> SELECT xpath_long('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3

自: 2.0.0

xpath_number

xpath_number(xml, xpath) - 返回一个双精度值，如果没有找到匹配项则返回零，如果找到匹配项但值为非数字则返回NaN。

示例：

> SELECT xpath_number('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3.0

自: 2.0.0

xpath_short

xpath_short(xml, xpath) - 返回一个短整数值，如果没有找到匹配项则返回零值，或者找到匹配项但值为非数字。

示例：

> SELECT xpath_short('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
 3

自: 2.0.0

xpath_string

xpath_string(xml, xpath) - 返回与XPath表达式匹配的第一个xml节点的文本内容。

示例：

> SELECT xpath_string('<a><b>b</b><c>cc</c></a>','a/c');
 cc

自: 2.0.0

xxhash64

xxhash64(expr1, expr2, ...) - 返回参数的64位哈希值。哈希种子为42。

示例：

> SELECT xxhash64('Spark', array(123), 2);
 5602566077635097486

自: 3.0.0

year

year(date) - 返回日期/时间戳的年份部分。

示例：

> SELECT year('2016-07-30');
 2016

自: 1.5.0

zip_with

zip_with(left, right, func) - 将两个给定的数组按元素逐个合并成一个数组，使用函数进行合并。如果一个数组较短，则在末尾追加null以匹配较长数组的长度，然后再应用函数。

示例：

> SELECT zip_with(array(1, 2, 3), array('a', 'b', 'c'), (x, y) -> (y, x));
 [{"y":"a","x":1},{"y":"b","x":2},{"y":"c","x":3}]
> SELECT zip_with(array(1, 2), array(3, 4), (x, y) -> x + y);
 [4,6]
> SELECT zip_with(array('a', 'b', 'c'), array('d', 'e', 'f'), (x, y) -> concat(x, y));
 ["ad","be","cf"]

自: 2.4.0

|

expr1 | expr2 - 返回 expr1 和 expr2 的按位或结果。

示例：

> SELECT 3 | 5;
 7

自: 1.4.0

||

expr1 || expr2 - 返回 expr1 和 expr2 的连接结果。

示例：

> SELECT 'Spark' || 'SQL';
 SparkSQL
> SELECT array(1, 2, 3) || array(4, 5) || array(6);
 [1,2,3,4,5,6]

注意：

|| 对于数组从2.4.0版本开始可用。

自: 2.3.0

~

~ expr - 返回 expr 的按位 NOT 的结果。

示例：

> SELECT ~ 0;
 -1

自: 1.4.0