Skip to main content

Массивы

empty​

Проверяет, является ли входной массив пустым.

Синтаксис

empty([x])

Массив считается пустым, если он не содержит ни одного элемента.

Примечание

Функцию можно оптимизировать, если включить настройку optimize_functions_to_subcolumns. При optimize_functions_to_subcolumns = 1 функция читает только подстолбец size0 вместо чтения и обработки всего столбца массива. Запрос SELECT empty(arr) FROM TABLE преобразуется к запросу SELECT arr.size0 = 0 FROM TABLE.

Функция также поддерживает работу с типами String и UUID.

Параметры

  • [x] — массив на входе функции. Array.

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

  • Возвращает 1 для пустого массива или 0 — для непустого массива.

Тип: UInt8.

Пример

Запрос:

SELECT empty([]);

Ответ:

┌─empty(array())─┐
│              1 │
└────────────────┘

notEmpty​

Проверяет, является ли входной массив непустым.

Синтаксис

notEmpty([x])

Массив считается непустым, если он содержит хотя бы один элемент.

Примечание

Функцию можно оптимизировать, если включить настройку optimize_functions_to_subcolumns. При optimize_functions_to_subcolumns = 1 функция читает только подстолбец size0 вместо чтения и обработки всего столбца массива. Запрос SELECT notEmpty(arr) FROM table преобразуется к запросу SELECT arr.size0 != 0 FROM TABLE.

Функция также поддерживает работу с типами String и UUID.

Параметры

  • [x] — массив на входе функции. Array.

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

  • Возвращает 1 для непустого массива или 0 — для пустого массива.

Тип: UInt8.

Пример

Запрос:

SELECT notEmpty([1,2]);

Результат:

┌─notEmpty([1, 2])─┐
│                1 │
└──────────────────┘

length​

Возвращает количество элементов в массиве. Тип результата - UInt64. Функция также работает для строк.

Функцию можно оптимизировать, если включить настройку optimize_functions_to_subcolumns. При optimize_functions_to_subcolumns = 1 функция читает только подстолбец size0 вместо чтения и обработки всего столбца массива. Запрос SELECT length(arr) FROM table преобразуется к запросу SELECT arr.size0 FROM TABLE.

emptyArrayUInt8, emptyArrayUInt16, emptyArrayUInt32, emptyArrayUInt64​

emptyArrayInt8, emptyArrayInt16, emptyArrayInt32, emptyArrayInt64​

emptyArrayFloat32, emptyArrayFloat64​

emptyArrayDate, emptyArrayDateTime​

emptyArrayString​

Принимает ноль аргументов и возвращает пустой массив соответствующего типа.

emptyArrayToSingle​

Принимает пустой массив и возвращает массив из одного элемента, равного значению по умолчанию.

range(end), range([start, ] end [, step])​

Возвращает массив чисел от start до end - 1 с шагом step.

Синтаксис

range([start, ] end [, step])

Аргументы

  • start — начало диапазона. Обязательно, когда указан step. По умолчанию равно 0. Тип: UInt
  • end — конец диапазона. Обязательный аргумент. Должен быть больше, чем start. Тип: UInt
  • step — шаг обхода. Необязательный аргумент. По умолчанию равен 1. Тип: UInt

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

  • массив UInt чисел от start до end - 1 с шагом step

Особенности реализации

  • Не поддерживаются отрицательные значения аргументов: start, end, step имеют тип UInt.

  • Если в результате запроса создаются массивы суммарной длиной больше, чем количество элементов, указанное настройкой function_range_max_elements_in_block, то генерируется исключение.

  • Возвращает Null если любой аргумент Nullable(Nothing) типа. Генерируется исключение если любой аргумент Null (Nullable(T) тип).

Примеры

Запрос:

SELECT range(5), range(1, 5), range(1, 5, 2);

Ответ:

┌─range(5)────┬─range(1, 5)─┬─range(1, 5, 2)─┐
│ [0,1,2,3,4] │ [1,2,3,4]   │ [1,3]          │
└─────────────┴─────────────┴────────────────┘

array(x1, …), оператор [x1, …]​

Создаёт массив из аргументов функции. Аргументы должны быть константами и иметь типы, для которых есть наименьший общий тип. Должен быть передан хотя бы один аргумент, так как иначе непонятно, какого типа создавать массив. То есть, с помощью этой функции невозможно создать пустой массив (для этого используйте функции emptyArray*, описанные выше). Возвращает результат типа Array(T), где T - наименьший общий тип от переданных аргументов.

arrayConcat​

Объединяет массивы, переданные в качестве аргументов.

arrayConcat(arrays)

Аргументы

  • arrays – произвольное количество элементов типа ArrayПример
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
┌─res───────────┐
│ [1,2,3,4,5,6] │
└───────────────┘

arrayElement(arr, n), operator arr[n]​

Достаёт элемент с индексом n из массива arr. n должен быть любым целочисленным типом. Индексы в массиве начинаются с единицы. Поддерживаются отрицательные индексы. В этом случае, будет выбран соответствующий по номеру элемент с конца. Например, arr[-1] - последний элемент массива.

