内置函数

aes_decrypt(expr, key[, mode[, padding[, aad]]]) - 使用具有 padding 的 mode 中的 AES 返回 expr 的解密值。支持 16、24 和 32 位的密钥长度。支持的 (mode, padding) 组合为 ('ECB', 'PKCS')、('GCM', 'NONE') 和 ('CBC', 'PKCS')。可选的附加身份验证数据 (AAD) 仅支持 GCM。如果为加密提供，则必须为解密提供相同的 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]]]]) - 使用给定的 mode 中的 AES 和指定的 padding 返回 expr 的加密值。支持 16、24 和 32 位的密钥长度。支持的 (mode, padding) 组合为 ('ECB', 'PKCS'), ('GCM', 'NONE') 和 ('CBC', 'PKCS')。可选的初始化向量 (IV) 仅支持 CBC 和 GCM 模式。 CBC 必须为 16 个字节，GCM 必须为 12 个字节。如果未提供，将生成一个随机向量并将其添加到输出中。可选的附加认证数据 (AAD) 仅支持 GCM。如果为加密提供了 AAD，则必须为解密提供相同的 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 and expr2 - 逻辑 AND。

示例

> 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 的至少一个值为 true，则返回 true。

示例

> 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 为 true，则仅返回非空值。

示例

> 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 interval 列 col 的近似 percentile，该值是排序后的 col 值（从最小到最大排序）中的最小值，使得不超过 percentage 的 col 值小于或等于该值。 percentage 的值必须介于 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]

注意

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

自从 3.3.0

array_append

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

示例

> 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) - 返回数组中的最大值。对于双精度/浮点类型，NaN 大于任何非 NaN 元素。 NULL 元素将被跳过。

示例

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

自从 2.4.0

array_min

array_min(array) - 返回数组中的最小值。对于双精度/浮点类型，NaN 大于任何非 NaN 元素。 NULL 元素将被跳过。

示例

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

自从 2.4.0

array_position

array_position(array, element) - 以 long 类型返回数组中第一个匹配元素的（从 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) - 将元素添加到作为第一个参数传递的数组的开头。元素的类型应与数组的元素类型相同。空元素也会前置到数组。但是，如果传递的数组为 NULL，则输出为 NULL。

示例

> 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) - 返回包含 element count 次的数组。

示例

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

自从 2.4.0

array_size

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

示例

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

自从 3.3.0

array_sort

array_sort(expr, func) - 对输入数组进行排序。如果省略 func，则按升序排序。输入数组的元素必须是可排序的。对于双精度/浮点类型，NaN 大于任何非 NaN 元素。 Null 元素将放置在返回数组的末尾。自 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，否则返回 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) - 返回以二进制表示的 long 值 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) - 返回所有非空输入值的按位 AND，如果没有则返回 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) - 返回所有非空输入值的按位 OR，如果没有则返回 null。

示例

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

自从 3.0.0

bit_xor

bit_xor(expr) - 返回所有非空输入值的按位 XOR，如果没有则返回 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) - 返回给定输入子表达式的 bucket 编号。

示例

> 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) - 返回一个位图，该位图是来自子表达式的所有位图的按位 OR。输入应该是从 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 的所有值为 true，则返回 true。

示例

> 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 的至少一个值为 true，则返回 true。

示例

> 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 舍入模式舍入到 d 位小数的 expr。

示例

> 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]

注意

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

自从 2.0.0

collect_set

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

示例

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

注意

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

自从 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 起，可以使用数组的 Concat 逻辑。

自从 1.5.0

concat_ws

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

示例

> 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) - 返回具有给定 esp、置信度和种子的列的 count-min sketch。结果是一个字节数组，可以在使用前反序列化为 CountMinSketch。Count-min sketch 是一种概率数据结构，用于使用亚线性空间进行基数估计。

示例

> 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() - 返回当前的 catalog。

示例

> SELECT current_catalog();
 spark_catalog

自从 3.1.0

current_database

current_database() - 返回当前的 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() - 返回当前的 database。

示例

> 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 - 要遵循的日期/时间格式模式。有关有效的日期和时间格式模式，请参阅 Datetime Patterns。

示例

> 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) - 返回截断为格式模型 fmt 指定的单位的时间戳 ts。

