内置函数

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

参数

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

示例

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

自 3.3.0

aes_encrypt

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

示例

> 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 区间列 col 的近似 percentile，它是排序后的 col 值（从小到大排序）中的最小值，使得不超过 percentage 的 col 值小于或等于该值。percentage 的值必须介于 0.0 和 1.0 之间。accuracy 参数（默认值：10000）是一个正数，用于控制近似精度，但会增加内存消耗。accuracy 的值越高，精度越高，1.0/accuracy 是近似的相对误差。当 percentage 是一个数组时，percentage 数组的每个值都必须介于 0.0 和 1.0 之间。在这种情况下，返回给定 percentage 数组中列 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) - 返回数组中的最大值。对于 double/float 类型，NaN 大于任何非 NaN 元素。跳过 NULL 元素。

示例

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

自 2.4.0

array_min

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

示例

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

自 2.4.0

array_position

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

示例

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

自 2.4.0

array_prepend

array_prepend(array, element) - 将元素添加到作为第一个参数传递的数组的开头。元素的类型应与数组元素的类型相同。空元素也会添加到数组的开头。但是，如果传递的数组为 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，则按升序排序。输入数组的元素必须是可排序的。对于 double/float 类型，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 不为 true，则抛出异常。

示例

> SELECT assert_true(0 < 1);
 NULL

自 2.0.0

atan

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

示例

> SELECT atan(0);
 0.0

自 1.4.0

atan2

atan2(exprY, exprX) - 返回平面正 x 轴与由坐标 (exprX, exprY) 给定的点之间的弧度角，如同通过 java.lang.Math.atan2 计算一样。

参数

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

示例

> SELECT atan2(0, 0);
 0.0

自 1.4.0

atanh

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

示例

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

自 3.0.0

avg

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

示例

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

自 1.0.0

base64

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

示例

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

自 1.5.0

between

expr1 [NOT] BETWEEN expr2 AND expr3 - 计算 expr1 是否 [不] 介于 expr2 和 expr3 之间。

示例

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

自 1.0.0

bigint

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

自 2.0.1

bin

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

示例

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

自 1.5.0

binary

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

自 2.0.1

bit_and

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

示例

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

自 3.0.0

bit_count

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

示例

> SELECT bit_count(0);
 0

自 3.0.0

bit_get

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

示例

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

自 3.2.0

bit_length

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

示例

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

自 2.3.0

bit_or

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

示例

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

自 3.0.0

bit_xor

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

示例

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

自 3.0.0

bitmap_bit_position

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

示例

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

自 3.5.0

bitmap_bucket_number

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

示例

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

自 3.5.0

bitmap_construct_agg

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

示例

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

自 3.5.0

bitmap_count

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

示例

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

自 3.5.0

bitmap_or_agg

bitmap_or_agg(child) - 返回一个位图，该位图是子表达式中所有位图的按位或。输入应该是从 bitmap_construct_agg() 创建的位图。

示例

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

自 3.5.0

bool_and

bool_and(expr) - 如果 expr 的所有值都为 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 输入返回 null。否则，该函数对于 null 输入返回 -1。使用默认设置时，该函数对于 null 输入返回 -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) - 返回 ASCII 字符，其二进制等效于 expr。如果 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 版本起，支持数组的串联逻辑。

自 1.5.0

concat_ws

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

示例

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

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

自 1.5.0

contains

contains(left, right) - 返回一个布尔值。如果在 left 中找到 right，则值为 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) - 将没有时区的 timestamp sourceTs 从 sourceTz 时区转换为 targetTz。

参数

sourceTz - 输入 timestamp 的时区。如果缺少，则使用当前会话时区作为源时区。
targetTz - 输入 timestamp 应转换到的时区
sourceTs - 没有时区的 timestamp

示例

> 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() - 返回当前目录。

示例

> SELECT current_catalog();
 spark_catalog

自 3.1.0

current_database

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

示例

> SELECT current_database();
 default

自 1.6.0

current_date

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

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

示例

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

注意

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

自 1.5.0

current_schema

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

示例

> SELECT current_schema();
 default

自 1.6.0

current_timestamp

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

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

示例

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

注意

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

自 1.5.0

current_timezone

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

示例

> SELECT current_timezone();
 Asia/Shanghai

自 3.1.0

current_user

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