Если индекс выходит за границы массива, то возвращается некоторое значение по умолчанию (0 для чисел, пустая строка для строк и т. п.), кроме случая с неконстантным массивом и константным индексом 0 (в этом случае будет ошибка Array indices are 1-based).

has(arr, elem)​

Проверяет наличие элемента elem в массиве arr. Возвращает 0, если элемента в массиве нет, или 1, если есть.

NULL обрабатывается как значение.

SELECT has([1, 2, NULL], NULL)
┌─has([1, 2, NULL], NULL)─┐
│                       1 │
└─────────────────────────┘

hasAll​

Проверяет, является ли один массив подмножеством другого.

hasAll(set, subset)

Аргументы

  • set – массив любого типа с набором элементов.
  • subset – массив любого типа со значениями, которые проверяются на вхождение в set.

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

  • 1, если set содержит все элементы из subset.
  • 0, в противном случае.

Особенности

  • Пустой массив является подмножеством любого массива.
  • NULL обрабатывается как значение.
  • Порядок значений в обоих массивах не имеет значения.

Примеры

SELECT hasAll([], []) возвращает 1.

SELECT hasAll([1, Null], [Null]) возвращает 1.

SELECT hasAll([1.0, 2, 3, 4], [1, 3]) возвращает 1.

SELECT hasAll(['a', 'b'], ['a']) возвращает 1.

SELECT hasAll([1], ['a']) возвращает 0.

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]]) возвращает 0.

hasAny​

Проверяет, имеют ли два массива хотя бы один общий элемент.

hasAny(array1, array2)

Аргументы

  • array1 – массив любого типа с набором элементов.
  • array2 – массив любого типа с набором элементов.

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

  • 1, если array1 и array2 имеют хотя бы один одинаковый элемент.
  • 0, в противном случае.

Особенности

  • NULL обрабатывается как значение.
  • Порядок значений в обоих массивах не имеет значения.

Примеры

SELECT hasAny([1], []) возвращает 0.

SELECT hasAny([Null], [Null, 1]) возвращает 1.

SELECT hasAny([-128, 1., 512], [1]) возвращает 1.

SELECT hasAny([[1, 2], [3, 4]], ['a', 'c']) возвращает 0.

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]]) возвращает 1.

indexOf(arr, x)​

Возвращает индекс первого элемента x (начиная с 1), если он есть в массиве, или 0, если его нет.

Пример:

SELECT indexOf([1, 3, NULL, NULL], NULL)
┌─indexOf([1, 3, NULL, NULL], NULL)─┐
│                                 3 │
└───────────────────────────────────┘

Элементы, равные NULL, обрабатываются как обычные значения.

arrayCount([func,] arr1, …)​

Возвращает количество элементов массива arr, для которых функция func возвращает не 0. Если func не указана - возвращает количество ненулевых элементов массива.

Функция arrayCount является функцией высшего порядка — в качестве первого аргумента ей можно передать лямбда-функцию.

countEqual(arr, x)​

Возвращает количество элементов массива, равных x. Эквивалентно arrayCount(elem -> elem = x, arr).

NULL обрабатывается как значение.

Пример:

SELECT countEqual([1, 2, NULL, NULL], NULL)
┌─countEqual([1, 2, NULL, NULL], NULL)─┐
│                                    2 │
└──────────────────────────────────────┘

arrayEnumerate(arr)​

Возвращает массив [1, 2, 3, …, length(arr)]

Эта функция обычно используется совместно с ARRAY JOIN. Она позволяет, после применения ARRAY JOIN, посчитать что-либо только один раз для каждого массива. Пример:

SELECT
    count() AS Reaches,
    countIf(num = 1) AS Hits
FROM test.hits
ARRAY JOIN
    GoalsReached,
    arrayEnumerate(GoalsReached) AS num
WHERE CounterID = 160656
LIMIT 10
┌─Reaches─┬──Hits─┐
│   95606 │ 31406 │
└─────────┴───────┘

В этом примере, Reaches - число достижений целей (строк, получившихся после применения ARRAY JOIN), а Hits - число хитов (строк, которые были до ARRAY JOIN). В данном случае, тот же результат можно получить проще:

SELECT
    sum(length(GoalsReached)) AS Reaches,
    count() AS Hits
FROM test.hits
WHERE (CounterID = 160656) AND notEmpty(GoalsReached)
┌─Reaches─┬──Hits─┐
│   95606 │ 31406 │
└─────────┴───────┘

Также эта функция может быть использована в функциях высшего порядка. Например, с её помощью можно достать индексы массива для элементов, удовлетворяющих некоторому условию.

arrayEnumerateUniq(arr, …)​

Возвращает массив, такого же размера, как исходный, где для каждого элемента указано, какой он по счету среди элементов с таким же значением. Например: arrayEnumerateUniq([10, 20, 10, 30]) = [1, 1, 2, 1].

Эта функция полезна при использовании ARRAY JOIN и агрегации по элементам массива. Пример:

SELECT
    Goals.ID AS GoalID,
    sum(Sign) AS Reaches,
    sumIf(Sign, num = 1) AS Visits
FROM test.visits
ARRAY JOIN
    Goals,
    arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC
LIMIT 10
┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │    3214 │   1097 │
│ 2825062 │    3188 │   1097 │
│   56600 │    2803 │    488 │
│ 1989037 │    2401 │    365 │
│ 2830064 │    2396 │    910 │
│ 1113562 │    2372 │    373 │
│ 3270895 │    2262 │    812 │
│ 1084657 │    2262 │    345 │
│   56599 │    2260 │    799 │
│ 3271094 │    2256 │    812 │
└─────────┴─────────┴────────┘

В этом примере, для каждого идентификатора цели, посчитано количество достижений целей (каждый элемент вложенной структуры данных Goals является достижением целей) и количество визитов. Если бы не было ARRAY JOIN, мы бы считали количество визитов как sum(Sign). Но в данном случае, строчки были размножены по вложенной структуре Goals, и чтобы после этого учесть каждый визит один раз, мы поставили условие на значение функции arrayEnumerateUniq(Goals.ID).

Функция arrayEnumerateUniq может принимать несколько аргументов - массивов одинаковых размеров. В этом случае, уникальность считается для кортежей элементов на одинаковых позициях всех массивов.

SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]) AS res
┌─res───────────┐
│ [1,2,1,1,2,1] │
└───────────────┘

Это нужно при использовании ARRAY JOIN с вложенной структурой данных и затем агрегации по нескольким элементам этой структуры.

arrayPopBack​

Удаляет последний элемент из массива.

arrayPopBack(array)

Аргументы

  • array – массив.

Пример

SELECT arrayPopBack([1, 2, 3]) AS res;
┌─res───┐
│ [1,2] │
└───────┘

arrayPopFront​

Удаляет первый элемент из массива.

arrayPopFront(array)

Аргументы

  • array – массив.

Пример

SELECT arrayPopFront([1, 2, 3]) AS res;
┌─res───┐
│ [2,3] │
└───────┘

arrayPushBack​

Добавляет один элемент в конец массива.

arrayPushBack(array, single_value)

Аргументы

  • array – массив.
  • single_value – значение добавляемого элемента. В массив с числам можно добавить только числа, в массив со строками только строки. При добавлении чисел ClickHouse автоматически приводит тип single_value к типу данных массива. Подробнее о типах данных в ClickHouse читайте в разделе «Типы данных». Может быть равно NULL, в этом случае функция добавит элемент NULL в массив, а тип элементов массива преобразует в Nullable.

Пример

SELECT arrayPushBack(['a'], 'b') AS res;
┌─res───────┐
│ ['a','b'] │
└───────────┘

arrayPushFront​

Добавляет один элемент в начало массива.

arrayPushFront(array, single_value)

Аргументы

  • array – массив.
  • single_value – значение добавляемого элемента. В массив с числам можно добавить только числа, в массив со строками только строки. При добавлении чисел ClickHouse автоматически приводит тип single_value к типу данных массива. Подробнее о типах данных в ClickHouse читайте в разделе «Типы данных». Может быть равно NULL, в этом случае функция добавит элемент NULL в массив, а тип элементов массива преобразует в Nullable.

Пример

SELECT arrayPushFront(['b'], 'a') AS res;
┌─res───────┐
│ ['a','b'] │
└───────────┘

arrayResize​

Изменяет длину массива.

arrayResize(array, size[, extender])

Аргументы

  • array — массив.
  • size — необходимая длина массива.
    • Если size меньше изначального размера массива, то массив обрезается справа.
    • Если size больше изначального размера массива, массив дополняется справа значениями extender или значениями по умолчанию для типа данных элементов массива.
  • extender — значение для дополнения массива. Может быть NULL.

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

Массив длины size.

Примеры вызовов

SELECT arrayResize([1], 3);
┌─arrayResize([1], 3)─┐
│ [1,0,0]             │
└─────────────────────┘
SELECT arrayResize([1], 3, NULL);
┌─arrayResize([1], 3, NULL)─┐
│ [1,NULL,NULL]             │
└───────────────────────────┘

arraySlice​

Возвращает срез массива.

arraySlice(array, offset[, length])

Аргументы

  • array – массив данных.
  • offset – отступ от края массива. Положительное значение - отступ слева, отрицательное значение - отступ справа. Отсчёт элементов массива начинается с 1.
  • length – длина необходимого среза. Если указать отрицательное значение, то функция вернёт открытый срез [offset, array_length - length]. Если не указать значение, то функция вернёт срез [offset, the_end_of_array].

Пример

SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
┌─res────────┐
│ [2,NULL,4] │
└────────────┘

Элементы массива равные NULL обрабатываются как обычные значения.

arraySort([func,] arr, …)​

Возвращает массив arr, отсортированный в восходящем порядке. Если задана функция func, то порядок сортировки определяется результатом применения этой функции на элементы массива arr. Если func принимает несколько аргументов, то в функцию arraySort нужно передавать несколько массивов, которые будут соответствовать аргументам функции func. Подробные примеры рассмотрены в конце описания arraySort.

Пример сортировки целочисленных значений:

SELECT arraySort([1, 3, 3, 0])
┌─arraySort([1, 3, 3, 0])─┐
│ [0,1,3,3]               │
└─────────────────────────┘

Пример сортировки строковых значений:

SELECT arraySort(['hello', 'world', '!'])
┌─arraySort(['hello', 'world', '!'])─┐
│ ['!','hello','world']              │
└────────────────────────────────────┘

Значения NULL, NaN и Inf сортируются по следующему принципу:

SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
┌─arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf])─┐
│ [-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]                     │
└───────────────────────────────────────────────────────────┘
  • Значения -Inf идут в начале массива.
  • Значения NULL идут в конце массива.
  • Значения NaN идут перед NULL.
  • Значения Inf идут перед NaN.

Функция arraySort является функцией высшего порядка — в качестве первого аргумента ей можно передать лямбда-функцию. В этом случае порядок сортировки определяется результатом применения лямбда-функции на элементы массива.

Рассмотрим пример:

SELECT arraySort((x) -> -x, [1, 2, 3]) as res;
┌─res─────┐
│ [3,2,1] │
└─────────┘

Для каждого элемента исходного массива лямбда-функция возвращает ключ сортировки, то есть [1 –> -1, 2 –> -2, 3 –> -3]. Так как arraySort сортирует элементы в порядке возрастания ключей, результат будет [3, 2, 1]. Как можно заметить, функция x –> -x устанавливает обратный порядок сортировки.

Лямбда-функция может принимать несколько аргументов. В этом случае, в функцию arraySort нужно передавать несколько массивов, которые будут соответствовать аргументам лямбда-функции (массивы должны быть одинаковой длины). Следует иметь в виду, что результат будет содержать элементы только из первого массива; элементы из всех последующих массивов будут задавать ключи сортировки. Например:

SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
┌─res────────────────┐
│ ['world', 'hello'] │
└────────────────────┘

Элементы, указанные во втором массиве ([2,1]), определяют ключ сортировки для элементов из исходного массива ([‘hello’, ‘world’]), то есть [‘hello’ –> 2, ‘world’ –> 1]. Так как лямбда-функция не использует x, элементы исходного массива не влияют на порядок сортировки. Таким образом, ‘hello’ будет вторым элементом в отсортированном массиве, а ‘world’ — первым.

Ниже приведены другие примеры.

SELECT arraySort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
┌─res─────┐
│ [2,1,0] │
└─────────┘
SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res;
┌─res─────┐
│ [2,1,0] │
└─────────┘
Примечание

Для улучшения эффективности сортировки применяется преобразование Шварца.

arrayPartialSort([func,] limit, arr, …)​

То же, что и arraySort с дополнительным аргументом limit, позволяющим частичную сортировку. Возвращает массив того же размера, как и исходный, в котором элементы [1..limit] отсортированы в возрастающем порядке. Остальные элементы (limit..N] остаются в неспецифицированном порядке.

arrayReverseSort([func,] arr, …)​

Возвращает массив arr, отсортированный в нисходящем порядке. Если указана функция func, то массив arr сначала сортируется в порядке, который определяется функцией func, а затем отсортированный массив переворачивается. Если функция func принимает несколько аргументов, то в функцию arrayReverseSort необходимо передавать несколько массивов, которые будут соответствовать аргументам функции func. Подробные примеры рассмотрены в конце описания функции arrayReverseSort.

Пример сортировки целочисленных значений:

SELECT arrayReverseSort([1, 3, 3, 0]);
┌─arrayReverseSort([1, 3, 3, 0])─┐
│ [3,3,1,0]                      │
└────────────────────────────────┘

Пример сортировки строковых значений:

SELECT arrayReverseSort(['hello', 'world', '!']);
┌─arrayReverseSort(['hello', 'world', '!'])─┐
│ ['world','hello','!']                     │
└───────────────────────────────────────────┘

Значения NULL, NaN и Inf сортируются в следующем порядке:

SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
┌─res───────────────────────────────────┐
│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────┘
  • Значения Inf идут в начале массива.
  • Значения NULL идут в конце массива.
  • Значения NaN идут перед NULL.
  • Значения -Inf идут перед NaN.

Функция arrayReverseSort является функцией высшего порядка — в качестве первого аргумента ей можно передать лямбда-функцию. Например:

SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
┌─res─────┐
│ [1,2,3] │
└─────────┘

В этом примере, порядок сортировки устанавливается следующим образом:

  1. Сначала исходный массив ([1, 2, 3]) сортируется в том порядке, который определяется лямбда-функцией. Результатом будет массив [3, 2, 1].
  2. Массив, который был получен на предыдущем шаге, переворачивается. То есть, получается массив [1, 2, 3].

Лямбда-функция может принимать на вход несколько аргументов. В этом случае, в функцию arrayReverseSort нужно передавать несколько массивов, которые будут соответствовать аргументам лямбда-функции (массивы должны быть одинаковой длины). Следует иметь в виду, что результат будет содержать элементы только из первого массива; элементы из всех последующих массивов будут определять ключи сортировки. Например:

SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
┌─res───────────────┐
│ ['hello','world'] │
└───────────────────┘

В этом примере, массив сортируется следующим образом:

  1. Сначала массив сортируется в том порядке, который определяется лямбда-функцией. Элементы, указанные во втором массиве ([2,1]), определяют ключи сортировки соответствующих элементов из исходного массива ([‘hello’, ‘world’]). То есть, будет массив [‘world’, ‘hello’].
  2. Массив, который был отсортирован на предыдущем шаге, переворачивается. Получается массив [‘hello’, ‘world’].