参数

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

示例

> 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 与每个搜索值进行比较。如果 expr 等于搜索值，则 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() - 计算一组值中某个值的排名。结果是 1 加上先前分配的排名值。与 rank 函数不同，dense_rank 不会在排名序列中产生间隙。

参数

children - 这是排名的基础；一个 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) - 返回给定键的值。如果 map 中不包含该键，则该函数返回 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) - 返回一个布尔值。如果 left 以 right 结尾，则该值为 True。如果任何输入表达式为 NULL，则返回 NULL。否则，返回 False。 left 或 right 都必须是 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) - 对于非 null 操作数，返回与 EQUAL(=) 运算符相同的结果，但如果两者都为 null，则返回 true，如果其中一个为 null，则返回 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 的所有值都为 true，则返回 true。

示例

> 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 - 选择要提取的源的部分
- 对于日期和时间戳，field 支持的字符串值（不区分大小写）有：
  - "YEAR", ("Y", "YEARS", "YR", "YRS") - 年份字段
  - "YEAROFWEEK" - datetime 所在的 ISO 8601 周编号年份。例如，2005-01-02 是 2004 年的第 53 周的一部分，因此结果为 2004
  - "QUARTER", ("QTR") - datetime 所在的年份的季度 (1 - 4)
  - "MONTH", ("MON", "MONS", "MONTHS") - 月份字段 (1 - 12)
  - "WEEK", ("W", "WEEKS") - 基于周的 ISO 8601 周编号。一周被认为从星期一开始，第 1 周是包含 >3 天的第一周。在 ISO 周编号系统中，1 月初的日期可能属于前一年的第 52 周或第 53 周，而 12 月底的日期可能属于下一年的第 1 周。例如，2005-01-02 是 2004 年的第 53 周的一部分，而 2012-12-31 是 2013 年的第 1 周
  - "DAY", ("D", "DAYS") - 月份中的日期字段 (1 - 31)
  - "DAYOFWEEK",("DOW") - datetime 的星期几，星期日 (1) 到星期六 (7)
  - "DAYOFWEEK_ISO",("DOW_ISO") - 基于 ISO 8601 的 datetime 星期几，星期一 (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 中提取小时和分钟后剩余多少秒（带小数）
source - 应从中提取 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 开始，内部函数可以使用索引参数。

自从 2.4.0

find_in_set

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

示例

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

自从 1.5.0

first

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

示例

> 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

注意

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

自从 2.0.0

first_value

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

示例

> 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

注意

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

自从 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) - 使用 nb 个 bin 计算数字“expr”的直方图。返回值是一个 (x,y) 对数组，表示直方图 bin 的中心。随着“nb”值的增加，直方图近似变得更加精细，但可能会在异常值附近产生伪像。实际上，20-40 个直方图 bin 似乎效果很好，对于倾斜或较小的数据集需要更多的 bin。请注意，此函数创建具有非均匀 bin 宽度的直方图。它不提供直方图均方误差方面的保证，但在实践中与 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 Union 对象合并 Datasketches HllSketch 对象的两个二进制表示。将 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 的计算结果为 true，则返回 expr2；否则返回 expr3。

示例

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

自从 1.0.0

ifnull

ifnull(expr1, expr2) - 如果 expr1 为 null，则返回 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 不为 null，则返回 true，否则返回 false。

示例

> SELECT isnotnull(1);
 true

自从 1.0.0

isnull

isnull(expr) - 如果 expr 为 null，则返回 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。如果第 offset 行的 input 值为 null，则返回 null。如果没有这样的 offset 行（例如，当 offset 为 1 时，窗口的第一行没有任何前一行），则返回 default。

参数

input - 一个字符串表达式，用于评估当前行之前 offset 行的值。
offset - 一个整数表达式，表示在分区中向后跳跃的行数。
default - 一个字符串表达式，用于在 offset 行不存在时使用。

示例

> 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

注意

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

自从 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

注意

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

自从 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。如果第 offset 行的 input 值为 null，则返回 null。如果没有这样的 offset 行（例如，当 offset 为 1 时，窗口的最后一行没有任何后续行），则返回 default。

参数