示例

> SELECT current_user();
 mockingjay

自 3.2.0

date

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

自 2.0.1

date_add

date_add(start_date, num_days) - 返回 start_date 之后 num_days 天的日期。

示例

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

自 1.5.0

date_diff

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

示例

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

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

自 3.4.0

date_format

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

参数

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

示例

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

自 1.5.0

date_from_unix_date

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

示例

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

自 3.1.0

date_part

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

参数

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

示例

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

注意

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

自 3.0.0

date_sub

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

示例

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

自 1.5.0

date_trunc

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

参数

fmt - 表示要截断到的单位的格式
- "YEAR"、"YYYY"、"YY" - 截断到 ts 所在年份的第一天，时间部分将归零
- "QUARTER" - 截断到 ts 所在季度的第一天，时间部分将归零
- "MONTH"、"MM"、"MON" - 截断到 ts 所在月份的第一天，时间部分将归零
- "WEEK" - 截断到 ts 所在星期的星期一，时间部分将归零
- "DAY"、"DD" - 将时间部分归零
- "HOUR" - 将分钟和秒（包括小数部分）归零
- "MINUTE" - 将秒（包括小数部分）归零
- "SECOND" - 将秒的小数部分归零
- "MILLISECOND" - 将微秒归零
- "MICROSECOND" - 保留所有内容
ts - 日期时间值或有效的 timestamp 字符串

示例

> 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 返回相应的 result。如果没有找到匹配项，则返回 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 - 这是排名的依据；其中一个子项的值发生变化将触发排名的变化。这是一个内部参数，将由分析器分配。

示例

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

自 2.0.0

div

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

示例

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

自 3.0.0

double

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

自 2.0.1

e

e() - 返回欧拉数 e。

示例

> SELECT e();
 2.718281828459045

自 1.5.0

element_at

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

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

示例

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

自 2.4.0

elt

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

示例

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

自 2.0.0

encode

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

示例

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

自 1.5.0

endswith

endswith(left, right) - 返回一个布尔值。如果 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) - 对于非空操作数，返回与 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" - 日期时间所在的 ISO 8601 周编号年份。例如，2005-01-02 是 2004 年第 53 周的一部分，因此结果是 2004
  - "QUARTER"、("QTR") - 日期时间所在年份的季度（1 - 4）
  - "MONTH"、("MON"、"MONS"、"MONTHS") - 月份字段（1 - 12）
  - “WEEK”（“W”、“WEEKS”）- 基于 ISO 8601 周的年份的周数。一周被认为从星期一开始，第 1 周是包含大于 3 天的第一周。在 ISO 周编号系统中，1 月初的日期可能属于前一年的第 52 周或第 53 周，而 12 月末的日期可能属于下一年的第 1 周。例如，2005-01-02 属于 2004 年的第 53 周，而 2012-12-31 属于 2013 年的第 1 周。
  - “DAY”（“D”、“DAYS”）- 月份中的日期字段（1 - 31）。
  - “DAYOFWEEK”（“DOW”）- 日期时间是星期几，从星期日 (1) 到星期六 (7)。
  - “DAYOFWEEK_ISO”（“DOW_ISO”）- 基于 ISO 8601 的日期时间是星期几，从星期一 (1) 到星期日 (7)。
  - “DOY”- 一年中的日期（1 - 365/366）。
  - “HOUR”（“H”、“HOURS”、“HR”、“HRS”）- 小时字段（0 - 23）。
  - “MINUTE”（“M”、“MIN”、“MINS”、“MINUTES”）- 分钟字段（0 - 59）。
  - “SECOND”（“S”、“SEC”、“SECONDS”、“SECS”）- 秒字段，包括小数部分。
- interval（由 months、days、microseconds 组成）的 field 支持的字符串值如下（不区分大小写）：
  - “YEAR”（“Y”、“YEARS”、“YR”、“YRS”）- 总 months / 12。
  - “MONTH”（“MON”、“MONS”、“MONTHS”）- 总 months % 12。
  - “DAY”（“D”、“DAYS”）- interval 的 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) 在逗号分隔列表 (str_array) 中的索引（从 1 开始）。如果未找到该字符串或给定字符串 (str) 包含逗号，则返回 0。

示例

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

自 1.5.0

first

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

示例

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

注意

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

自 2.0.0