Ниже приведены ещё примеры.

SELECT arrayReverseSort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
┌─res─────┐
│ [0,1,2] │
└─────────┘
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
┌─res─────┐
│ [4,3,5] │
└─────────┘

arrayPartialReverseSort([func,] limit, arr, …)​

То же, что и arrayReverseSort с дополнительным аргументом limit, позволяющим частичную сортировку. Возвращает массив того же размера, как и исходный, в котором элементы [1..limit] отсортированы в убывающем порядке. Остальные элементы (limit..N] остаются в неспецифицированном порядке.

arrayUniq(arr, …)​

Если передан один аргумент, считает количество разных элементов в массиве. Если передано несколько аргументов, считает количество разных кортежей из элементов на соответствующих позициях в нескольких массивах.

Если необходимо получить список уникальных элементов массива, можно воспользоваться arrayReduce(‘groupUniqArray’, arr).

arrayJoin(arr)​

Особенная функция. Смотрите раздел «Функция arrayJoin».

arrayDifference​

Вычисляет разность между соседними элементами массива. Возвращает массив, где первым элементом будет 0, вторым – разность a[1] - a[0] и т. д. Тип элементов результирующего массива определяется правилами вывода типов при вычитании (напр. UInt8 - UInt8 = Int16).

Синтаксис

arrayDifference(array)

Аргументы

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

Возвращает массив разностей между соседними элементами.

Пример

Запрос:

SELECT arrayDifference([1, 2, 3, 4]);

Результат:

┌─arrayDifference([1, 2, 3, 4])─┐
│ [0,1,1,1]                     │
└───────────────────────────────┘

Пример переполнения из-за результирующего типа Int64:

Запрос:

SELECT arrayDifference([0, 10000000000000000000]);

Результат:

┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616]                   │
└────────────────────────────────────────────┘

arrayDistinct​

Принимает массив, возвращает массив, содержащий уникальные элементы.

Синтаксис

arrayDistinct(array)

Аргументы

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

Возвращает массив, содержащий только уникальные элементы исходного массива.

Пример

Запрос:

SELECT arrayDistinct([1, 2, 2, 3, 1]);

Ответ:

┌─arrayDistinct([1, 2, 2, 3, 1])─┐
│ [1,2,3]                        │
└────────────────────────────────┘

arrayEnumerateDense(arr)​

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

Пример:

SELECT arrayEnumerateDense([10, 20, 10, 30])
┌─arrayEnumerateDense([10, 20, 10, 30])─┐
│ [1,2,1,3]                             │
└───────────────────────────────────────┘

arrayIntersect(arr)​

Принимает несколько массивов, возвращает массив с элементами, присутствующими во всех исходных массивах.

Пример:

SELECT
    arrayIntersect([1, 2], [1, 3], [2, 3]) AS no_intersect,
    arrayIntersect([1, 2], [1, 3], [1, 4]) AS intersect
┌─no_intersect─┬─intersect─┐
│ []           │ [1]       │
└──────────────┴───────────┘

arrayReduce​

Применяет агрегатную функцию к элементам массива и возвращает ее результат. Имя агрегирующей функции передается как строка в одинарных кавычках 'max', 'sum'. При использовании параметрических агрегатных функций, параметр указывается после имени функции в круглых скобках 'uniqUpTo(6)'.

Синтаксис

arrayReduce(agg_func, arr1, arr2, ..., arrN)

Аргументы

  • agg_func — Имя агрегатной функции, которая должна быть константой string.
  • arr — Любое количество столбцов типа array в качестве параметров агрегатной функции.

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

Пример

Запрос:

SELECT arrayReduce('max', [1, 2, 3]);

Результат:

┌─arrayReduce('max', [1, 2, 3])─┐
│                             3 │
└───────────────────────────────┘

Если агрегатная функция имеет несколько аргументов, то эту функцию можно применять к нескольким массивам одинакового размера.

Пример

Запрос:

SELECT arrayReduce('maxIf', [3, 5], [1, 0]);

Результат:

┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│                                    3 │
└──────────────────────────────────────┘

Пример с параметрической агрегатной функцией:

Запрос:

SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

Результат:

┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│                                                           4 │
└─────────────────────────────────────────────────────────────┘

arrayReduceInRanges​

Применяет агрегатную функцию к элементам массива в заданных диапазонах и возвращает массив, содержащий результат, соответствующий каждому диапазону. Функция вернет тот же результат, что и несколько arrayReduce(agg_func, arraySlice(arr1, index, length), ...).

Синтаксис

arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN)

Аргументы

  • agg_func — имя агрегатной функции, которая должна быть строковой константой.
  • ranges — диапазоны для агрегирования, которые должны быть массивом of кортежей содержащих индекс и длину каждого диапазона.
  • arr — любое количество столбцов типа Array в качестве параметров агрегатной функции.

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

  • Массив, содержащий результаты агрегатной функции для указанных диапазонов.

Тип: Array.

Пример

Запрос:

SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res

Результат:

┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘

arrayReverse(arr)​

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

Пример:

SELECT arrayReverse([1, 2, 3])
┌─arrayReverse([1, 2, 3])─┐
│ [3,2,1]                 │
└─────────────────────────┘

reverse(arr)​

Синоним для «arrayReverse»

arrayFlatten​

Преобразует массив массивов в плоский массив.

Функция:

  • Оперирует с массивами любой вложенности.
  • Не изменяет массив, если он уже плоский.

Результирующий массив содержит все элементы исходных массивов.

Синтаксис

flatten(array_of_arrays)

Синоним: flatten.

Аргументы

  • array_of_arrays — массив массивов. Например, [[1,2,3], [4,5]].

Примеры

SELECT flatten([[[1]], [[2], [3]]]);
┌─flatten(array(array([1]), array([2], [3])))─┐
│ [1,2,3]                                     │
└─────────────────────────────────────────────┘

arrayCompact​

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

Синтаксис

arrayCompact(arr)

Аргументы

arr — массив для обхода.

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

Массив без последовательных дубликатов.

Тип: Array.

Пример

Запрос:

SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);

Результат:

┌─arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])─┐
│ [1,nan,nan,2,3]                            │
└────────────────────────────────────────────┘

arrayZip​

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

Синтаксис

arrayZip(arr1, arr2, ..., arrN)

Аргументы

Функция принимает любое количество массивов, которые могут быть различных типов. Все массивы должны иметь одинаковую длину.

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

  • Массив с элементами исходных массивов, сгруппированными в кортежи. Типы данных в кортежах соответствуют типам данных входных массивов и следуют в том же порядке, в котором переданы массивы.

Тип: Массив.

Пример

Запрос:

SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);

Результат:

┌─arrayZip(['a', 'b', 'c'], [5, 2, 1])─┐
│ [('a',5),('b',2),('c',1)]            │
└──────────────────────────────────────┘

arrayMap(func, arr1, …)​

Возвращает массив, полученный на основе результатов применения функции func к каждому элементу массива arr.

Примеры:

SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
┌─res─────┐
│ [3,4,5] │
└─────────┘

Следующий пример показывает, как создать кортежи из элементов разных массивов:

SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res;
┌─res─────────────────┐
│ [(1,4),(2,5),(3,6)] │
└─────────────────────┘

Функция arrayMap является функцией высшего порядка — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.

arrayFilter(func, arr1, …)​

Возвращает массив, содержащий только те элементы массива arr1, для которых функция func возвращает не 0.

Примеры:

SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
┌─res───────────┐
│ ['abc World'] │
└───────────────┘
SELECT
    arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr)
    AS res
┌─res─┐
│ [2] │
└─────┘

Функция arrayFilter является функцией высшего порядка — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.

arrayFill(func, arr1, …)​

Перебирает arr1 от первого элемента к последнему и заменяет arr1[i] на arr1[i - 1], если func вернула 0. Первый элемент arr1 остаётся неизменным.

Примеры:

SELECT arrayFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
┌─res──────────────────────────────┐
│ [1,1,3,11,12,12,12,5,6,14,14,14] │
└──────────────────────────────────┘

Функция arrayFill является функцией высшего порядка — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.

arrayReverseFill(func, arr1, …)​

Перебирает arr1 от последнего элемента к первому и заменяет arr1[i] на arr1[i + 1], если func вернула 0. Последний элемент arr1 остаётся неизменным.

Примеры:

SELECT arrayReverseFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
┌─res────────────────────────────────┐
│ [1,3,3,11,12,5,5,5,6,14,NULL,NULL] │
└────────────────────────────────────┘

Функция arrayReverseFill является функцией высшего порядка — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.

arraySplit(func, arr1, …)​

Разделяет массив arr1 на несколько. Если func возвращает не 0, то массив разделяется, а элемент помещается в левую часть. Массив не разбивается по первому элементу.

Примеры:

SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
┌─res─────────────┐
│ [[1,2,3],[4,5]] │
└─────────────────┘

Функция arraySplit является функцией высшего порядка — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.

arrayReverseSplit(func, arr1, …)​

Разделяет массив arr1 на несколько. Если func возвращает не 0, то массив разделяется, а элемент помещается в правую часть. Массив не разбивается по последнему элементу.

Примеры:

SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
┌─res───────────────┐
│ [[1],[2,3,4],[5]] │
└───────────────────┘

Функция arrayReverseSplit является функцией высшего порядка — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.

arrayExists([func,] arr1, …)​

Возвращает 1, если существует хотя бы один элемент массива arr, для которого функция func возвращает не 0. Иначе возвращает 0.

Функция arrayExists является функцией высшего порядка - в качестве первого аргумента ей можно передать лямбда-функцию.

arrayAll([func,] arr1, …)​

Возвращает 1, если для всех элементов массива arr, функция func возвращает не 0. Иначе возвращает 0.

Функция arrayAll является функцией высшего порядка - в качестве первого аргумента ей можно передать лямбда-функцию.

arrayFirst(func, arr1, …)​

Возвращает первый элемент массива arr1, для которого функция func возвращает не 0.

Функция arrayFirst является функцией высшего порядка — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.