input - 一个字符串表达式，用于评估当前行之后 offset 行的值。
offset - 一个整数表达式，表示在分区中向前跳跃的行数。
default - 一个字符串表达式，用于在 offset 大于窗口时使用。默认值为 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 - 一个字符串表达式。该 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]) - 返回 substr 在 str 中位置 pos 之后第一次出现的位置。给定的 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]]]]]]]) - 从年、月、周、日、小时、分钟和秒创建 interval。

参数

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，则将 seconds 字段设置为 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，则将 seconds 字段设置为 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，则将 seconds 字段设置为 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]]) - 从年、月创建 year-month interval。

参数

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, ...) - 使用给定的键/值对创建一个 map。

示例

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

自从 2.0.0

map_concat

map_concat(map, ...) - 返回所有给定 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) - 如果 map 包含键，则返回 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) - 返回给定 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) - 使用函数过滤 map 中的条目。

示例

> 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) - 使用一对给定的键/值数组创建一个 map。 keys 中的所有元素都不应为 null

示例

> 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) - 返回从给定条目数组创建的 map。

示例

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

自从 2.4.0

map_keys

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

示例

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

自从 2.0.0

map_values

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

示例

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

自从 2.0.0

map_zip_with

map_zip_with(map1, map2, function) - 通过将函数应用于具有相同键的值对，将两个给定的 map 合并为一个 map。对于仅在一个 map 中存在的键，将传递 NULL 作为缺失键的值。如果输入 map 包含重复的键，则只有重复键的第一个条目会传递到 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 interval 列 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，或者有 0 行，则返回 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 的值。 Offset 从 1 开始。如果 ignoreNulls=true，则在查找第 offset 行时，我们将跳过 null 值。否则，每行都计入 offset。如果没有这样的第 offset 行（例如，当 offset 为 10 时，窗口框架的大小小于 10），则返回 null。

参数

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 - 一个 int 表达式，表示将行划分成的桶数。默认值为 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 为 null，则返回 expr2，否则返回 expr1。

示例

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

自从 2.0.0

nvl2

nvl2(expr1, expr2, expr3) - 如果 expr1 不为 null，则返回 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 or expr2 - 逻辑 OR。

示例

> 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]) - 从位置 pos 开始，用长度为 len 的 replace 替换 input。

示例

> 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('https://spark.apache.org/path?query=1', 'HOST');
 spark.apache.org
> SELECT parse_url('https://spark.apache.org/path?query=1', 'QUERY');
 query=1
> SELECT parse_url('https://spark.apache.org/path?query=1', 'QUERY', 'query');
 1

自从 2.0.0

percent_rank

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

参数

children - 这是排名的基础；一个 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() - 返回 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]) - 返回位置 pos 之后 str 中第一次出现 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) 中独立且均匀分布 (i.i.d.) 的值。

示例

> 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() - 计算一组值中某个值的排名。结果是 1 加上分区排序中当前行之前或等于当前行的行数。这些值将在序列中产生间隙。

参数

children - 这是排名的基础；一个 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) - 将二元运算符应用于初始状态和数组中的所有元素，并将此结果归约为单个状态。通过应用完成函数，将最终状态转换为最终结果。

示例

> 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 - 一个字符串表达式。 regex 字符串应为 Java 正则表达式。

自从 Spark 2.0 以来，我们的 SQL 解析器中取消转义了字符串文字（包括 regex 模式）。例如，要匹配“\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 - 表示正则表达式的字符串。 regex 字符串应为 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 表达式匹配的第一个字符串，并对应于 regex 组索引。

参数

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

自从 Spark 2.0 以来，我们的 SQL 解析器中取消转义了字符串文字（包括 regex 模式）。例如，要匹配“\abc”，regexp 的正则表达式可以是“^\abc$”。

有一个 SQL 配置 'spark.sql.parser.escapedStringLiterals'，可用于回退到关于字符串文字解析的 Spark 1.6 行为。例如，如果启用了该配置，则可以匹配“\abc”的 regexp 为“^\abc$”。
idx - 表示组索引的整数表达式。 regex 可能包含多个组。 idx 指示要提取的 regex 组。组索引应为非负数。 idx 的最小值为 0，这意味着匹配整个正则表达式。如果未指定 idx，则默认组索引值为 1。 idx 参数是 Java regex 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 表达式匹配的所有字符串，并对应于 regex 组索引。

