Перейти к содержимому
Последнее обновление

ARRAY_COUNT

array_count​

SinceVersion 2.0.0

Описание​

Применяет лямбда-выражение к элементам массива и подсчитывает количество элементов, для которых возвращаемое значение не равно 0.

Синтаксис​

array_count(lambda, array1, ...)

Параметры​

  • lambda：лямбда-выражение для проверки и обработки элементов массива
  • array1, ...：один или несколько параметров типа ARRAY<T>

Поддерживаемые типы T:

  • Числовые типы: TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL
  • Строковые типы: CHAR, VARCHAR, STRING
  • Типы даты и времени: DATE, DATETIME, DATEV2, DATETIMEV2, TIMESTAMP_NS
  • Логический тип: BOOLEAN
  • Типы IP: IPV4, IPV6
  • UUID: UUID
  • Сложные типы данных: ARRAY, MAP, STRUCT

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

Тип возвращаемого значения: BIGINT

Значение результата:

  • Возвращает количество элементов, для которых результат лямбда-выражения равен true
  • 0: если ни один элемент не удовлетворяет условию или входной массив имеет значение NULL

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

  • Количество параметров лямбда-выражения должно совпадать с количеством параметров-массивов
  • Все входные массивы должны иметь одинаковую длину
  • Поддерживается подсчёт по нескольким массивам и по массивам сложных типов
  • Для пустого массива возвращается 0, для массива NULL возвращается 0
  • Лямбда-выражения могут вызывать другие функции высшего порядка, но возвращаемые типы должны быть совместимы
  • Обработка значений null в элементах массива: элементы со значением null передаются лямбда-выражению для обработки, и оно может проверять значения null

Примеры​

CREATE TABLE array_count_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_count_test VALUES
(1, [1, 2, 3, 4, 5], [1.1, 2.2, 3.3, 4.4, 5.5], ['a', 'bb', 'ccc', 'dddd', 'eeeee']),
(2, [1, null, 3, null, 5], [1.1, null, 3.3, null, 5.5], ['a', null, 'ccc', null, 'eeeee']),
(3, [], [], []),
(4, NULL, NULL, NULL);

Примеры запросов:

Подсчёт элементов int_array, которые больше 2:

SELECT array_count(x -> x > 2, int_array) FROM array_count_test WHERE id = 1;
+-------------------------------------+
| array_count(x -> x > 2, int_array)  |
+-------------------------------------+
|                                   3 |
+-------------------------------------+

Подсчёт элементов double_array, которые больше или равны 3:

SELECT array_count(x -> x >= 3, double_array) FROM array_count_test WHERE id = 1;
+------------------------------------------+
| array_count(x -> x >= 3, double_array)   |
+------------------------------------------+
|                                        3 |
+------------------------------------------+

Подсчёт элементов string_array, длина которых больше 2:

SELECT array_count(x -> length(x) > 2, string_array) FROM array_count_test WHERE id = 1;
+--------------------------------------------------+
| array_count(x -> length(x) > 2, string_array)    |
+--------------------------------------------------+
|                                              3   |
+--------------------------------------------------+

Вычисление для пустого массива:

SELECT array_count(x -> x > 0, int_array) FROM array_count_test WHERE id = 3;
+-------------------------------------+
| array_count(x -> x > 0, int_array)  |
+-------------------------------------+
|                                   0 |
+-------------------------------------+

Вычисление для массива NULL:

SELECT array_count(x -> x > 0, int_array) FROM array_count_test WHERE id = 4;
+-------------------------------------+
| array_count(x -> x > 0, int_array)  |
+-------------------------------------+
|                                   0 |
+-------------------------------------+

Подсчёт элементов со значением null в массиве, содержащем значения null:

SELECT array_count(x -> x is null, int_array) FROM array_count_test WHERE id = 2;
+------------------------------------------+
| array_count(x -> x is null, int_array)   |
+------------------------------------------+
|                                        2 |
+------------------------------------------+

Подсчёт элементов со значением, отличным от null, в массиве, содержащем значения null:

SELECT array_count(x -> x is not null, int_array) FROM array_count_test WHERE id = 2;
+----------------------------------------------+
| array_count(x -> x is not null, int_array)   |
+----------------------------------------------+
|                                            3 |
+----------------------------------------------+

Пример с несколькими параметрами-массивами:

SELECT array_count((x, y) -> x > y, [1, 2, 3], [0, 3, 2]);
+--------------------------------------------------+
| array_count((x, y) -> x > y, [1, 2, 3], [0, 3, 2]) |
+--------------------------------------------------+
|                                              2   |
+--------------------------------------------------+

Пример со сложным типом: подсчёт массивов, содержащих более 2 элементов:

SELECT array_count(x -> array_size(x) > 2, [[1,2],[1,2,3],[4,5,6,7]]);
+----------------------------------------------------------------+
| array_count(x -> array_size(x) > 2, [[1,2],[1,2,3],[4,5,6,7]]) |
+----------------------------------------------------------------+
|                                                              2 |
+----------------------------------------------------------------+

Вложенные функции высшего порядка: array_count ожидает, что тело лямбда-выражения вернёт скалярное значение, которое можно привести к BOOLEAN. Когда внутренняя функция array_exists возвращает ARRAY логических значений (по одному на каждый внутренний элемент), array_count не может обработать его и сообщает об ошибке сигнатуры:

SELECT array_count(x -> array_exists(y -> y > 5, x), [[1,2,3],[4,5,6],[7,8,9]]);
ERROR 1105 (HY000): errCode = 2, detailMessage = Can not find the compatibility function signature: array_count(ARRAY<ARRAY<BOOLEAN>>)

Чтобы подсчитать внешние массивы, содержащие хотя бы один элемент больше 5, оберните внутреннюю проверку так, чтобы лямбда-выражение возвращало скалярное значение BOOLEAN, например size(array_filter(y -> y > 5, x)) > 0:

SELECT array_count(x -> size(array_filter(y -> y > 5, x)) > 0, [[1,2,3],[4,5,6],[7,8,9]]);
+----------------------------------------------------------------------------------+
| array_count(x -> size(array_filter(y -> y > 5, x)) > 0, [[1,2,3],[4,5,6],[7,8,9]]) |
+----------------------------------------------------------------------------------+
|                                                                                2 |
+----------------------------------------------------------------------------------+

Пример с литералом массива:

SELECT array_count(x -> x % 2 = 0, [1, 2, 3, 4, 5, 6]);
+------------------------------------------+
| array_count(x -> x % 2 = 0, [1, 2, 3, 4, 5, 6]) |
+------------------------------------------+
|                                        3 |
+------------------------------------------+

Ключевые слова​

ARRAY, COUNT, ARRAY_COUNT

Report issue