Presto数组函数

下标运算符：[]

该[]运算符用于访问数组的元素，并从 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]

数组函数

all_match( array(T) , function(T , boolean) ) → boolean#
返回数组的所有元素是否与给定的谓词匹配。true如果所有元素都匹配谓词，则返回（一种特殊情况是数组为空时）；false如果一个或多个元素不匹配；NULL如果谓词函数NULL为一个或多个元素以及true所有其他元素返回。

any_match( array(T) , function(T , boolean) ) → boolean#
返回数组的任何元素是否与给定的谓词匹配。true如果一个或多个元素与谓词匹配，则返回；false如果没有任何元素匹配（特殊情况是数组为空时）；NULL如果谓词函数NULL为一个或多个元素以及false 所有其他元素返回。

array_average（数组（双）） →双#
返回的所有非空元素的平均值array。如果没有非空元素，则返回 null。

array_distinct( x ) → array

从数组中删除重复值x。

array_dupes(数组(T)) -> 数组(bigint/varchar )#
返回在中多次出现的一组元素array。

T必须强制到bigint或varchar。

array_except( x , y ) → 数组#
返回一个包含 inx但不包含 in的元素数组y，没有重复项。

array_frequency( array(bigint)) -> map(bigint , int )#
返回一个映射：键是中的唯一元素array，值是键出现的次数。忽略空元素。空数组返回空映射。

array_frequency( array(varchar)) -> map(varchar , int )#
返回一个映射：键是中的唯一元素array，值是键出现的次数。忽略空元素。空数组返回空映射。

array_has_dupes(数组(T) ) → 布尔值#
返回一个布尔值：是否array有任何元素出现多次。

T必须强制到bigint或varchar。

array_intersect( x , y ) → 数组#
返回x和的交集中元素的数组y，没有重复项。

array_intersect( array(array(E))) -> array(bigint/double )#
返回给定数组中所有数组的交集元素的数组，没有重复项。E 必须是可强制的double。bigint如果 T 可强制转换为，则返回bigint。否则，返回double。

array_join( x , delimiter , null_replacement ) → varchar
-- 使用分隔符和可选字符串连接给定数组的元素以替换空值。

array_max( x ) → x
-- 返回输入数组的最大值。array_min( x ) → x
-- 返回输入数组的最小值。

array_normalize( x , p ) → 数组#
x通过将每个元素除以数组的 p 范数来规范化数组。它等价于，但reduce 部分只执行一次。如果数组为 null 或有 null 数组元素，则返回 null。TRANSFORM(array, v -> v / REDUCE(array, 0, (a, v) -> a + POW(ABS(v), p), a -> POW(a, 1 / p))

array_position( x ,元素) → bigint
-- 返回element数组中第一次出现的位置x（如果未找到则返回0）。

array_position( x ,元素,实例) → bigint#
如果，则返回in 数组中第实例次出现的位置。如果，则返回数组中最后一次出现的位置。如果没有找到匹配的元素实例，则返回。instance > 0elementxinstance < 0instanceelementx0

array_remove( x ,元素) → 数组#
element从 array 中删除所有相等的元素x。

array_sort( x ) → array
-- 排序并返回数组x。的元素x必须是可排序的。空元素将放置在返回数组的末尾。

array_sort(数组(T) ,函数(T , T , int)) -> 数组(T )#
array根据给定的 Comparator排序并返回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]]
Copy to clipboard
array_sum( array(T) ) → bigint/double#
返回的所有非空元素的总和array。如果没有非空元素，则返回0。行为类似于聚合函数sum()。

T必须是强制的double。bigint如果 T 可强制转换为，则返回bigint。否则，返回double。

arrays_overlap( x , y ) → 布尔值#
如果测试阵列x和y具有共同任何非空元素。如果没有共同的非空元素但任一数组包含空值，则返回空值。

array_union( x , y ) → 数组#
返回xand的联合中元素的数组y，没有重复项。

cardinality( x ) → bigint
-- 返回数组的基数（大小）x。

concat( array1 , array2 , ... , arrayN ) → array
-- 连接数组array1, array2, ..., arrayN。此函数提供与 SQL 标准连接运算符 ( ||)相同的功能。

combinations(数组(T) , n) -> 数组(数组(T) )#
返回输入数组的 n 元素组合。如果输入数组没有重复项，则combinations返回 n 元素子集。子组的顺序是确定性的但未指定。子组中元素的顺序是确定的但未指定。n不得大于 5，并且生成的子组总大小必须小于 100000：

SELECT combinations(ARRAY[‘foo’, ‘bar’, ‘boo’],2); --[[‘foo’, ‘bar’], [‘foo’, ‘boo’][‘bar’, ‘boo’]]
SELECT combinations(ARRAY[1,2,3,4,5],3); --[[1,2,3], [1,2,4], [1,3,4], [2,3,4]]
SELECT combinations(ARRAY[1,2,2],2); --[[1,2],[1,2],[2,2]]
Copy to clipboard
contains( x ,元素) → 布尔值#
如果数组x包含，则返回 true element。

