Последнее обновление 16 окт. 2026 г.

ARRAY_SORT

Описание

Если лямбда-функция не указана, элементы массива сортируются по возрастанию. В противном случае сортировка выполняется в соответствии с лямбда-функцией.

Синтаксис

ARRAY_SORT(<arr>)
ARRAY_SORT(<lambda>, <arr>)

Параметры

Параметр Описание

<arr> ARRAY, элементы которого могут быть числами, логическими значениями, строками, значениями даты и времени, IP, UUID или значениями других поддерживаемых типов. Поддерживаются многомерные массивы, но все вложенные элементы должны относиться к этим поддерживаемым типам.

<lambda> Необязательный компаратор, который принимает два элемента и возвращает -1, 0 или 1, если первый элемент соответственно меньше второго, равен ему или больше него.

Параметр	Описание
`<arr>`	ARRAY, элементы которого могут быть числами, логическими значениями, строками, значениями даты и времени, IP, UUID или значениями других поддерживаемых типов. Поддерживаются многомерные массивы, но все вложенные элементы должны относиться к этим поддерживаемым типам.
`<lambda>`	Необязательный компаратор, который принимает два элемента и возвращает -1, 0 или 1, если первый элемент соответственно меньше второго, равен ему или больше него.

Возвращаемое значение

Если выражение lambda отсутствует
- Возвращает ARRAY<T> того же типа, что и входной массив.
- Элементы NULL помещаются в начало возвращаемого массива.
Если выражение lambda присутствует, сортирует элементы в соответствии с лямбда-выражением и возвращает ARRAY<T> того же типа, что и входной массив.

В линейке Doris 4.1 начиная с версии 4.1.5 при использовании компаратора, который ссылается на аргумент внешней лямбда-функции или на другой столбец, явно выдаётся ошибка. Компаратор может использовать только два собственных аргумента, а вложенная в него лямбда-функция не может захватывать эти аргументы компаратора. Это ограничение не затрагивает обычный захват аргументов вложенными лямбда-функциями в ARRAY_MAP.

Примечания по использованию

Если выражение lambda отсутствует
- Если входное значение — NULL, возвращает NULL; если на вход подан пустой массив [], возвращает пустой массив.
- ARRAY_SORT сортирует по возрастанию, а ARRAY_REVERSE_SORT — по убыванию.
Если выражение lambda присутствует
- Значение выражения lambda должно быть -1, 0 или 1. При наличии значения NULL необходимо явно указать, следует ли помещать значение NULL в начало или в конец массива.

Пример

Базовый пример: элементы NULL помещаются в начало возвращаемого массива

SELECT ARRAY_SORT([2,1,3,null]);

+--------------------------+
| ARRAY_SORT([2,1,3,null]) |
+--------------------------+
| [null, 1, 2, 3]          |
+--------------------------+

Если входное значение — NULL, возвращает NULL; если на вход подан пустой массив [], возвращает пустой массив.

SELECT ARRAY_SORT(NULL);

+------------------+
| ARRAY_SORT(NULL) |
+------------------+
| NULL             |
+------------------+

SELECT ARRAY_SORT([]);

+----------------+
| ARRAY_SORT([]) |
+----------------+
| []             |
+----------------+

Использование выражений lambda

SELECT array_sort((x, y) -> IF(x < y, 1, IF(x = y, 0, -1)), [3, 2, 5, 1, 2]);

+-----------------------------------------------------------------------+
| array_sort((x, y) -> IF(x < y, 1, IF(x = y, 0, -1)), [3, 2, 5, 1, 2]) |
+-----------------------------------------------------------------------+
| [5, 3, 2, 2, 1]                                                       |
+-----------------------------------------------------------------------+

SELECT array_sort((x, y) -> IF(x < y, 1, IF(x = y, 0, -1)), ['bc', 'ab', 'dc']);

+--------------------------------------------------------------------------+
| array_sort((x, y) -> IF(x < y, 1, IF(x = y, 0, -1)), ['bc', 'ab', 'dc']) |
+--------------------------------------------------------------------------+
| ["dc", "bc", "ab"]                                                       |
+--------------------------------------------------------------------------+

SELECT array_sort((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,
                              [3, 2, null, 5, null, 1, 2]);

+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| array_sort((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,
                              [3, 2, null, 5, null, 1, 2]) |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| [null, null, 5, 3, 2, 2, 1]                                                                                                                                                                                                                                                                                |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT array_sort((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,
                              [3, 2, null, 5, null, 1, 2]);

+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| array_sort((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,
                              [3, 2, null, 5, null, 1, 2]) |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| [5, 3, 2, 2, 1, null, null]                                                                                                                                                                                                                                                                                |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT array_sort((x, y) -> IF(length(x) < length(y), -1,
                            IF(length(x) = length(y), 0, 1)),
                            ['a', 'abcd', 'abc']);

+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| array_sort((x, y) -> IF(length(x) < length(y), -1,
                            IF(length(x) = length(y), 0, 1)),
                            ['a', 'abcd', 'abc']) |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ["a", "abc", "abcd"]                                                                                                                                               |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT array_sort((x, y) -> IF(cardinality(x) < cardinality(y), -1,
                            IF(cardinality(x) = cardinality(y), 0, 1)),
                            [[2, 3, 1], [4, 2, 1, 4], [1, 2]]);

+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| array_sort((x, y) -> IF(cardinality(x) < cardinality(y), -1,
                            IF(cardinality(x) = cardinality(y), 0, 1)),
                            [[2, 3, 1], [4, 2, 1, 4], [1, 2]]) |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| [[1, 2], [2, 3, 1], [4, 2, 1, 4]]                                                                                                                                                                   |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Сортировка многомерного массива

SELECT ARRAY_SORT([[6, 2], [5, 6]]);

+------------------------------+
| ARRAY_SORT([[6, 2], [5, 6]]) |
+------------------------------+
| [[5, 6], [6, 2]]             |
+------------------------------+

Описание​

Синтаксис​

Параметры​

Возвращаемое значение​

Примечания по использованию​

Пример​