arrayFirstIndex(func, arr1, …)​

Возвращает индекс первого элемента массива arr1, для которого функция func возвращает не 0.

Функция arrayFirstIndex является функцией высшего порядка — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.

arrayMin​

Возвращает значение минимального элемента в исходном массиве.

Если передана функция func, возвращается минимум из элементов массива, преобразованных этой функцией.

Функция arrayMin является функцией высшего порядка — в качестве первого аргумента ей можно передать лямбда-функцию.

Синтаксис

arrayMin([func,] arr)

Аргументы

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

  • Минимальное значение функции (или минимальный элемент массива).

Тип: если передана func, соответствует типу ее возвращаемого значения, иначе соответствует типу элементов массива.

Примеры

Запрос:

SELECT arrayMin([1, 2, 4]) AS res;

Результат:

┌─res─┐
│   1 │
└─────┘

Запрос:

SELECT arrayMin(x -> (-x), [1, 2, 4]) AS res;

Результат:

┌─res─┐
│  -4 │
└─────┘

arrayMax​

Возвращает значение максимального элемента в исходном массиве.

Если передана функция func, возвращается максимум из элементов массива, преобразованных этой функцией.

Функция arrayMax является функцией высшего порядка — в качестве первого аргумента ей можно передать лямбда-функцию.

Синтаксис

arrayMax([func,] arr)

Аргументы

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

  • Максимальное значение функции (или максимальный элемент массива).

Тип: если передана func, соответствует типу ее возвращаемого значения, иначе соответствует типу элементов массива.

Примеры

Запрос:

SELECT arrayMax([1, 2, 4]) AS res;

Результат:

┌─res─┐
│   4 │
└─────┘

Запрос:

SELECT arrayMax(x -> (-x), [1, 2, 4]) AS res;

Результат:

┌─res─┐
│  -1 │
└─────┘

arraySum​

Возвращает сумму элементов в исходном массиве.

Если передана функция func, возвращается сумма элементов массива, преобразованных этой функцией.

Функция arraySum является функцией высшего порядка — в качестве первого аргумента ей можно передать лямбда-функцию.

Синтаксис

arraySum([func,] arr)

Аргументы

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

  • Сумма значений функции (или сумма элементов массива).

Тип: для Decimal чисел в исходном массиве (если функция func была передана, то для чисел, преобразованных ею) — Decimal128, для чисел с плавающей точкой — Float64, для беззнаковых целых чисел — UInt64, для целых чисел со знаком — Int64.

Примеры

Запрос:

SELECT arraySum([2, 3]) AS res;

Результат:

┌─res─┐
│   5 │
└─────┘

Запрос:

SELECT arraySum(x -> x*x, [2, 3]) AS res;

Результат:

┌─res─┐
│  13 │
└─────┘

arrayAvg​

Возвращает среднее значение элементов в исходном массиве.

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

Функция arrayAvg является функцией высшего порядка — в качестве первого аргумента ей можно передать лямбда-функцию.

Синтаксис

arrayAvg([func,] arr)

Аргументы

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

  • Среднее значение функции (или среднее значение элементов массива).

Тип: Float64.

Примеры

Запрос:

SELECT arrayAvg([1, 2, 4]) AS res;

Результат:

┌────────────────res─┐
│ 2.3333333333333335 │
└────────────────────┘

Запрос:

SELECT arrayAvg(x -> (x * x), [2, 4]) AS res;

Результат:

┌─res─┐
│  10 │
└─────┘

Синтаксис

arraySum(arr)

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

  • Число.

Тип: Int или Float.

Аргументы

Примеры

Запрос:

SELECT arraySum([2,3]) AS res;

Результат:

┌─res─┐
│   5 │
└─────┘

Запрос:

SELECT arraySum(x -> x*x, [2, 3]) AS res;

Результат:

┌─res─┐
│  13 │
└─────┘

arrayCumSum([func,] arr1, …)​

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

Функция arrayCumSum является функцией высшего порядка - в качестве первого аргумента ей можно передать лямбда-функцию.

Пример:

SELECT arrayCumSum([1, 1, 1, 1]) AS res
┌─res──────────┐
│ [1, 2, 3, 4] │
└──────────────┘

arrayAUC​

Вычисляет площадь под кривой.

Синтаксис

arrayAUC(arr_scores, arr_labels)

Аргументы

  • arr_scores — оценка, которую дает модель предсказания.
  • arr_labels — ярлыки выборок, обычно 1 для содержательных выборок и 0 для бессодержательных выборок.

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

Значение площади под кривой.

Тип данных: Float64.

Пример

Запрос:

SELECT arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

Результат:

┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                                          0.75 │
└────────────────────────────────────────---──┘

arrayProduct​

Возвращает произведение элементов массива.

Синтаксис

arrayProduct(arr)

Аргументы

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

  • Произведение элементов массива.

Тип: Float64.

Примеры

Запрос:

SELECT arrayProduct([1,2,3,4,5,6]) as res;

Результат:

┌─res───┐
│ 720   │
└───────┘

Запрос:

SELECT arrayProduct([toDecimal64(1,8), toDecimal64(2,8), toDecimal64(3,8)]) as res, toTypeName(res);