参数

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

自从 Spark 2.0 以来，我们的 SQL 解析器中取消转义了字符串文字（包括 regex 模式）。例如，要匹配“\abc”，regexp 的正则表达式可以是“^\abc$”。

有一个 SQL 配置 'spark.sql.parser.escapedStringLiterals'，可用于回退到关于字符串文字解析的 Spark 1.6 行为。例如，如果启用了该配置，则可以匹配“\abc”的 regexp 为“^\abc$”。
idx - 表示组索引的整数表达式。 regex 可能包含多个组。 idx 指示要提取的 regex 组。组索引应为非负数。 idx 的最小值为 0，这意味着匹配整个正则表达式。如果未指定 idx，则默认组索引值为 1。 idx 参数是 Java regex 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 - 表示正则表达式的字符串。 regex 字符串应为 Java 正则表达式。

自从 Spark 2.0 以来，我们的 SQL 解析器中取消转义了字符串文字（包括 regex 模式）。例如，要匹配“\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 - 一个字符串表达式。 regex 字符串应为 Java 正则表达式。

自从 Spark 2.0 以来，我们的 SQL 解析器中取消转义了字符串文字（包括 regex 模式）。例如，要匹配“\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 - 表示正则表达式的字符串。 regex 字符串应为 Java 正则表达式。

自从 Spark 2.0 以来，我们的 SQL 解析器中取消转义了字符串文字（包括 regex 模式）。例如，要匹配“\abc”，regexp 的正则表达式可以是“^\abc$”。

有一个 SQL 配置 'spark.sql.parser.escapedStringLiterals'，可用于回退到关于字符串文字解析的 Spark 1.6 行为。例如，如果启用了该配置，则可以匹配“\abc”的 regexp 为“^\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 - 表示正则表达式的字符串。 regex 字符串应为 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 - 一个字符串表达式。如果在 str 中未找到 search，则返回未更改的 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) - 返回最接近参数值且等于数学整数的双精度浮点值。

示例

> SELECT rint(12.3456);
 12.0

自从 1.4.0

rlike

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

参数

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

自从 Spark 2.0 以来，我们的 SQL 解析器中取消转义了字符串文字（包括 regex 模式）。例如，要匹配“\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) - 返回使用 HALF_UP 舍入模式将 expr 舍入到 d 位小数后的结果。

示例

> SELECT round(2.5, 0);
 3

自从 1.5.0

row_number

row_number() - 根据窗口分区内的行排序，为每一行分配一个唯一的顺序编号，从 1 开始。

示例

> 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 格式的 schema。

示例

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

自从 3.0.0

schema_of_json

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

示例

> 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 递增。返回元素的类型与参数表达式的类型相同。

支持的类型包括：byte、short、integer、long、date、timestamp。

start 和 stop 表达式必须解析为相同的类型。如果 start 和 stop 表达式解析为“date”或“timestamp”类型，则 step 表达式必须解析为“interval”、“year-month interval”或“day-time interval”类型，否则解析为与 start 和 stop 表达式相同的类型。

参数

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 - 一个字符串，用于指定会话的超时时间，表示为“interval value”（有关更多详细信息，请参阅Interval Literal）。对于固定间隔持续时间，可以是一个表达式，该表达式应用于每个输入，并计算得出动态间隔持续时间的“interval value”。

示例

> 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) - 将 expr 的 sha1 哈希值作为十六进制字符串返回。

示例

> SELECT sha('Spark');
 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c

自从 1.5.0

sha1

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

示例

> SELECT sha1('Spark');
 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c

自从 1.5.0

sha2

sha2(expr, bitLength) - 以 expr 的十六进制字符串形式返回 SHA-2 系列的校验和。支持 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) - 如果 expr 为负数，则返回 -1.0，如果为 0，则返回 0.0，如果为正数，则返回 1.0。

示例

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

自从 1.4.0

signum

signum(expr) - 如果 expr 为负数，则返回 -1.0，如果为 0，则返回 0.0，如果为正数，则返回 1.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。否则，对于空输入，该函数返回 -1。使用默认设置时，对于空输入，该函数返回 -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) - 子集数组 x，从索引 start 开始（数组索引从 1 开始，如果 start 为负数，则从末尾开始），长度为指定的 length。

