Presto--数组函数和运算符_presto数组函数-CSDN博客

本文链接：https://blog.csdn.net/qq_35531549/article/details/90411388

本文介绍了Presto中的数组操作，包括脚标运算符[]用于访问数组元素，连接运算符||用于合并数组，以及各种数组函数，如去除重复值、求交集、并集、差集等。此外，还涵盖了排序、查找、过滤、转换等功能，帮助理解Presto对数组的全面支持。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组函数和运算符

脚标运算符：[]

[]用于访问一个数组的元素，并从1开始索引：

SELECT  my_array [ 1 ]  AS  first_element

连接运算符：||

||用来连接相同类型的数组或者元素：

SELECT  ARRAY  [ 1 ]  ||  ARRAY  [ 2 ];  -  [1,2] 
SELECT  ARRAY  [ 1 ]  ||  2 ;  -  [1,2] 
SELECT  2  ||  ARRAY  [ 1 ];   -  [2,1]

数组函数

array_distinct（x ） →数组

从数组中删除重复的值x。
array_intersect（x，y ） →数组

返回x和y的交集中的不重复元素。
array_union（x，y ） →数组

返回x和y的并集中的不重复元素。
array_except（x，y ） →数组

返回属于x但不属于y的不重复元素。（差集）
array_join（x，delimiter，null_replacement ） →varchar

使用delimiter界定符连接x给定数组的元素并且用null_replacement可选字符串来填充数组里面的空值。
array_max（x ） →x

返回输入数组的最大值。
array_min（x ） →x

返回输入数组的最小值。
array_position（x，element） →bigint

返回数组x中第一次出现元素element的位置（数字）（如果未找到，则返回0）。
array_remove（x，元素） →数组

删除数组x中和element相同的所有元素。
array_sort（x ） →数组

排序x并返回数组。x的元素必须是可排序的。空元素将放置在返回数组的末尾。
array_sort（array（T），function（T，T，int）） - > array（T ）

array根据给定的比较函数function排序并返回。比较函数采用两个可空的参数来表示array两个可以为空的元素。当第一个可空元素小于，等于或大于第二个可空元素时，它返回-1,0或1。如果比较函数返回其他值（包括NULL），则查询将失败并引发错误

SELECT array_sort(ARRAY [3, 2, 5, 1, 2], (x, y) -> IF(x < y, 1, IF(x = y, 0, -1))); -- [5, 3, 2, 2, 1]
SELECT array_sort(ARRAY ['bc', 'ab', 'dc'], (x, y) -> IF(x < y, 1, IF(x = y, 0, -1))); -- ['dc', 'bc', 'ab']
SELECT array_sort(ARRAY [3, 2, null, 5, null, 1, 2], -- sort null first with descending order
                  (x, y) -> CASE WHEN x IS NULL THEN -1
                                 WHEN y IS NULL THEN 1
                                 WHEN x < y THEN 1
                                 WHEN x = y THEN 0
                                 ELSE -1 END); -- [null, null, 5, 3, 2, 2, 1]
SELECT array_sort(ARRAY [3, 2, null, 5, null, 1, 2], -- sort null last with descending order
                  (x, y) -> CASE WHEN x IS NULL THEN 1
                                 WHEN y IS NULL THEN -1
                                 WHEN x < y THEN 1
                                 WHEN x = y THEN 0
                                 ELSE -1 END); -- [5, 3, 2, 2, 1, null, null]
SELECT array_sort(ARRAY ['a', 'abcd', 'abc'], -- sort by string length
                  (x, y) -> IF(length(x) < length(y),
                               -1,
                               IF(length(x) = length(y), 0, 1))); -- ['a', 'abc', 'abcd']
SELECT array_sort(ARRAY [ARRAY[2, 3, 1], ARRAY[4, 2, 1, 4], ARRAY[1, 2]], -- sort by array length
                  (x, y) -> IF(cardinality(x) < cardinality(y),
                               -1,
                               IF(cardinality(x) = cardinality(y), 0, 1))); -- [[1, 2], [2, 3, 1], [4, 2, 1, 4]]

arrays_overlap（x，y ） →布尔值

测试数组x和y是否有任何共同的非空元素。如果没有公共的非空元素，但是两个数组都包含null，则返回null。。
cardinality（x ） →bigint

返回数组的基数（大小）。
concat（array1，array2，…，arrayN ） →数组

连接数组array1，array2，...，arrayN。此函数提供与SQL标准串联运算符（||）相同的功能。
contains（x，元素） →布尔值

如果数组x包含元素 element，则返回true。
element_at（数组（E），索引） →E

返回array给定的元素是否在给定的索引index。如果index> 0，则此函数提供与SQL标准下标运算符（[]）相同的功能。如果index<0，则element_at从最后到第一个的元素访问到第一个元素。
filter（array（T），function（T，boolean）） - > array（T ）

把函数function返回true的元素来构造新数组：

SELECT filter(ARRAY [], x -> true); -- []
SELECT filter(ARRAY [5, -6, NULL, 7], x -> x > 0); -- [5, 7]
SELECT filter(ARRAY [5, NULL, 7, NULL], x -> x IS NOT NULL); -- [5, 7]

flatten（x ） →数组
Flattens an array(array(T)) to an array(T) by concatenating the contained arrays.
ngrams(array(T), n) -> array(array(T))
Returns n-grams for the array:

SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 2); -- [['foo', 'bar'], ['bar', 'baz'], ['baz', 'foo']]
SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 3); -- [['foo', 'bar', 'baz'], ['bar', 'baz', 'foo']]
SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 4); -- [['foo', 'bar', 'baz', 'foo']]
SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 5); -- [['foo', 'bar', 'baz', 'foo']]
SELECT ngrams(ARRAY[1, 2, 3, 4], 2); -- [[1, 2], [2, 3], [3, 4]]

reduce(array(T), initialState S, inputFunction(S, T, S), outputFunction(S, R)) → R
Returns a single value reduced from array. inputFunction will be invoked for each element in array in order. In addition to taking the element, inputFunction takes the current state, initially initialState, and returns the new state. outputFunction will be invoked to turn the final state into the result value. It may be the identity function (i -> i).

SELECT reduce(ARRAY [], 0, (s, x) -> s + x, s -> s); -- 0
SELECT reduce(ARRAY [5, 20, 50], 0, (s, x) -> s + x, s -> s); -- 75
SELECT reduce(ARRAY [5, 20, NULL, 50], 0, (s, x) -> s + x, s -> s); -- NULL
SELECT reduce(ARRAY [5, 20, NULL, 50], 0, (s, x) -> s + COALESCE(x, 0), s -> s); -- 75
SELECT reduce(ARRAY [5, 20, NULL, 50], 0, (s, x) -> IF(x IS NULL, s, s + x), s -> s); -- 75
SELECT reduce(ARRAY [2147483647, 1], CAST (0 AS BIGINT), (s, x) -> s + x, s -> s); -- 2147483648
SELECT reduce(ARRAY [5, 6, 10, 20], -- calculates arithmetic average: 10.25
              CAST(ROW(0.0, 0) AS ROW(sum DOUBLE, count INTEGER)),
              (s, x) -> CAST