Возвращаемое значение всегда имеет тип Float64. Результат:

┌─res─┬─toTypeName(arrayProduct(array(toDecimal64(1, 8), toDecimal64(2, 8), toDecimal64(3, 8))))─┐
│ 6   │ Float64                                                                                  │
└─────┴──────────────────────────────────────────────────────────────────────────────────────────┘

arrayRotateLeft​

Поворачивает массив влево на заданное число элементов. Если количество элементов отрицательно, то массив поворачивается вправо.

Синтаксис

arrayRotateLeft(arr, n)

Аргументы

  • arr — Массив.
  • n — Число элементов, на которое нужно повернуть массив.

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

  • Массив, повернутый на заданное число элементов влево.

Тип: Массив.

Примеры

Запрос:

SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;

Результат:

┌─res───────────┐
│ [3,4,5,6,1,2] │
└───────────────┘

Запрос:

SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;

Результат:

┌─res───────────┐
│ [5,6,1,2,3,4] │
└───────────────┘

Запрос:

SELECT arrayRotateLeft(['a','b','c','d','e'], 3) as res;

Результат:

┌─res───────────────────┐
│ ['d','e','a','b','c'] │
└───────────────────────┘

arrayRotateRight​

Поворачивает массив вправо на заданное число элементов. Если количество элементов отрицательно, то массив поворачивается влево.

Синтаксис

arrayRotateRight(arr, n)

Аргументы

  • arr — Массив.
  • n — Число элементов, на которое нужно повернуть массив.

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

  • Массив, повернутый на заданное число элементов вправо.

Тип: Массив.

Примеры

Запрос:

SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;

Результат:

┌─res───────────┐
│ [5,6,1,2,3,4] │
└───────────────┘

Запрос:

SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;

Результат:

┌─res───────────┐
│ [3,4,5,6,1,2] │
└───────────────┘

Запрос:

SELECT arrayRotateRight(['a','b','c','d','e'], 3) as res;

Результат:

┌─res───────────────────┐
│ ['c','d','e','a','b'] │
└───────────────────────┘

arrayShiftLeft​

Сдвигает массив влево на заданное число элементов. Новые элементы заполняются переданным аргументом или значением по умолчанию для типа элементов массива. Если количество элементов отрицательно, то массив сдвигается вправо.

Синтаксис

arrayShiftLeft(arr, n[, default])

Аргументы

  • arr — Массив.
  • n — Число элементов, на которое нужно сдвинуть массив.
  • default — Опциональный. Значение по умолчанию для новых элементов.

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

  • Массив, сдвинутый на заданное число элементов влево.

Тип: Массив.

Примеры

Запрос:

SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;

Результат:

┌─res───────────┐
│ [3,4,5,6,0,0] │
└───────────────┘

Запрос:

SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;

Результат:

┌─res───────────┐
│ [0,0,1,2,3,4] │
└───────────────┘

Запрос:

SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;

Результат:

┌─res─────────────┐
│ [3,4,5,6,42,42] │
└─────────────────┘

Запрос:

SELECT arrayShiftLeft(['a','b','c','d','e','f'], 3, 'foo') as res;

Результат:

┌─res─────────────────────────────┐
│ ['d','e','f','foo','foo','foo'] │
└─────────────────────────────────┘

Запрос:

SELECT arrayShiftLeft([1,2,3,4,5,6] :: Array(UInt16), 2, 4242) as res;

Результат:

┌─res─────────────────┐
│ [3,4,5,6,4242,4242] │
└─────────────────────┘

arrayShiftRight​

Сдвигает массив вправо на заданное число элементов. Новые элементы заполняются переданным аргументом или значением по умолчанию для типа элементов массива. Если количество элементов отрицательно, то массив сдвигается влево.

Синтаксис

arrayShiftRight(arr, n[, default])

Аргументы

  • arr — Массив.
  • n — Число элементов, на которое нужно сдвинуть массив.
  • default — Опциональный. Значение по умолчанию для новых элементов.

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

  • Массив, сдвинутый на заданное число элементов вправо.

Тип: Массив.

Примеры

Запрос:

SELECT arrayShiftRight([1,2,3,4,5,6], 2) as res;

Результат:

┌─res───────────┐
│ [0,0,1,2,3,4] │
└───────────────┘

Запрос:

SELECT arrayShiftRight([1,2,3,4,5,6], -2) as res;

Результат:

┌─res───────────┐
│ [3,4,5,6,0,0] │
└───────────────┘

Запрос:

SELECT arrayShiftRight([1,2,3,4,5,6], 2, 42) as res;

Результат:

┌─res─────────────┐
│ [42,42,1,2,3,4] │
└─────────────────┘

Запрос:

SELECT arrayShiftRight(['a','b','c','d','e','f'], 3, 'foo') as res;

Результат:

┌─res─────────────────────────────┐
│ ['foo','foo','foo','a','b','c'] │
└─────────────────────────────────┘

Запрос:

SELECT arrayShiftRight([1,2,3,4,5,6] :: Array(UInt16), 2, 4242) as res;

Результат:

┌─res─────────────────┐
│ [4242,4242,1,2,3,4] │
└─────────────────────┘