示例

> 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 的至少一个值为 true，则返回 true。

示例

> 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 元素将被放置在返回数组的开头，或者在降序中，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) - 在与 regex 匹配的位置周围拆分 str，并返回一个长度最多为 limit 的数组。

参数

str - 要拆分的字符串表达式。
regex - 表示正则表达式的字符串。 regex 字符串应该是 Java 正则表达式。
limit - 一个整数表达式，用于控制应用 regex 的次数。
- limit > 0：结果数组的长度不会超过 limit，并且结果数组的最后一个条目将包含最后一个匹配的 regex 之后的所有输入。
- 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) - 通过 delimiter 拆分 str，并返回拆分部分的请求部分（基于 1）。如果任何输入为空，则返回空值。如果 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) - 返回一个布尔值。如果 left 以 right 开头，则该值为 True。如果任一输入表达式为 NULL，则返回 NULL。否则，返回 False。left 或 right 都必须是 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, ...) - 创建一个具有给定字段值的 struct。

示例

> 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 为负数，则返回最终分隔符（从右侧计数）右侧的所有内容。在搜索 delim 时，函数 substring_index 执行区分大小写的匹配。

示例

> 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 epoch 以来的微秒数创建时间戳。

示例

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

自从 3.1.0

timestamp_millis

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

示例

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

自从 3.1.0

timestamp_seconds

timestamp_seconds(seconds) - 从 UTC epoch 以来的秒数（可以是小数）创建时间戳。

示例

> 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]) - 根据提供的 fmt 将输入 str 转换为二进制值。 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) - 基于 formatExpr 将 numberExpr 转换为字符串。如果转换失败，则会引发异常。格式可以包含以下字符，不区分大小写：'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]) - 使用 fmt 表达式解析 date_str 表达式为日期。如果输入无效，则返回 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) - 基于字符串格式 'fmt' 将字符串 'expr' 转换为数字。如果转换失败，则会引发异常。格式可以包含以下字符，不区分大小写：'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]) - 使用 fmt 表达式将 timestamp_str 表达式解析为具有本地时区的时间戳。如果输入无效，则返回 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]) - 使用 fmt 表达式将 timestamp_str 表达式解析为不带时区的时间戳。如果输入无效，则返回 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) - 基于 formatExpr 将 numberExpr 转换为字符串。如果转换失败，则会引发异常。格式可以包含以下字符，不区分大小写：'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) - 使用函数转换 map 中的键。

示例

> 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) - 使用函数转换 map 中的值。

示例

> 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 字符串中存在的字符替换为 to 字符串中对应的字符来翻译 input 字符串。

示例

> 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，其日期的 time 部分被截断为格式模型 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) - 返回从组的值计算得出的平均值，如果溢出，则结果为 null。

示例

> 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，则其结果始终为 null。 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 的）索引处的数组元素。如果 Index 为 0，Spark 将抛出错误。如果 index < 0，则从最后一个到第一个访问元素。如果索引超过数组的长度，该函数始终返回 NULL。

try_element_at(map, key) - 返回给定键的值。如果该键未包含在 map 中，该函数始终返回 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，如果溢出，则结果为 null。可接受的输入类型与 * 运算符相同。

示例

> 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，如果溢出，则结果为 null。可接受的输入类型与 - 运算符相同。

示例

> 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) - 基于字符串格式 fmt 将字符串“expr”转换为数字。如果字符串 '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]) - 使用 fmt 表达式解析 timestamp_str 表达式为时间戳。无论是否启用 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) - 返回在具有 num_bucket 个桶的等宽直方图中，value 将被分配到的桶号，范围为 min_value 到 max_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 - 一个字符串，指定窗口的宽度，表示为“interval value”。 (有关更多详细信息，请参见间隔字面量。)请注意，持续时间是固定的时间长度，不会随时间根据日历而变化。
slide_duration - 一个字符串，指定窗口的滑动间隔，表示为“interval value”。每隔 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 minutes。

示例

> 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) - 返回 xml 节点中与 XPath 表达式匹配的值的字符串数组。

示例

> 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 的按位 OR 运算的结果。

示例

> 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