Apache Spark 2.4 新增了24个内置函数和5个高阶函数，本文将对这29个函数的使用进行介绍。关于 Apache Spark 2.4 的新特性，可以参见 《Apache Spark 2.4 正式发布，重要功能详细介绍》。

如果想及时了解Spark、Hadoop或者Hbase相关的文章，欢迎关注微信公共帐号：iteblog_hadoop

针对数组类型的函数

array_distinct

array_distinct(array<T>): array<T> ：从给定数组中删除重复值。使用如下：

SELECT array_distinct(array(1, 2, 3, null, 3));

[1,2,3,null]

array_intersect

array_intersect(array<T>, array<T>): array<T>：返回给定两个数组元素的交集，结果已经去重了。使用如下：

SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));

[1,3]

array_union

array_union(array<T>, array<T>): array<T>：返回给定两个数组元素的并集，结果已经去重了。使用如下：

SELECT array_union(array(1, 2, 3), array(1, 3, 5));

[1,2,3,5]

array_except

array_except(array<T>, array<T>): array<T>：返回只在数组1而不在数组2的元素，结果已经去重了。使用如下：

SELECT array_except(array(1, 2, 3), array(1, 3, 5));

[2]

array_join

array_join(array<String>, String[, String]): String：使用分隔符将数组的元素进行拼接。另外，我们还可以指定可选的字符来替换 null 值。如果我们没有指定 null 值的替换字符串，那么结果中将会把 null 值替换掉。

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

array_max

array_max(array<T>): T：返回数组中的最大值， null 元素将会被忽略。

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

20

array_min

array_min(array<T>): T：返回数组中的最小值， null 元素将会被忽略。

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

1

array_position

array_position(array<T>, T): Long：返回元素 T 在数组第一次出现的位置，从1开始算。

SELECT array_position(array(3, 2, 1), 1);

3

array_remove

array_remove(array<T>, T): array<T>：从给定数组中删除所有与给定元素相等的元素。

SELECT array_remove(array(1, 2, 3, null, 3), 3);

[1,2,null]

arrays_overlap

arrays_overlap(array<T>, array<T>): array<T>：如果数组1最少包含数组2中一个非空的元素，则返回 true；如果两个数组没有公共元素，而且两个数组均为空则返回 false，如果其中任何一个数组包含 null 元素则返回 null。

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

true

array_sort

array_sort(array<T>): array<T>：按升序对输入数组进行排序。输入数组的元素必须是可排序的。null 元素将放置在返回数组的末尾。

SELECT array_sort(array('b', 'd', null, 'c', 'a'));

["a","b","c","d",null]

concat

concat(String, ...): String / concat(array<T>, ...): array<T>：返回 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]

flatten

flatten(array<array<T>>): array<T>：将数组的数组转换为数组。

SELECT flatten(array(array(1, 2), array(3, 4)));

[1,2,3,4]

array_repeat

array_repeat(T, Int): array<T>：返回包含元素计数次数的数组。

SELECT array_repeat('123', 2);

["123","123"]

reverse

reverse(String): String / reverse(array<T>): array<T>：将字符串进行反转，或者将数组的元素顺序进行反转。

SELECT reverse('Spark SQL');

LQS krapS

SELECT reverse(array(2, 1, 4, 3));

[3,4,1,2]

sequence

sequence(T, T[, T]): array<T>：生成从 start 到 stop（包括）的元素数组，逐步递增。返回元素的类型与参数表达式的类型相同。

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

shuffle

shuffle(array<T>): array<T>：返回给定数组的随机排列。

SELECT shuffle(array(1, 20, 3, 5));

[3,5,1,20]

SELECT shuffle(array(1, 20, null, 3));

[null,3,20,1]

slice

slice(array<T>, Int, Int): array<T>：从 start 索引位置开始从数组中截取 length 长度的子数组；如果 start 为负数，则从后面向前截取。

SELECT slice(array(1, 2, 3, 4), 2, 2);

[2,3]

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

[3,4]

array_zip

array_zip(array<T>, array<U>, ...): array<struct<T, U, ...>>：返回一个合并的结构数组，其中第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}]

针对 map 类型的函数

map_form_arrays

map_form_arrays(array<K>, array<V>): map<K, V>：通过给定的 key value 数组对组合一个 map，key 不能包含 null 值。

SELECT map_from_arrays(array(1.0, 3.0), array('2', '4'));

{"1.0":"2","3.0":"4"}

map_from_entries

map_from_entries(array<struct<K, V>>): map<K, V>：从结构体中返回一个 map。

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

{"1":"a","2":"b"}

map_concat

map_concat(map<K, V>, ...): map<K, V>：返回多个 map 的并集。

SELECT map_concat(map(1, 'a', 2, 'b'), map(2, 'c', 3, 'd'));

{"1":"a","2":"c","3":"d"}

针对数组和 map 类型的函数

element_at

element_at(array<T>, Int): T / element_at(map<K, V>, K): V：对于数组，返回给定索引位置（从1开始算）在对应数组里面的值；如果 index < 0，则从后往前算；如果给定的索引大于数组的长度，则返回 null。对于 map，返回给定 key 对应的值；如果 map 中不包含这个 key，则返回 null。

SELECT element_at(array(1, 2, 3), 2);

2

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

b

cardinality

cardinality(array<T>): Int / cardinality(map<K, V>): Int：size 的别名。返回给定数组或 map 的大小；如果数组或 map 为 null，则返回 -1。

SELECT cardinality(array('b', 'd', 'c', 'a'));

4

高阶函数

transform

transform(array<T>, function<T, U>): array<U> 和 transform(array<T> function<T, Int, U>): array<U>：使用给定函数转换数组中的元素。如果 lambda 函数有两个参数，则第二个参数代表这个元素的索引。

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]

filter

filter(array<T>, function<T, Boolean>): array<T>：使用给定的谓词过滤给定数组的元素。

SELECT filter(array(1, 2, 3), x -> x % 2 == 1);

[1,3]

aggregate

aggregate(array<T>, A, function<A, T, A>[, function<A, R>]): R：将二元运算符应用于初始的 state 和数组中的所有元素，并返回单个值。

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

exists

exists(array<T>, function<T, Boolean>): Boolean：判断数组里面是否有元素符合给定谓词。

SELECT exists(array(1, 2, 3), x -> x % 2 == 0);

true

zip_with

zip_with(array<T>, array<U>, function<T,U,R>): array<R>：使用函数将两个给定数组（按元素）合并为单个数组。 如果其中一个数组较短，则在应用函数之前，在短数组的末尾附加 null 值以匹配较长数组的长度。

SELECT zip_with(array(1, 2, 3), array('a', 'b', 'c'), (x, y) -> (y, x));

[{"y":"a","x":1},{"y":"b","x":2},{"y":"c","x":3}]

SELECT zip_with(array(1, 2), array(3, 4), (x, y) -> x + y);

[4,6]

SELECT zip_with(array('a', 'b', 'c'), array('d', 'e', 'f'), (x, y) -> concat(x, y));

["ad","be","cf"]