Функции для списков

`array_length()`

Описание	Возвращает длину списка.
Использование	`array_length(list)`

Посмотреть пример

SELECT
    array_length([1,2,3])             AS result_1,
    array_length(['Tengri'])          AS result_2,
    array_length(split('Tengri', '')) AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| 3        | 1        | 6        |
+----------+----------+----------+

`flatten()`

Описание	Принимает вложенный список и возвращает список, сокращенный на один уровень вложения.
Использование	`flatten(nested_list)`

Посмотреть пример

SELECT
    flatten([[1, 2], [3, 4, 5]])       AS result_1,
    flatten([[1], [2], [3], [4], [5]]) AS result_2;

+-------------+-------------+
| result_1    | result_2    |
+-------------+-------------+
| {1,2,3,4,5} | {1,2,3,4,5} |
+-------------+-------------+

`list_aggregate()`

Описание	Применяет заданную агрегатную функцию к заданному списку.
Использование	`list_aggregate(list, function_name, ...)`
Псевдонимы	`aggregate()`, `array_aggr()`, `array_aggregate()`, `list_aggr()`

Посмотреть пример

SELECT
    list_aggregate([1, 2, 3], 'max')                           AS result_1,
    list_aggregate([1, 2, 3], 'any_value')                     AS result_2,
    list_aggregate(['I', 'love', 'Tengri'], 'string_agg', ' ') AS result_3;

+----------+----------+---------------+
| result_1 | result_2 | result_3      |
+----------+----------+---------------+
| 3        | 1        | I love Tengri |
+----------+----------+---------------+

`list_concat()`

Описание	Объединяет несколько списков в один.
Использование	`list_concat(list_1, list_2 ...)`
Псевдонимы	`list_cat()`, `array_concat()`, `array_cat()`

Пустые значения (NULL) игнорируются.

См. также Оператор ||.

Посмотреть пример

SELECT
    list_concat([1,2,3], [4, 5])                    AS result_1,
    list_concat([1,2,3], NULL, [4, 5])              AS result_2,
    list_concat(['T', 'e'], ['n', 'g', 'r'], ['i']) AS result_3;

+-------------+-------------+---------------+
| result_1    | result_2    | result_3      |
+-------------+-------------+---------------+
| {1,2,3,4,5} | {1,2,3,4,5} | {T,e,n,g,r,i} |
+-------------+-------------+---------------+

`list_contains()`

Описание	Проверяет, входит ли элемент в список.
Использование	`list_contains(list, element)`
Псевдонимы	`array_contains()`, `array_has()`, `list_has()`

Посмотреть пример

SELECT
    list_contains([1,2,3], 3)          AS result_1,
    list_contains([1,2,3, NULL], 3)    AS result_2,
    list_contains([1,2,3, NULL], NULL) AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| true     | true     | null     |
+----------+----------+----------+

`list_cosine_distance()`

Описание	Вычисляет косинусное расстояние между двумя списками (числовыми векторами).
Использование	`list_cosine_distance(list_1, list_2)`

Посмотреть пример

SELECT
    list_cosine_distance([1, 2, 3], [1, 2, 3]) AS result_1,
    list_cosine_distance([1, 2, 3], [2, 4, 6]) AS result_2,
    list_cosine_distance([1, 2, 3], [5, 1, 9]) AS result_3;

+----------+----------+---------------------+
| result_1 | result_2 | result_3            |
+----------+----------+---------------------+
| 0        | 0        | 0.12153793814103686 |
+----------+----------+---------------------+

`list_cosine_similarity()`

Описание	Вычисляет косинусную близость между двумя списками (числовыми векторами).
Использование	`list_cosine_similarity(list_1, list_2)`

Посмотреть пример

SELECT
    list_cosine_similarity([1, 2, 3], [1, 2, 3]) AS result_1,
    list_cosine_similarity([1, 2, 3], [2, 4, 6]) AS result_2,
    list_cosine_similarity([1, 2, 3], [5, 1, 9]) AS result_3;