first_value

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

示例

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

注意

该函数是不确定的，因为其结果取决于行的顺序，而在 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, ...) - 返回所有参数中的最大值，跳过空值。

示例

> 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 个箱对数字“expr”计算直方图。返回值是一个 (x,y) 对数组，表示直方图箱的中心。随着“nb”值的增加，直方图近似值变得更加细粒度，但可能会在异常值周围产生伪像。在实践中，20-40 个直方图箱似乎效果良好，对于偏斜或较小的数据集，则需要更多箱。请注意，此函数创建的直方图的箱宽度不均匀。它不保证直方图的均方误差，但在实践中可与 R/S-Plus 统计计算包生成的直方图相媲美。注意：返回值中“x”字段的输出类型是从聚合函数中使用的输入值传播而来的。

示例

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

自 3.3.0

hll_sketch_agg

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

示例

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

自 3.5.0

hll_sketch_estimate

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

示例

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

自 3.5.0

hll_union

hll_union(first, second, allowDifferentLgConfigK) - 使用 Datasketches 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。如果没有这样的偏移行（例如，当偏移量为 1 时，窗口的第一行没有任何前一行），则返回 default。

参数

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

示例

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

自 2.0.0

last

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

示例

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

注意

该函数是不确定的，因为其结果取决于行的顺序，而在 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。如果没有这样的偏移行（例如，当偏移量为 1 时，窗口的最后一行没有任何后续行），则返回 default。

参数

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

示例

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

自 2.0.0

least

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

示例

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

自 1.5.0

left

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

示例

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

自 2.3.0

len

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

示例

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

自 3.4.0

length

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

示例

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

自 1.5.0

levenshtein

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

示例

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

自 1.5.0

like

str like pattern[ ESCAPE escape] - 如果 str 使用 escape 匹配 pattern，则返回 true，如果任何参数为 null，则返回 null，否则返回 false。

参数

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

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

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

启用 SQL 配置“spark.sql.parser.escapedStringLiterals”后，它将回退到 Spark 1.6 中关于字符串字面量解析的行为。例如，如果启用了该配置，则匹配“\abc”的模式应该是“\abc”。
escape - 从 Spark 3.0 开始添加的字符。默认转义字符为“\”。如果转义字符出现在特殊符号或另一个转义字符之前，则按字面意思匹配后面的字符。对任何其他字符进行转义都是无效的。

示例

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

注意

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

自 1.0.0

ln

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

示例

> SELECT ln(1);
 0.0

自 1.4.0

localtimestamp

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

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

示例

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

自 3.4.0

locate

locate(substr, str[, pos]) - 返回 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]]]]]]]) - 从年、月、周、天、小时、分钟和秒创建间隔。

参数

years - 年数，可以是正数或负数
months - 月数，可以是正数或负数
weeks - 周数，可以是正数或负数
days - 天数，可以是正数或负数
hours - 小时数，可以是正数或负数
mins - 分钟数，可以是正数或负数
secs - 秒数，小数部分以微秒精度表示。

示例

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

自 3.0.0

make_timestamp

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

参数

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

示例

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

自 3.0.0

make_timestamp_ltz

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

参数

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

示例

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

自 3.4.0

make_timestamp_ntz

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

参数

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

示例

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

自 3.4.0

make_ym_interval

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

参数

years - 年数，可以是正数或负数
months - 月数，可以是正数或负数

示例

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

自 3.2.0

map

map(key0, value0, key1, value1, ...) - 使用给定的键/值对创建映射。

示例

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

自 2.0.0

map_concat

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

示例

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

自 2.4.0

map_contains_key

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

示例

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

自 3.3.0

map_entries

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

示例

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

自 3.0.0

map_filter

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

示例

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

自 3.0.0

map_from_arrays

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

示例

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

自 2.4.0

map_from_entries

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

示例

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

自 2.4.0

map_keys

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

示例

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

自 2.0.0

map_values

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

示例

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

自 2.0.0

map_zip_with

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

示例

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

自 3.0.0

mask

mask(input[, upperChar, lowerChar, digitChar, otherChar]) - 屏蔽给定的字符串值。该函数将字符替换为“X”或“x”，将数字替换为“n”。这对于创建删除了敏感信息的表副本非常有用。

参数

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

示例

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

自 3.4.0

