Array Functions and Operators

    The || operator is used to concatenate an array with an array or an element of the same type:

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

    array_distinct(x) -> array

    Remove duplicate values from the array x.

    array_intersect(x, y)-> array

    Returns an array of the elements in the intersection of x and y, without duplicates.

    array_union(x, y) -> array

    Returns an array of the elements in the union of x and y, without duplicates.

    array_except(x, y) -> array

    Returns an array of elements in x but not in y, without duplicates.

    array_join(x, delimiter, null_replacement) -> varchar

    Concatenates the elements of the given array using the delimiter and an optional string to replace nulls.

    array_max(x) -> x

    Returns the maximum value of input array.

    array_min(x) -> x

    Returns the minimum value of input array.

    array_position(x, element) -> bigint

    Returns the position of the first occurrence of the element in array x (or 0 if not found).

    array_remove(x, element) -> array

    Remove all elements that equal element from array x.

    array_sort(x) -> array

    Sorts and returns the array x. The elements of x must be orderable. Null elements will be placed at the end of the returned array.

    **array_sort(array(T), function(T,T,int)) ** -> array(T)

    1. 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]
    2. SELECT array_sort(ARRAY ['bc', 'ab', 'dc'], (x, y) -> IF(x < y, 1, IF(x = y, 0, -1))); -- ['dc', 'bc', 'ab']
    3. SELECT array_sort(ARRAY [3, 2, null, 5, null, 1, 2], -- sort null first with descending order
    4.                   (x, y) -> CASE WHEN x IS NULL THEN -1
    5.                                  WHEN y IS NULL THEN 1
    6.                                  WHEN x < y THEN 1
    7.                                  WHEN x = y THEN 0
    8. SELECT array_sort(ARRAY [3, 2, null, 5, null, 1, 2], -- sort null last with descending order
    9.                   (x, y) -> CASE WHEN x IS NULL THEN 1
    10.                                  WHEN y IS NULL THEN -1
    11.                                  WHEN x < y THEN 1
    12.                                  WHEN x = y THEN 0
    13.                                  ELSE -1 END); -- [5, 3, 2, 2, 1, null, null]
    14. SELECT array_sort(ARRAY ['a', 'abcd', 'abc'], -- sort by string length
    15.                   (x, y) -> IF(length(x) < length(y),
    16.                                -1,
    17.                                IF(length(x) = length(y), 0, 1))); -- ['a', 'abc', 'abcd']
    18. SELECT array_sort(ARRAY [ARRAY[2, 3, 1], ARRAY[4, 2, 1, 4], ARRAY[1, 2]], -- sort by array length
    19.                   (x, y) -> IF(cardinality(x) < cardinality(y),
    20.                                -1,

    arrays_overlap(x, y) -> boolean

    Tests if arrays x and y have any any non-null elements in common. Returns null if there are no non-null elements in common but either array contains null.

    cardinality(x) -> bigint

    Returns the cardinality (size) of the array x.

    concat(array1, array2, …, arrayN) -> array

    Concatenates the arrays array1, array2, ..., arrayN. This function provides the same functionality as the SQL-standard concatenation operator (||).

    combinations(array(T), n) -> array(array(T))

    Returns n-element subgroups of input array. If the input array has no duplicates, combinations returns n-element subsets:

    Order of subgroups is deterministic but unspecified. Order of elements within a subgroup deterministic but unspecified. n must be not be greater than 5, and the total size of subgroups generated must be smaller than 100000.

    contains(x, element) -> boolean

    Returns true if the array x contains the element.

    element_at(array(E), index) -> E

    Returns element of array at given index. If index > 0, this function provides the same functionality as the SQL-standard subscript operator ([]). If index < 0, element_at accesses elements from the last to the first.

    filter(array(T), function(T,boolean)) -> array(T)

    Constructs an array from those elements of array for which function returns true:

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

    flatten(x) -> array

    Flattens an array(array(T)) to an array(T) by concatenating the contained arrays.

    ngrams(array(T), n) -> array(array(T))

    Returns n-grams (sub-sequences of adjacent n elements) for the array. The order of the n-grams in the result is unspecified:

    1. SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 2); -- [['foo', 'bar'], ['bar', 'baz'], ['baz', 'foo']]
    2. SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 3); -- [['foo', 'bar', 'baz'], ['bar', 'baz', 'foo']]
    3. SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 4); -- [['foo', 'bar', 'baz', 'foo']]
    4. SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 5); -- [['foo', 'bar', 'baz', 'foo']]
    5. 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). :

    repeat(element, count) -> array

    reverse(x) -> array

    Returns an array which has the reversed order of array x.

    sequence(start, stop) -> array(bigint)

    Generate a sequence of integers from start to stop, incrementing by 1 if start is less than or equal to stop, otherwise -1.

    sequence(start, stop, step) -> array(bigint)

    Generate a sequence of integers from start to stop, incrementing by step.

    sequence(start, stop) -> array(date)

    Generate a sequence of dates from start date to stop date, incrementing by 1 day if start date is less than or equal to stop date, otherwise -1 day.

    sequence(start, stop, step) -> array(date)

    Generate a sequence of dates from start to stop, incrementing by step. The type of step can be either INTERVAL DAY TO SECOND or INTERVAL YEAR TO MONTH.

    sequence(start, stop, step) -> array(timestamp)

    Generate a sequence of timestamps from start to stop, incrementing by step. The type of step can be either INTERVAL DAY TO SECOND or INTERVAL YEAR TO MONTH.

    shuffle(x) -> array

    Generate a random permutation of the given array x.

    slice(x, start, length) -> array

    Subsets array x starting from index start (or starting from the end if start is negative) with a length of length.

    transform(array(T), function(T,U)) -> array(U)

    Returns an array that is the result of applying function to each element of array:

    1. SELECT transform(ARRAY [], x -> x + 1); -- []
    2. SELECT transform(ARRAY [5, 6], x -> x + 1); -- [6, 7]
    3. SELECT transform(ARRAY [5, NULL, 6], x -> COALESCE(x, 0) + 1); -- [6, 1, 7]
    4. SELECT transform(ARRAY ['x', 'abc', 'z'], x -> x || '0'); -- ['x0', 'abc0', 'z0']
    5. SELECT transform(ARRAY [ARRAY [1, NULL, 2], ARRAY[3, NULL]], a -> filter(a, x -> x IS NOT NULL)); -- [[1, 2], [3]]

    zip(array1, array2[, …]) -> array(row)

    Merges the given arrays, element-wise, into a single array of rows. The M-th element of the N-th argument will be the N-th field of the M-th output element. If the arguments have an uneven length, missing values are filled with NULL. :

      zip_with(array(T), array(U), function(T,U,R)) -> array(R)

      Merges the two given arrays, element-wise, into a single array using . If one array is shorter, nulls are appended at the end to match the length of the longer array, before applying function: