ARRAY_FILTER
array_filter
Описание
Фильтрует элементы массива по условиям и возвращает новый массив, состоящий из элементов, удовлетворяющих этим условиям. Функция поддерживает два способа вызова: в форме функции высшего порядка с лямбда-выражениями и в форме фильтрации с непосредственным использованием логических массивов.
Синтаксис
array_filter(lambda, array1, ...)
array_filter(array1, array<boolean> filter_array)
Параметры
lambda: лямбда-выражение для проверки элементов массива; возвращает true/false или выражения, которые можно преобразовать в логические значенияarray1, ...: один или несколько параметров типа ARRAY<T>filter_array: логический массив типа ARRAY<BOOLEAN>, используемый для фильтрации
Поддерживаемые типы T:
- Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
- Строковые типы: CHAR, VARCHAR, STRING
- Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2
- Логический тип: BOOLEAN
- Типы IP: IPV4, IPV6
- Сложные типы данных: ARRAY, MAP, STRUCT
Возвращаемое значение
Тип возвращаемого значения: ARRAY<T>
Описание возвращаемого значения:
- Возвращает новый массив, состоящий из всех элементов, удовлетворяющих условиям фильтрации
- NULL: если входной массив равен NULL
- Пустой массив: если ни один элемент не удовлетворяет условиям
Примечания по использованию:
- Форма с лямбда-выражением: число параметров лямбда-выражения должно совпадать с числом переданных массивов
- Форма с логическим массивом: желательно, чтобы длины
array1иfilter_arrayполностью совпадали. Если логический массив длиннее, лишние логические значения игнорируются; если он короче, обрабатываются только элементы, для которых есть соответствующие позиции в логическом массиве - Поддерживается фильтрация нескольких массивов и массивов сложных типов
- Для пустого массива возвращается пустой массив, для массива NULL возвращается NULL
- В лямбда-выражении можно использовать любые скалярные выражения, но нельзя использовать агрегатные функции
- Лямбда-выражения могут вызывать другие функции высшего порядка, но должны возвращать значения совместимых типов
- Значения null в элементах массива: элементы null передаются лямбда-выражению для обработки; лямбда-выражение может проверять значения null
Примеры
Подготовка: создайте тестовую таблицу и загрузите 4 строки, охватывающие обычные и граничные случаи, а также пустые массивы и NULL. Все последующие примеры используют эту тестовую таблицу.
CREATE TABLE array_filter_test (
id INT,
int_array ARRAY<INT>,
double_array ARRAY<DOUBLE>,
string_array ARRAY<STRING>
)
DUPLICATE KEY(id)
DISTRIBUTED BY HASH(id) BUCKETS 3
PROPERTIES (
"replication_num" = "1"
);
INSERT INTO array_filter_test VALUES
(1, [1, 2, 3, 4, 5], [1.1, 2.2, 3.3, 4.4, 5.5], ['a', 'bb', 'ccc', 'dddd', 'eeeee']),
(2, [10, 20, 30], [10.5, 20.5, 30.5], ['x', 'yy', 'zzz']),
(3, [], [], []),
(4, NULL, NULL, NULL);
Пример 1: лямбда-выражение для столбца с массивами DOUBLE сохраняет элементы, удовлетворяющие условию >= 3.
SELECT array_filter(x -> x >= 3, double_array) FROM array_filter_test WHERE id = 1;
+------------------------------------------+
| array_filter(x -> x >= 3, double_array) |
+------------------------------------------+
| [3.3, 4.4, 5.5] |
+------------------------------------------+
Пример 2: лямбда-выражение для столбца с массивами STRING сохраняет элементы, удовлетворяющие условию length > 2.
SELECT array_filter(x -> length(x) > 2, string_array) FROM array_filter_test WHERE id = 1;
+--------------------------------------------------+
| array_filter(x -> length(x) > 2, string_array) |
+--------------------------------------------------+
| ["ccc", "dddd", "eeeee"] |
+--------------------------------------------------+
Пример 3: форма с логической маской сохраняет элементы в позициях, где маска имеет значение true.
SELECT array_filter(int_array, [false, true, false, true, true]) FROM array_filter_test WHERE id = 1;
+-----------------------------------------------------------+
| array_filter(int_array, [false, true, false, true, true]) |
+-----------------------------------------------------------+
| [2, 4, 5] |
+-----------------------------------------------------------+
Пример 4: форма с логической маской и литералами массивов.
SELECT array_filter([1,2,3], [true, false, true]);
+--------------------------------------------+
| array_filter([1,2,3], [true, false, true]) |
+--------------------------------------------+
| [1, 3] |
+--------------------------------------------+
Пример 5: логический массив длиннее массива значений; лишние элементы маски игнорируются.
SELECT array_filter([1,2,3], [true, false, true, false]);
+---------------------------------------------------+
| array_filter([1,2,3], [true, false, true, false]) |
+---------------------------------------------------+
| [1, 3] |
+---------------------------------------------------+
Пример 6: логический массив короче массива значений; обрабатываются только позиции, охваченные маской.
SELECT array_filter([1,2,3], [true, false]);
+--------------------------------------+
| array_filter([1,2,3], [true, false]) |
+--------------------------------------+
| [1] |
+--------------------------------------+
Пример 7: для пустого входного массива возвращается пустой массив (строка id = 3).
SELECT array_filter(x -> x > 0, int_array) FROM array_filter_test WHERE id = 3;
+-------------------------------------+
| array_filter(x -> x > 0, int_array) |
+-------------------------------------+
| [] |
+-------------------------------------+
Пример 8: для входного массива NULL возвращается NULL (строка id = 4).
SELECT array_filter(x -> x > 0, int_array) FROM array_filter_test WHERE id = 4;
+-------------------------------------+
| array_filter(x -> x > 0, int_array) |
+-------------------------------------+
| NULL |
+-------------------------------------+
Пример 9: массив содержит элементы NULL; лямбда-выражение может использовать проверку IS NOT NULL, чтобы исключить их.
SELECT array_filter(x -> x is not null, [null, 1, null, 2, null]);
+------------------------------------------------------------+
| array_filter(x -> x is not null, [null, 1, null, 2, null]) |
+------------------------------------------------------------+
| [1, 2] |
+------------------------------------------------------------+
Пример 10: лямбда-выражение с несколькими аргументами для двух массивов из тестовой таблицы.
SELECT array_filter((x, y) -> x > y, int_array, double_array) FROM array_filter_test WHERE id = 1;
+--------------------------------------------------------+
| array_filter((x, y) -> x > y, int_array, double_array) |
+--------------------------------------------------------+
| [] |
+--------------------------------------------------------+
Пример 11: фильтрация литерала вложенного массива сохраняет вложенные массивы, удовлетворяющие условию size > 2.
SELECT array_filter(x -> size(x) > 2, [[1,2], [3,4,5], [6], [7,8,9,10]]);
+-------------------------------------------------------------------+
| array_filter(x -> size(x) > 2, [[1,2], [3,4,5], [6], [7,8,9,10]]) |
+-------------------------------------------------------------------+
| [[3, 4, 5], [7, 8, 9, 10]] |
+-------------------------------------------------------------------+
Пример 12: фильтрация массива элементов MAP сохраняет элементы, для которых выполняется условие x['a'] > 10.
SELECT array_filter(x -> x['a'] > 10, [{'a':5}, {'a':15}, {'a':20}]);
+---------------------------------------------------------------+
| array_filter(x -> x['a'] > 10, [{'a':5}, {'a':15}, {'a':20}]) |
+---------------------------------------------------------------+
| [{"a":15}, {"a":20}] |
+---------------------------------------------------------------+
Пример 13: фильтрация массива элементов STRUCT по значению поля.
SELECT array_filter(x -> struct_element(x, 'age') > 18, array(named_struct('name','Alice','age',20),named_struct('name','Bob','age',16),named_struct('name','Eve','age',30)));
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| array_filter(x -> struct_element(x, 'age') > 18, array(named_struct('name','Alice','age',20),named_struct('name','Bob','age',16),named_struct('name','Eve','age',30))) |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| [{"name":"Alice", "age":20}, {"name":"Eve", "age":30}] |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
Пример 14: число параметров лямбда-выражения должно совпадать с числом переданных массивов.
SELECT array_filter(x -> x > 0, [1,2,3], [4,5,6], [7,8,9]);
ERROR 1105 (HY000): errCode = 2, detailMessage = lambda x -> (x > 0) arguments' size is not equal parameters' size
Пример 15: форма с несколькими массивами требует, чтобы все входные массивы имели одинаковую длину.
SELECT array_filter((x, y) -> x > y, [1,2,3], [4,5]);
ERROR 1105 (HY000): errCode = 2, detailMessage = [INVALID_ARGUMENT]in array map function, the input column size are not equal completely, nested column data rows 1st size is 3, 2th size is 2.
Пример 16: первый аргумент должен быть массивом.
SELECT array_filter(x -> x > 0, 'not_an_array');
ERROR 1105 (HY000): errCode = 2, detailMessage = lambda argument must be array but is 'not_an_array'
Пример 17: вложенная функция высшего порядка; внутренняя функция array_count возвращает скалярное значение, которое может использовать лямбда-выражение внешней функции array_filter.
SELECT array_filter(x -> array_count(y -> y > 5, x) > 0, [[1,2,3],[4,5,6],[7,8,9]]);
+------------------------------------------------------------------------------+
| array_filter(x -> array_count(y -> y > 5, x) > 0, [[1,2,3],[4,5,6],[7,8,9]]) |
+------------------------------------------------------------------------------+
| [[4, 5, 6], [7, 8, 9]] |
+------------------------------------------------------------------------------+
Пример 18: контрпример; лямбда-выражение внешней функции array_filter не может возвращать массив (array_exists здесь возвращает ARRAY
SELECT array_filter(x -> array_exists(y -> y > 5, x), [[1,2,3],[4,5,6]]);
ERROR 1105 (HY000): errCode = 2, detailMessage = Can not find the compatibility function signature: array_filter(ARRAY<ARRAY<TINYINT>>, ARRAY<ARRAY<BOOLEAN>>)
Ключевые слова
ARRAY, FILTER, ARRAY_FILTER