max

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

示例

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

自 1.0.0

max_by

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

示例

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

自 3.0.0

md5

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

示例

> SELECT md5('Spark');
 8cde774d6f7333752ed72cacddb05126

自 1.5.0

mean

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

示例

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

自 1.0.0

median

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

示例

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

自 3.4.0

min

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

示例

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

自 1.0.0

min_by

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

示例

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

自 3.0.0

minute

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

示例

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

自 1.5.0

mod

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

示例

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

自 1.0.0

mode

mode(col) - 返回 col 中值的最频繁值。忽略 NULL 值。如果所有值均为 NULL 或有 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 值。偏移量从 1 开始。如果 ignoreNulls=true，则在查找第 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) - 将每个窗口分区的行划分为从 1 到最多 n 的 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 - 逻辑或。

示例

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

自 1.0.0

overlay

overlay(input, replace, pos[, len]) - 将 input 中从 pos 开始且长度为 len 的部分替换为 replace。

示例

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

自 3.0.0

parse_url

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

示例

> SELECT parse_url('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 - 这是排名的依据；其中一个子项的值发生变化将触发排名的变化。这是一个内部参数，将由分析器分配。

示例

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

自 2.0.0

percentile

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

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

示例

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

自 2.1.0

percentile_approx

percentile_approx(col, percentage [, accuracy]) - 返回数值或 ANSI 间隔列 col 的近似 percentile，它是排序后的 col 值（从小到大切排序）中的最小值，使得不超过 percentage 的 col 值小于或等于该值。百分比值必须介于 0.0 和 1.0 之间。accuracy 参数（默认值：10000）是一个正数，用于控制近似精度，但会增加内存消耗。accuracy 值越大，精度越高，1.0/accuracy 是近似的相对误差。当 percentage 是一个数组时，百分比数组的每个值必须介于 0.0 和 1.0 之间。在这种情况下，返回列 col 在给定百分比数组处的近似百分位数数组。

示例

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

自 2.1.0

pi

pi() - 返回圆周率。

示例

> SELECT pi();
 3.141592653589793

自 1.5.0

pmod

pmod(expr1, expr2) - 返回 expr1 模 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]) - 返回 substr 在 str 中从位置 pos 开始的第一次出现的位置。给定的 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 - 这是排名的依据；其中一个子项的值发生变化将触发排名的变化。这是一个内部参数，将由分析器分配。

示例

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

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

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

示例

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

注意

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

自 3.2.0

regexp_count

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

参数

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

示例

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

自 3.4.0

regexp_extract

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

参数

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

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

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

示例

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

自 1.5.0

regexp_extract_all

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

参数

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

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

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

示例

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

自 3.1.0

regexp_instr

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

参数

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

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

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

示例

> SELECT regexp_instr('[email protected]', '@[^.]*');
 5

自 3.4.0

regexp_like

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

参数

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

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

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

示例

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

注意

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

自 3.2.0

regexp_replace

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

参数

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

从 Spark 2.0 开始，字符串字面量（包括正则表达式模式）在我们的 SQL 解析器中是未转义的。例如，要匹配 "\abc"，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 - 表示正则表达式的字符串。正则表达式字符串应为 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 或 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 - 一个字符串表达式。正则表达式字符串应为 Java 正则表达式。

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

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

示例

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

注意

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

自 1.0.0

round

round(expr, d) - 使用 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 - 一个字符串，指定会话的超时，表示为“间隔值”（有关更多详细信息，请参阅间隔字面量），用于固定间隔持续时间，或者一个应用于每个输入并评估为“间隔值”的表达式，用于动态间隔持续时间。

示例

> 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) - 返回 SHA-2 系列的校验和，作为 expr 的十六进制字符串。支持 SHA-224、SHA-256、SHA-384 和 SHA-512。位长度为 0 等于 256。

示例

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

自 1.5.0

shiftleft

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

示例

> SELECT shiftleft(2, 1);
 4

自 1.5.0

shiftright

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

示例

> SELECT shiftright(4, 1);
 2

自 1.5.0

shiftrightunsigned

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

示例

> SELECT shiftrightunsigned(4, 1);
 2

自 1.5.0

shuffle

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

示例

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

注意

该函数是非确定性的。

自 2.4.0

sign

