Apache Spark 2.4 新增内置函数和高阶函数使用介绍

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

• 1 针对数组类型的函数
  • 1.1 array_distinct
  • 1.2 array_intersect
  • 1.3 array_union
  • 1.4 array_except
  • 1.5 array_join
  • 1.6 array_max
  • 1.7 array_min
  • 1.8 array_position
  • 1.9 array_remove
  • 1.10 arrays_overlap
  • 1.11 array_sort
  • 1.12 concat
  • 1.13 flatten
  • 1.14 array_repeat
  • 1.15 reverse
  • 1.16 sequence
  • 1.17 shuffle
  • 1.18 slice
  • 1.19 array_zip
• 2 针对 map 类型的函数
  • 2.1 map_form_arrays
  • 2.2 map_from_entries
  • 2.3 map_concat
• 3 针对数组和 map 类型的函数
  • 3.1 element_at
  • 3.2 cardinality
• 4 高阶函数
  • 4.1 transform
  • 4.2 filter
  • 4.3 aggregate
  • 4.4 exists
  • 4.5 zip_with

针对数组类型的函数

array_distinct

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

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

 

[1,2,3,null]

array_intersect

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

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

 

[1,3]

array_union

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

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

 

[1,2,3,5]

array_except

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

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

 

[2]

array_join

array_join(array, 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：返回数组中的最大值， null 元素将会被忽略。

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

 

20

array_min

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

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

 

1

array_position

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

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

 

3

array_remove

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

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

 

[1,2,null]

arrays_overlap

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

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

 

true

array_sort

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

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

 

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

concat

concat(String, ...): String / concat(array, ...): array：返回 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：将数组的数组转换为数组。

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

 

[1,2,3,4]

array_repeat

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

SELECT array_repeat('123', 2);

 

["123","123"]

reverse

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

SELECT reverse('Spark SQL');

 

LQS krapS

 

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

 

[3,4,1,2]

sequence

sequence(T, T[, T]): array：生成从 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): array：返回给定数组的随机排列。

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, Int, Int): array：从 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, array, ...): array>：返回一个合并的结构数组，其中第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, array): map：通过给定的 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>): map：从结构体中返回一个 map。

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

 

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

map_concat

map_concat(map, ...): map：返回多个 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, Int): T / element_at(map, 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): Int / cardinality(map): Int：size 的别名。返回给定数组或 map 的大小；如果数组或 map 为 null，则返回 -1。

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

 

4

高阶函数

transform

transform(array, function): array 和 transform(array function): array：使用给定函数转换数组中的元素。如果 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, function): array：使用给定的谓词过滤给定数组的元素。

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

 

[1,3]

aggregate

aggregate(array, A, function[, function]): 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, function): Boolean：判断数组里面是否有元素符合给定谓词。

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

 

true

zip_with

zip_with(array, array, function): array：使用函数将两个给定数组（按元素）合并为单个数组。 如果其中一个数组较短，则在应用函数之前，在短数组的末尾附加 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"]