+----------+----------+--------------------+
| result_1 | result_2 | result_3           |
+----------+----------+--------------------+
| 1        | 1        | 0.8784620618589631 |
+----------+----------+--------------------+

`list_distance()`

Описание	Вычисляет евклидово расстояние между двумя точками, координаты которых заданы в виде списков.
Использование	`list_distance(list_1, list_2)`

Вычисляет евклидово расстояние между двумя точками, координаты которых заданы в виде списков — числовых векторов равной длины.

Посмотреть пример

SELECT
    list_distance([1, 2, 3], [1, 2, 3]) AS result_1,
    list_distance([1, 2, 3], [1, 2, 4]) AS result_2,
    list_distance([0, 0], [3, 4])       AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| 0        | 1        | 5        |
+----------+----------+----------+

`list_distinct()`

Описание	Удаляет из списка все дубликаты и пустые значения.
Использование	`list_distinct(list)`

Удаляет из списка все дубликаты и пустые значения. Не сохраняет исходный порядок элементов.

Посмотреть пример

SELECT
    list_distinct([1, 2, 3, 1, 2, 3]) AS result_1,
    list_distinct([1, 2, 3, NULL])    AS result_2,
    list_distinct([NULL])             AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| {3,2,1}  | {3,2,1}  | {}       |
+----------+----------+----------+

`list_extract()`

Описание	Возвращает элемент из списка по индексу.
Использование	`list_extract(list, index)`
Псевдонимы	`list_element()`

Нумерация элементов начинается с 1.

Посмотреть пример

SELECT
    list_extract(['A', 'B', 'C'], 1)   AS result_1,
    list_extract(['A',  NULL, 'C'], 2) AS result_2,
    list_extract(['A', 'B', 'C'], 5)   AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| A        | null     | null     |
+----------+----------+----------+

`list_grade_up()`

Описание	Возвращает отсортированный список исходных индексов элементов списка.
Использование	`list_grade_up(list)`
Псевдонимы	`array_grade_up()`, `grade_up()`

Нумерация элементов начинается с 1.

Посмотреть пример

SELECT
    list_grade_up([3, 2, 1, 0])    AS result_1,
    list_grade_up(['C', 'A', 'B']) AS result_1,
    list_grade_up([1, NULL, 2])    AS result_3;

+-----------+----------+----------+
| result_1  | result_1 | result_3 |
+-----------+----------+----------+
| {4,3,2,1} | {2,3,1}  | {1,3,2}  |
+-----------+----------+----------+

`list_has_all()`

Описание	Проверяет, что все элементы второго списка содержатся в первом списке.
Использование	`list_has_all(list_1, list_2)`
Псевдонимы	`array_has_all()`

Посмотреть пример

SELECT
    list_has_all([1, 2, 3], [1, 2])       AS result_1,
    list_has_all([1, 2, 3], [1, 2, NULL]) AS result_2,
    list_has_all([1, 2, 3], [1, 2, 3, 4]) AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| true     | true     | false    |
+----------+----------+----------+

`list_has_any()`

Описание	Проверяет, есть ли у двух списков хотя бы один общий элемент.
Использование	`list_has_any(list_1, list_2)`
Псевдонимы	`array_has_any()`

Посмотреть пример

SELECT
    list_has_any([1, 2, 3], [1, 4])       AS result_1,
    list_has_any([1, 2, 3], [1, 2, NULL]) AS result_2,
    list_has_any([1, 2, 3], [4])          AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| true     | true     | false    |
+----------+----------+----------+

`list_inner_product()`

Описание	Вычисляет скалярное произведение двух числовых векторов равной длины.
Использование	`list_inner_product(list_1, list_2)`
Псевдонимы	`list_dot_product()`

Посмотреть пример

SELECT
    list_inner_product([1, 2], [1, 2])       AS result_1,
    list_inner_product([1, -2], [-1, 2])     AS result_2,
    list_inner_product([1, 2, 3], [0, 0, 0]) AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| 5        | -5       | 0        |
+----------+----------+----------+

`list_negative_inner_product()`

Описание	Вычисляет скалярное произведение двух числовых векторов равной длины, умноженное на `-1`.
Использование	`list_negative_inner_product(list_1, list_2)`
Псевдонимы	`list_negative_dot_product()`

Посмотреть пример

SELECT
    list_negative_inner_product([1, 2], [1, 2])       AS result_1,
    list_negative_inner_product([1, -2], [-1, 2])     AS result_2,
    list_negative_inner_product([1, 2, 3], [0, 0, 0]) AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| -5       | 5        | 0        |
+----------+----------+----------+

`list_position()`

Описание	Возвращает индекс элемента в спике.
Использование	`list_position(list, element)`
Псевдонимы	`array_indexof()`, `array_position()`, `list_indexof()`

Возвращает индекс элемента в спике. Если элемент не найден, возвращает NULL. Если вхождений более одного, возвращает индекс первого вхождения.

Посмотреть пример

SELECT
    list_position(['A', 'B', 'C'], 'B')      AS result_1,
    list_position(['A', 'B', 'C'], 'X')      AS result_2,
    list_position(['A', 'B', 'A', 'C'], 'A') AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| 2        | null     | 1        |
+----------+----------+----------+

`list_resize()`

Описание	Изменяет длину списка до указанного размера.
Использование	`list_resize(list, size[, value])`
Псевдонимы	`array_resize()`

Изменяет длину списка до указанного размера. Если указанный размер больше текущего, дополняет список значениями из value или значениями NULL, если value не задано. Если указанный размер меньше текущего, удаляет элементы с правого конца.

Посмотреть пример

SELECT
    list_resize(['A', 'B', 'C'], 2)      AS result_1,
    list_resize(['A', 'B', 'C'], 4)      AS result_2,
    list_resize(['A', 'B', 'C'], 5, 'X') AS result_3;

+----------+--------------+-------------+
| result_1 | result_2     | result_3    |
+----------+--------------+-------------+
| {A,B}    | {A,B,C,null} | {A,B,C,X,X} |
+----------+--------------+-------------+

`list_reverse_sort()`

Описание	Сортирует список в порядке убывания.
Использование	`list_reverse_sort(list[, null_order])`
Псевдонимы	`array_reverse_sort()`

В параметре null_order можно задать расположение значений NULL после сортировки:

NULLS FIRST — значения NULL в начале
NULLS LAST — значения NULL в конце (по умолчанию)

Посмотреть пример

SELECT
    list_reverse_sort([1, 3, 2])                      AS result_1,
    list_reverse_sort([1, 3, NULL, 2])                AS result_2,
    list_reverse_sort([1, 3, NULL, 2], 'NULLS FIRST') AS result_3;

+----------+--------------+--------------+
| result_1 | result_2     | result_3     |
+----------+--------------+--------------+
| {3,2,1}  | {3,2,1,None} | {None,3,2,1} |
+----------+--------------+--------------+

`list_select()`

Описание	Возвращает список элементов исходного списка по их индексам.
Использование	`list_select(list, index_list)`
Псевдонимы	`array_select()`

Нумерация элементов начинается с 1.

Посмотреть пример

SELECT
    list_select([4, 5, 6], [1, 3])          AS result_1,
    list_select([4, 5, 6], [1, 3, 4])       AS result_2,
    list_select([4, 5, 6, NULL], [1, 3, 4]) AS result_3;

+----------+------------+------------+
| result_1 | result_2   | result_3   |
+----------+------------+------------+
| {4,6}    | {4,6,None} | {4,6,None} |
+----------+------------+------------+

`list_sort()`

Описание	Сортирует список.
Использование	`list_sort(list[, sort_order, null_order])`
Псевдонимы	`array_sort()`

В параметре sort_order можно задать порядок сортировки:

ASC-- по возрастанию (по умолчанию)
DESC — по убыванию

В параметре null_order можно задать расположение значений NULL после сортировки:

NULLS FIRST — значения NULL в начале
NULLS LAST — значения NULL в конце (по умолчанию)

Второй параметр можно задать, только если задан первый.

Посмотреть пример

SELECT
    list_sort([1, 3, 2])                              AS result_1,
    list_sort([1, 3, NULL, 2], 'DESC')                AS result_2,
    list_sort([1, 3, NULL, 2], 'DESC', 'NULLS FIRST') AS result_3;

+----------+--------------+--------------+
| result_1 | result_2     | result_3     |
+----------+--------------+--------------+
| {1,2,3}  | {3,2,1,None} | {None,3,2,1} |
+----------+--------------+--------------+

`list_unique()`

Описание	Вычисляет количество уникальных элементов в списке.
Использование	`list_unique(list)`
Псевдонимы	`array_unique()`

Посмотреть пример

SELECT
    list_unique(['A', 'B', 'A'])       AS result_1,
    list_unique(['A', 'B', 'A', NULL]) AS result_2,
    list_unique(['A', NULL, NULL])     AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| 2        | 2        | 1        |
+----------+----------+----------+

`list_value()`

Описание	Создает список из переданных аргументов.
Использование	`list_value(value_1, value_2, ...)`
Псевдонимы	`list_pack()`

Посмотреть пример

SELECT
    list_value(1, 2, 3)       AS result_1,
    list_value(1)             AS result_2,
    list_value(1, 2, 3, NULL) AS result_3;

+----------+----------+--------------+
| result_1 | result_2 | result_3     |
+----------+----------+--------------+
| {1,2,3}  | {1}      | {1,2,3,None} |
+----------+----------+--------------+

`list_where()`

Описание	Фильтрует список по списку логических флагов.
Использование	`list_where(list, mask_list)`
Псевдонимы	`array_where()`

Посмотреть пример

SELECT
    list_where([1, 2, 3], [true, false, true])        AS result_1,
    list_where([1, 2, 3, 4], [true, false, true])     AS result_2,
    list_where([1, 2, 3], [true, false, true, false]) AS result_3;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| {1,3}    | {1,3}    | {1,3}    |
+----------+----------+----------+

`list_zip()`

Описание	Объединяет списки в новый список, длина которого равна длине самого длинного списка.
Использование	`list_zip(list_1, ..., list_n[, truncate])`
Псевдонимы	`array_zip()`

Объединяет n списков в новый список, длина которого равна длине самого длинного списка. Его элементами являются структуры из n элементов из каждого списка. Отсутствующие элементы заменяются значением NULL.

Если задан параметр truncate (через значение TRUE), все списки усекаются до длины наименьшего списка.

Посмотреть пример

SELECT
    list_zip(['A', 'B', 'C'], ['1', '2', '3'])  AS result_1,
    list_zip(['A', 'B'], ['1', '2', '3'])       AS result_2,
    list_zip(['A', 'B'], ['1', '2', '3'], true) AS result_3;

+------------------------------------+-------------------------------------+-------------------------+
| result_1                           | result_2                            | result_3                |
+------------------------------------+-------------------------------------+-------------------------+
| {['A', '1'],['B', '2'],['C', '3']} | {['A', '1'],['B', '2'],[None, '3']} | {['A', '1'],['B', '2']} |
+------------------------------------+-------------------------------------+-------------------------+

`range()`

Описание	Генерирует список последовательных чисел в заданном диапазоне.
Использование	`range([start,] stop[, step])`

Конечная граница (stop) не включается в результат.

Если параметр start`не указан, то последовательность начинается с `0.

В параметре step можно указать шаг последовательности.

Посмотреть пример

SELECT
    range(10)       AS result_1,
    range(5, 10)    AS result_2,
    range(5, 10, 2) AS result_3;

+-----------------------+-------------+----------+
| result_1              | result_2    | result_3 |
+-----------------------+-------------+----------+
| {0,1,2,3,4,5,6,7,8,9} | {5,6,7,8,9} | {5,7,9}  |
+-----------------------+-------------+----------+