sign(expr) - 当 expr 为负数、0 或正数时，分别返回 -1.0、0.0 或 1.0。

示例

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

自 1.4.0

signum

signum(expr) - 当 expr 为负数、0 或正数时，分别返回 -1.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 输入返回 null。否则，该函数对于 null 输入返回 -1。默认情况下，该函数对于 null 输入返回 -1。

示例

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

自 1.5.0

skewness

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

示例

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

自 1.6.0

slice

slice(x, start, length) - 从索引 start（数组索引从 1 开始，如果 start 为负数，则从末尾开始）开始，对数组 x 进行长度为 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 元素。在升序排序中，空元素将放置在返回数组的开头；在降序排序中，空元素将放置在返回数组的末尾。

示例

> 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) - 按分隔符拆分 str，并返回拆分的请求部分（从 1 开始）。如果任何输入为 null，则返回 null。如果 partNum 超出拆分部分的范围，则返回空字符串。如果 partNum 为 0，则抛出错误。如果 partNum 为负数，则从字符串的末尾开始倒计数部分。如果 delimiter 是空字符串，则不拆分 str。

示例

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

自 3.3.0

sqrt

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

示例

> SELECT sqrt(4);
 2.0

自 1.1.1

stack

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

示例

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

自 2.0.0

startswith

startswith(left, right) - 返回一个布尔值。如果 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, ...) - 使用给定的字段值创建结构体。

示例

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

自 1.4.0

substr

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

substr(str FROM pos[ FOR len]]) - 返回 str 中从 pos 开始且长度为 len 的子字符串，或者从 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]) - 返回 str 中从 pos 开始且长度为 len 的子字符串，或者从 pos 开始且长度为 len 的字节数组切片。

substring(str FROM pos[ FOR len]]) - 返回 str 中从 pos 开始且长度为 len 的子字符串，或者从 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 中在出现 count 次分隔符 delim 之前的子字符串。如果 count 为正数，则返回最后一个分隔符（从左侧开始计数）左侧的所有内容。如果 count 为负数，则返回最后一个分隔符（从右侧开始计数）右侧的所有内容。函数 substring_index 在搜索 delim 时执行区分大小写的匹配。

示例

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

自 1.5.0

sum

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

示例

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

自 1.0.0

tan

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

参数

expr - 弧度角

示例

> SELECT tan(0);
 0.0

自 1.4.0

tanh

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

参数

expr - 双曲角

示例

> SELECT tanh(0);
 0.0

自 1.4.0

timestamp

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

自 2.0.1

timestamp_micros

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

示例

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

自 3.1.0

timestamp_millis

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

示例

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

自 3.1.0

timestamp_seconds

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

示例

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

自 3.1.0

tinyint

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

自 2.0.1

to_binary

to_binary(str[, fmt]) - 根据提供的 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) - 使用函数转换映射中的元素。

示例

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

自 3.0.0

transform_values

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

示例

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

自 3.0.0

translate

translate(input, from, to) - 通过将 from 字符串中出现的字符替换为 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，并将日期的时间部分截断为格式模型 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 开始）索引处的数组元素。如果索引为 0，Spark 将抛出错误。如果索引 < 0，则从最后一个元素访问到第一个元素。如果索引超过数组的长度，则该函数始终返回 NULL。

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

示例

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

自 3.3.0

try_multiply

try_multiply(expr1, expr2) - 返回 expr1*expr2，如果发生溢出，则结果为 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 周是第 1 周，其中天数 >3。

示例

> SELECT weekofyear('2008-02-20');
 8

自 1.5.0

when

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

参数

expr1, expr3 - 分支条件表达式应均为布尔类型。
expr2, expr4, expr5 - 分支值表达式和 else 值表达式应均为相同类型或可强制转换为通用类型。

示例

> SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
 1.0
> SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
 2.0
> SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END;
 NULL

自 1.0.1

width_bucket

width_bucket(value, min_value, max_value, num_bucket) - 返回在 min_value 到 max_value 范围内具有 num_bucket 个桶的等宽直方图中 value 将分配到的桶号。

示例

> SELECT width_bucket(5.3, 0.2, 10.6, 5);
 3
> SELECT width_bucket(-2.1, 1.3, 3.4, 3);
 0
> SELECT width_bucket(8.1, 0.0, 5.7, 4);
 5