element_at(数组(E) ,索引) → E#
返回array给定处的元素index。如果index> 0，则此函数提供与 SQL 标准下标运算符 ( [])相同的功能。如果index< 0，element_at则从最后一个到第一个访问元素。

filter( array(T) , function(T , boolean)) -> array(T )#
从构造的那些元件的阵列array用于它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]
Copy to clipboard
flatten( x ) → 数组#
通过连接包含的数组将an 展平array(array(T))为 an array(T)。

ngrams(数组(T) , n) -> 数组(数组(T) )#
返回n-grams 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]]
Copy to clipboard
none_match( array(T) , function(T , boolean) ) → boolean#
返回数组中是否没有任何元素与给定的谓词匹配。true如果没有任何元素与谓词匹配，则返回（特殊情况是数组为空时）；false如果一个或多个元素匹配； NULL如果谓词函数NULL为一个或多个元素以及false所有其他元素返回。

reduce( array(T) , initialState S , inputFunction(S , T , S) , outputFunction(S , R) ) → R#
返回从减少的单个值array。inputFunction将按array顺序为每个元素调用。除了获取元素之外，还inputFunction获取当前状态， initial initialState，并返回新状态。outputFunction将被调用以将最终状态转换为结果值。它可能是恒等函数 ( )。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(ROW(x + s.sum, s.count + 1) AS ROW(sum DOUBLE, count INTEGER)),
s -> IF(s.count = 0, NULL, s.sum / s.count));
Copy to clipboard
repeat(元素,计数) → 数组#
重复element的count次数。

reverse( x ) → array
--返回一个与 array 顺序相反的数组x。

sequence（开始，停止）#
生成从startto 开始的整数序列，如果小于或等于，则stop递增，否则为。1startstop-1

sequence（开始，停止，步骤）#
生成一个整数序列，从start到stop递增step。

sequence（开始，停止）#
生成从start日期到stop日期的日期序列，1如果start日期小于或等于stop日期，则按-1天递增，否则按天递增。

sequence（开始，停止，步骤）#
生成从start到的日期序列，以stop递增step。的类型step可以是或。INTERVAL DAY TO SECONDINTERVAL YEAR TO MONTH

sequence（开始，停止，步骤）#
生成从start到的时间戳序列，以stop递增step。的类型step可以是或。INTERVAL DAY TO SECONDINTERVAL YEAR TO MONTH

shuffle( x ) → array
-- 生成给定数组的随机排列x。

slice( x ,开始,长度) → 数组#
子集数组x从索引开始start（如果start是负数，则从末尾开始），长度为length.

transform(数组(T) ,函数(T , U)) -> 数组(U )#
返回一个数组，该数组是应用于function的每个元素的结果array：

SELECT transform(ARRAY [], x -> x + 1); – []
SELECT transform(ARRAY [5, 6], x -> x + 1); – [6, 7]
SELECT transform(ARRAY [5, NULL, 6], x -> COALESCE(x, 0) + 1); – [6, 1, 7]
SELECT transform(ARRAY [‘x’, ‘abc’, ‘z’], x -> x || ‘0’); – [‘x0’, ‘abc0’, ‘z0’]
SELECT transform(ARRAY [ARRAY [1, NULL, 2], ARRAY[3, NULL]], a -> filter(a, x -> x IS NOT NULL)); – [[1, 2], [3]]
Copy to clipboard
zip( array1, array2[, …]) -> array(row )#
将给定的数组按元素合并到单个行数组中。第 N 个参数的第 M 个元素将是第 M 个输出元素的第 N 个字段。如果参数的长度不均匀，则缺失值用NULL.

SELECT zip(ARRAY[1, 2], ARRAY[‘1b’, null, ‘3b’]); – [ROW(1, ‘1b’), ROW(2, null), ROW(null, ‘3b’)]
Copy to clipboard
zip_with(数组(T) ,数组(U) ,函数(T , U , R)) -> 数组(R )#
使用将两个给定的数组按元素合并为一个数组function。如果一个数组较短，则在应用之前将空值附加到末尾以匹配较长数组的长度function：

SELECT zip_with(ARRAY[1, 3, 5], ARRAY['a', 'b', 'c'], (x, y) -> (y, x)); -- [ROW('a', 1), ROW('b', 3), ROW('c', 5)]
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']
SELECT zip_with(ARRAY['a'], ARRAY['d', null, 'f'], (x, y) -> coalesce(x, y)); -- ['a', null, 'f']

参考

Array Functions and Operators — Presto 0.259.1 Documentation
https://prestodb.io/docs/current/functions/array.html