> SELECT width_bucket(-0.9, 5.2, 0.5, 2);
 3
> SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
 1
> SELECT width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
 2
> SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
 1
> SELECT width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
 2

自 3.1.0

window

window(time_column, window_duration[, slide_duration[, start_time]]) - 给定指定列的时间戳，将行分组到一个或多个时间窗口中。窗口开始是包含的，但窗口结束是排除的，例如 12:05 将在窗口 [12:05,12:10) 中，但不在 [12:00,12:05) 中。窗口可以支持微秒精度。不支持月份顺序的窗口。有关详细说明和示例，请参阅结构化流指南文档中的“事件时间上的窗口操作”。

参数

time_column - 用作时间窗口化的时间戳的列或表达式。时间列必须是 TimestampType。
window_duration - 一个字符串，指定表示为“间隔值”的窗口宽度。（有关更多详细信息，请参阅间隔文字。）请注意，持续时间是固定的时间长度，不会随时间根据日历而变化。
slide_duration - 一个字符串，指定表示为“间隔值”的窗口滑动间隔。每 slide_duration 将生成一个新窗口。必须小于或等于 window_duration。此持续时间同样是绝对的，不会随时间根据日历而变化。
start_time - 相对于 1970-01-01 00:00:00 UTC 的偏移量，用于启动窗口间隔。例如，为了获得在整点后 15 分钟开始的小时滚动窗口，例如 12:15-13:15、13:15-14:15...，请提供 start_time 为 15 分钟。

示例

> SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, start;
  A1    2021-01-01 00:00:00 2021-01-01 00:05:00 2
  A1    2021-01-01 00:05:00 2021-01-01 00:10:00 1
  A2    2021-01-01 00:00:00 2021-01-01 00:05:00 1
> SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '10 minutes', '5 minutes') ORDER BY a, start;
  A1    2020-12-31 23:55:00 2021-01-01 00:05:00 2
  A1    2021-01-01 00:00:00 2021-01-01 00:10:00 3
  A1    2021-01-01 00:05:00 2021-01-01 00:15:00 1
  A2    2020-12-31 23:55:00 2021-01-01 00:05:00 1
  A2    2021-01-01 00:00:00 2021-01-01 00:10:00 1

自 2.0.0

window_time

window_time(window_column) - 从时间/会话窗口列中提取时间值，该值可用于窗口的事件时间值。提取的时间是 (window.end - 1)，它反映了聚合窗口具有独占上限的事实 - [start, end)。有关详细说明和示例，请参阅结构化流指南文档中的“事件时间上的窗口操作”。

参数

window_column - 表示时间/会话窗口的列。

示例

> SELECT a, window.start as start, window.end as end, window_time(window), cnt FROM (SELECT a, window, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, window.start);
  A1    2021-01-01 00:00:00 2021-01-01 00:05:00 2021-01-01 00:04:59.999999  2
  A1    2021-01-01 00:05:00 2021-01-01 00:10:00 2021-01-01 00:09:59.999999  1
  A2    2021-01-01 00:00:00 2021-01-01 00:05:00 2021-01-01 00:04:59.999999  1

自 3.4.0

xpath

xpath(xml, xpath) - 返回 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"]

自 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) - 使用函数将两个给定数组按元素合并到一个数组中。如果一个数组较短，则在应用函数之前，会在末尾追加空值以匹配较长数组的长度。

示例

> SELECT zip_with(array(1, 2, 3), array('a', 'b', 'c'), (x, y) -> (y, x));
 [{"y":"a","x":1},{"y":"b","x":2},{"y":"c","x":3}]
> SELECT zip_with(array(1, 2), array(3, 4), (x, y) -> x + y);
 [4,6]
> SELECT zip_with(array('a', 'b', 'c'), array('d', 'e', 'f'), (x, y) -> concat(x, y));
 ["ad","be","cf"]

自 2.4.0

|

expr1 | expr2 - 返回 expr1 和 expr2 的按位或运算结果。

示例

> SELECT 3 | 5;
 7

自 1.4.0

||

expr1 || expr2 - 返回 expr1 和 expr2 的串联。

示例

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

注意

|| 对于数组，自 2.4.0 起可用。

自 2.3.0

~

~ expr - 返回 expr 的按位非运算结果。

示例

> SELECT ~ 0;
 -1

自 1.4.0