Функции для работы с массивами

array

Появилась в версии: v1.1

Создаёт массив из аргументов функции.

Аргументы должны быть константами и иметь типы, для которых существует общий супертип. Должен быть передан как минимум один аргумент, иначе будет непонятно, какой тип массива создавать. Это означает, что вы не можете использовать эту функцию для создания пустого массива. Для этого используйте функцию emptyArray*.

Для получения того же результата используйте оператор [ ].

Синтаксис

array(x1 [, x2, ..., xN])

Аргументы

x1 — константное значение любого типа T. Если указан только этот аргумент, массив будет иметь тип T.
[, x2, ..., xN] — дополнительные N константных значений с общим надтипом с x1

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

Возвращает массив, где 'T' — наименьший общий тип среди переданных аргументов. Array(T)

Примеры

Корректное использование

SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)

┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32)  │
└─────────┴───────────────┘

Неверное использование

SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)

Получено исключение от сервера (версия 25.4.3):
Код: 386. DB::Exception: Получено от localhost:9000. DB::Exception:
Отсутствует общий супертип для типов Int32, DateTime, Int8 ...

arrayAUCPR

Добавлена в: v20.4

Вычисляет площадь под кривой «точность–полнота» (precision–recall, PR). Кривая точность–полнота строится путём отображения точности по оси Y и полноты по оси X для всех порогов. Полученное значение лежит в диапазоне от 0 до 1, при этом большее значение соответствует более высокой эффективности модели. PR AUC особенно полезна для несбалансированных наборов данных, обеспечивая более наглядное сравнение качества модели по сравнению с ROC AUC в таких случаях. Для получения дополнительной информации смотрите здесь, здесь и здесь.

Синтаксис

arrayAUCPR(scores, labels[, partial_offsets])

Псевдонимы: arrayPRAUC

Аргументы

cores — Оценки, которые выдаёт модель предсказания. Array((U)Int*) или Array(Float*)
labels — Метки объектов, обычно 1 для положительного и 0 для отрицательного примера. Array((U)Int*) или Array(Enum)
partial_offsets —
Необязательный аргумент. Array(T) из трёх неотрицательных целых чисел для вычисления частичной площади под PR-кривой (эквивалент вертикальной полосе в PR-пространстве) вместо полной AUC. Этот параметр полезен для распределённого вычисления PR AUC. Массив должен содержать следующие элементы [higher_partitions_tp, higher_partitions_fp, total_positives].
- higher_partitions_tp: Количество положительных меток в партициях с более высокими оценками.
- higher_partitions_fp: Количество отрицательных меток в партициях с более высокими оценками.
- total_positives: Общее количество положительных примеров во всём наборе данных.

Примечание

Когда используется arr_partial_offsets, arr_scores и arr_labels должны представлять только одну партицию всего набора данных, содержащую некоторый интервал оценок. Набор данных должен быть разделён на смежные партиции, где каждая партиция содержит подмножество данных, оценки которого попадают в определённый диапазон. Например:

Одна партиция может содержать все оценки в диапазоне [0, 0.5).
Другая партиция может содержать оценки в диапазоне [0.5, 1.0].

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

Возвращает площадь под кривой «точность–полнота» (PR). Float64

Примеры

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

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

┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                              0.8333333333333333 │
└─────────────────────────────────────────────────┘

arrayAll

Добавлена в версии: v1.1

Возвращает 1, если лямбда-выражение func(x [, y1, y2, ... yN]) возвращает true для всех элементов. В противном случае возвращает 0.

Синтаксис

arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, которая применяется к элементам исходного массива (x) и массивам условий (y). Лямбда-функция
source_arr — исходный массив для обработки. Array(T)
cond1_arr, ... — Необязательно. N массивов условий, которые передают дополнительные аргументы в лямбда-функцию. Array(T)

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

Возвращает 1, если лямбда-функция возвращает true для всех элементов, в противном случае — 0. UInt8

Примеры

Все элементы соответствуют условию

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])

Не все элементы совпадают

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])

arrayAvg

Введена в версии v21.1

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

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

Синтаксис

arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — Необязательный параметр. Лямбда-функция, которая применяется к элементам исходного массива (x) и массивам условий (y). Lambda function
source_arr — Исходный массив для обработки. Array(T)
[, cond1_arr, ... , condN_arr] — Необязательный параметр. N массивов условий, предоставляющих дополнительные аргументы лямбда-функции. Array(T)

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

Возвращает среднее значение элементов исходного массива или среднее значение элементов результатов лямбда-функции, если она указана. Float64

Примеры

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

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

2.5

Использование с лямбда-функцией

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

6.5

arrayCompact

Впервые представлена в версии v20.1

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

Синтаксис

arrayCompact(arr)

Аргументы

arr — массив, из которого нужно удалить дубликаты. Array(T)

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

Возвращает массив без дубликатов значений Array(T)

Примеры

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

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

[1,nan,2,3]

arrayConcat

Введён в версии: v1.1

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

Синтаксис

arrayConcat(arr1 [, arr2, ... , arrN])

Аргументы

arr1 [, arr2, ... , arrN] — N массивов для конкатенации. Array(T)

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

Возвращает один объединённый массив из переданных массивов. Array(T)

Примеры

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

SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res

[1, 2, 3, 4, 5, 6]

arrayCount

Появилась в версии: v1.1

Возвращает количество элементов, для которых func(arr1[i], ..., arrN[i]) возвращает true. Если func не задана, возвращает количество ненулевых элементов в массиве.

arrayCount — это функция высшего порядка.

Синтаксис

arrayCount([func, ] arr1, ...)

Аргументы

func — Необязательный параметр. Функция, применяемая к каждому элементу массива/массивов. Lambda function
arr1, ..., arrN — N массивов. Array(T)

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

Возвращает количество элементов, для которых func возвращает значение true. В противном случае возвращает количество ненулевых элементов в массиве. UInt32

Примеры

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

SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)

arrayCumSum

Введена в версии: v1.1

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

Синтаксис

arrayCumSum([func,] arr1[, arr2, ... , arrN])

Аргументы

func — необязательный параметр. Лямбда-функция, применяемая к элементам массива для каждой позиции. Lambda function
arr1 — исходный массив числовых значений. Array(T)
[arr2, ..., arrN] — необязательные параметры. Дополнительные массивы того же размера, передаваемые в лямбда-функцию в качестве аргументов, если она указана. Array(T)

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

Возвращает массив частичных сумм элементов исходного массива. Тип результата соответствует числовому типу входного массива. Array(T)

Примеры

Базовое использование

SELECT arrayCumSum([1, 1, 1, 1]) AS res

[1, 2, 3, 4]

С лямбда-функцией

SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res

[2, 6, 12]

arrayCumSumNonNegative

Введена в версии: v18.12

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

Синтаксис

arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])

Аргументы

func — Необязательный параметр. Лямбда-функция, применяемая к элементам массива для каждой позиции. Lambda function
arr1 — Исходный массив числовых значений. Array(T)
[arr2, ..., arrN] — Необязательные. Дополнительные массивы того же размера, передаваемые как аргументы лямбда-функции, если она указана. Array(T)

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

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

Примеры

Базовое использование

SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res

[1, 2, 0, 1]

С лямбдой

SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res

[2, 0, 6]

arrayDifference

Функция появилась в версии v1.1.

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

Синтаксис

arrayDifference(arr)

Аргументы

arr — Массив, для которого вычисляют разности между соседними элементами. Array(T)

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

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

Примеры

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

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

[0,1,1,1]

Пример переполнения при типе результата Int64

SELECT arrayDifference([0, 10000000000000000000]);

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

arrayDistinct

Введена в версии: v1.1

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

Синтаксис

arrayDistinct(arr)

Аргументы

arr — Массив, из которого нужно извлечь различные элементы. Array(T)

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

Возвращает массив, содержащий различные элементы Array(T)

Примеры

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

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

[1,2,3]

arrayDotProduct

Добавлена в версии: v23.5

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

Примечание

Размеры двух векторов должны быть равны. Массивы и кортежи (Tuples) также могут содержать элементы разных типов.

Синтаксис

arrayDotProduct(v1, v2)

Аргументы

v1 — первый вектор. Array((U)Int* | Float* | Decimal) или Tuple((U)Int* | Float* | Decimal)
v2 — второй вектор. Array((U)Int* | Float* | Decimal) или Tuple((U)Int* | Float* | Decimal)

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

Скалярное произведение двух векторов.

Примечание

Тип возвращаемого значения определяется типом аргументов. Если Array или Tuple содержат элементы разных типов, тип результата — их супертип.

(U)Int* или Float* или Decimal

Примеры

Пример для Array

SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);

32    UInt16

Пример tuple

SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);

32    Float64

arrayElement

Впервые появился в версии: v1.1

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

Примечание

Массивы в ClickHouse индексируются с единицы.

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

Оператор [n] обладает той же функциональностью.

Синтаксис

arrayElement(arr, n)

Аргументы

arr — массив для поиска. Array(T). - n — позиция извлекаемого элемента. (U)Int*.

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

Возвращает один объединённый массив из переданных аргументов-массивов Array(T).

Примеры

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

SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

Отрицательные индексы

SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

Использование обозначения [n]

SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)

Выход индекса за границы массива

SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

arrayElementOrNull

Впервые появилась в версии v1.1

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

Примечание

Массивы в ClickHouse индексируются с единицы.

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

Синтаксис

arrayElementOrNull(arrays)

Аргументы

arrays — Произвольное количество аргументов-массивов. Array

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

Возвращает один объединённый массив из переданных массивов. Array(T)

Примеры

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

SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

Отрицательные индексы

SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

Индекс выходит за пределы массива

SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

NULL

arrayEnumerate

Введена в версии: v1.1

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

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

Синтаксис

arrayEnumerate(arr)

Аргументы

arr — массив, который требуется пронумеровать. Array

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

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

Примеры

Простейший пример с ARRAY JOIN

CREATE TABLE test
(
    `id` UInt8,
    `tag` Array(String),
    `version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);

SELECT
    id,
    tag,
    version,
    seq
FROM test
ARRAY JOIN
    tag,
    version,
    arrayEnumerate(tag) AS seq

┌─id─┬─tag────────────┬─version─────┬─seq─┐
│  1 │ release-stable │ 2.4.0       │   1 │
│  1 │ dev            │ 2.6.0-alpha │   2 │
│  1 │ security       │ 2.4.0-sec1  │   3 │
└────┴────────────────┴─────────────┴─────┘

arrayEnumerateDense

Появилась в версии: v18.12

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

Синтаксис

arrayEnumerateDense(arr)

Аргументы

arr — массив для перебора. Array(T)

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

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

Примеры

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

SELECT arrayEnumerateDense([10, 20, 10, 30])

[1,2,1,3]

arrayEnumerateDenseRanked

Добавлено в версии: v20.1

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

Синтаксис

arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)

Аргументы

clear_depth — перечислять элементы на указанном уровне отдельно. Должен быть меньше или равен max_arr_depth. UInt*
arr — N-мерный массив для перечисления. Array(T)
max_array_depth — максимальная эффективная глубина. Должна быть меньше или равна глубине arr. UInt*

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

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

Примеры

Базовое использование

-- При clear_depth=1 и max_array_depth=1 результат идентичен результату функции arrayEnumerateDense.

SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);

[1,2,1,3]

Использование с многомерным массивом

-- В этом примере arrayEnumerateDenseRanked используется для получения массива, который показывает для каждого элемента
-- многомерного массива его порядковый номер среди элементов с одинаковым значением.
-- Для первой строки переданного массива [10, 10, 30, 20] соответствующая первая строка результата — [1, 1, 2, 3],
-- что означает: 10 — это первое встреченное число в позициях 1 и 2, 30 — второе встреченное число в позиции 3,
-- а 20 — третье встреченное число в позиции 4.
-- Для второй строки [40, 50, 10, 30] соответствующая вторая строка результата — [4,5,1,2], что означает: 40
-- и 50 — это четвёртое и пятое встреченные числа в позициях 1 и 2 этой строки, ещё одно 10
-- (первое встреченное число) находится в позиции 3, а 30 (второе встреченное число) — в последней позиции.

SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);

[[1,1,2,3],[4,5,1,2]]

Пример с повышенным значением clear_depth

-- Изменение clear_depth=2 приводит к тому, что перечисление выполняется отдельно для каждой строки заново.

SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);

[[1, 1, 2, 3], [1, 2, 3, 4]]

arrayEnumerateUniq

Появилась в версии: v1.1

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

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

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

Синтаксис

arrayEnumerateUniq(arr1[, arr2, ... , arrN])

Аргументы

arr1 — Первый массив для обработки. Array(T)
arr2, ... — Необязательный параметр. Дополнительные массивы того же размера для обеспечения уникальности кортежей. Array(UInt32)

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

Возвращает массив, в котором каждый элемент — это позиция среди элементов с тем же значением или кортежем. Array(T)

Примеры

Базовое использование

SELECT arrayEnumerateUniq([10, 20, 10, 30]);

[1, 1, 2, 1]

Несколько массивов

SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);

[1,2,1,1,2,1]

Агрегация с ARRAY JOIN

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

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 │
└─────────┴─────────┴────────┘

arrayEnumerateUniqRanked

Впервые появилась в версии: v20.1

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

Синтаксис

arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)

Аргументы

clear_depth — Перечислять элементы на указанном уровне по отдельности. Положительное целое число, меньшее или равное max_arr_depth. UInt*
arr — N-мерный массив для перечисления. Array(T)
max_array_depth — Максимальная эффективная глубина. Положительное целое число, меньшее или равное глубине arr. UInt*

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

Возвращает N-мерный массив того же размера, что и arr, в котором каждый элемент показывает позицию этого элемента среди других элементов с тем же значением. Array(T)

Примеры

Пример 1

-- При clear_depth=1 и max_array_depth=1 результат arrayEnumerateUniqRanked
-- идентичен результату, который вернула бы функция arrayEnumerateUniq для того же массива.

SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);

[1, 1, 2]

Пример 2

-- при clear_depth=1 и max_array_depth=1 результат arrayEnumerateUniqRanked
-- идентичен результату, который вернула бы функция arrayEnumerateUniq для того же массива.

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);", "[[1, 1, 1], [2, 3, 2], [2]]

[1, 1, 2]

Пример 3

-- В этом примере arrayEnumerateUniqRanked используется для получения массива, который показывает
-- для каждого элемента многомерного массива его порядковый номер среди элементов
-- с таким же значением. Для первой строки переданного массива [1, 2, 3] соответствующий
-- результат — [1, 1, 1], что означает, что значения 1, 2 и 3 встречаются впервые.
-- Для второй строки переданного массива [2, 2, 1] соответствующий результат — [2, 3, 3],
-- что означает, что значение 2 встречается во второй и третий раз, а значение 1 — 
-- во второй раз. Аналогично, для третьей строки переданного массива [3]
-- соответствующий результат — [2], что означает, что значение 3 встречается во второй раз.

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

[[1, 1, 1], [2, 3, 2], [2]]

Пример 4

-- Изменение clear_depth=2 приводит к раздельной нумерации элементов для каждой строки.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

[[1, 1, 1], [1, 2, 1], [1]]

arrayExcept

Введена в версии v25.9

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

Эта функция выполняет операцию разности множеств между двумя массивами. Для каждого элемента в source она проверяет, существует ли этот элемент в except (с использованием точного сравнения). Если нет, элемент включается в результат.

Операция обладает следующими свойствами:

Порядок элементов из source сохраняется
Дубликаты в source сохраняются, если их нет в except
NULL обрабатывается как отдельное значение

Синтаксис

arrayExcept(source, except)

Аргументы

source — исходный массив с элементами, подлежащими фильтрации. Array(T)
except — массив, содержащий элементы, которые нужно исключить из результата. Array(T)

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

Возвращает массив того же типа, что и входной массив, содержащий элементы из source, отсутствующие в except. Array(T)

Примеры

Базовый пример

SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])

[1, 2, 2, 4]

with_nulls1

SELECT arrayExcept([1, NULL, 2, NULL], [2])

[1, NULL, NULL]

with_nulls2

SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])

[1]

строки

SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])

['яблоко', 'вишня']

arrayExists

Введена в версии: v1.1

Возвращает 1, если в исходном массиве есть хотя бы один элемент, для которого func(x[, y1, y2, ... yN]) возвращает true. В противном случае возвращает 0.

Синтаксис

arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, которая применяется к элементам исходного массива (x) и массивов условий (y). Lambda function
source_arr — исходный массив для обработки. Array(T)
[, cond1_arr, ... , condN_arr] — необязательный параметр. N массивов условий, передающих дополнительные аргументы лямбда-функции. Array(T)

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

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

Примеры

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

SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])

arrayFill

Добавлена в: v20.1

Функция arrayFill последовательно обрабатывает исходный массив от первого элемента до последнего, вычисляя лямбда‑условие на каждой позиции с использованием элементов из исходного массива и массива условий. Когда лямбда‑функция возвращает false на позиции i, функция заменяет этот элемент элементом на позиции i-1 из текущего состояния массива. Первый элемент всегда сохраняется независимо от каких‑либо условий.

Синтаксис

arrayFill(func(x [, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x [, y1, ..., yN]) — лямбда-функция func(x [, y1, y2, ... yN]) → F(x [, y1, y2, ... yN]), которая применяется к элементам исходного массива (x) и массивов-условий (y). Lambda function
source_arr — исходный массив для обработки. Lambda function
[, cond1_arr, ... , condN_arr] — Необязательные. N массивов-условий, которые передаются как дополнительные аргументы лямбда-функции. Array(T)

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

Возвращает массив Array(T)

Примеры

Пример с одним массивом

SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res

[1, 1, 2, 2]

Пример с двумя массивами

SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res

[5, 5, 6, 6]

arrayFilter

Появился в версии: v1.1

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

Синтаксис

arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, которая применяется к элементам исходного массива (x) и массивов условий (y). Lambda function
source_arr — исходный массив для обработки. Array(T)
[, cond1_arr, ... , condN_arr] — необязательный параметр. N массивов условий, предоставляющих дополнительные аргументы для лямбда-функции. Array(T)

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

Возвращает подмассив исходного массива Array(T)

Примеры

Пример 1

SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res

['abc World']

Пример 2

SELECT
    arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr)
    AS res

[2]

arrayFirst

Впервые появилось в версии v1.1

Возвращает первый элемент исходного массива, для которого func(x[, y1, y2, ... yN]) возвращает true, иначе возвращает значение по умолчанию.

Синтаксис

arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, которая работает с элементами исходного массива (x) и массивов условий (y). Lambda function. - source_arr — исходный массив для обработки. Array(T). - [, cond1_arr, ... , condN_arr] — необязательный параметр. N массивов условий, передающих дополнительные аргументы в лямбда-функцию. Array(T).

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

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

Примеры

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

SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Совпадений не найдено

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

0 UInt8

arrayFirstIndex

Появилась в версии: v1.1

Возвращает индекс первого элемента исходного массива, для которого func(x[, y1, y2, ... yN]) возвращает true, в противном случае возвращает 0.

Синтаксис

arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — lambda‑функция, которая работает с элементами исходного массива (x) и массивов условий (y). Лямбда‑функция. - source_arr — исходный массив для обработки. Array(T). - [, cond1_arr, ... , condN_arr] — необязательные N массивов условий, передающих дополнительные аргументы в lambda‑функцию. Array(T).

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

Возвращает индекс первого элемента исходного массива, для которого func возвращает true, в противном случае возвращает 0 UInt32.

Примеры

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

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Совпадений не найдено

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])

arrayFirstOrNull

Введена в версии: v1.1

Возвращает первый элемент исходного массива, для которого func(x[, y1, y2, ... yN]) возвращает true, в противном случае — NULL.

Синтаксис

arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, которая применяется к элементам исходного массива (x) и массивов-условий (y). Лямбда-функция
source_arr — исходный массив для обработки. Array(T)
[, cond1_arr, ... , condN_arr] — необязательный параметр. N массивов-условий, предоставляющих дополнительные аргументы для лямбда-функции. Array(T)

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

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

Примеры

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

SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Совпадений не найдено

SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

NULL Nullable(UInt8)

arrayFlatten

Введена в версии: v20.1

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

Функция:

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

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

Синтаксис

arrayFlatten(arr)

Псевдонимы: flatten

Аргументы

arr — многомерный массив. Array(Array(T))

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

Возвращает плоский массив, полученный из многомерного массива Array(T)

Примеры

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

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

[1, 2, 3]

arrayFold

Появилась в версии: v23.10

Применяет лямбда-функцию к одному или нескольким массивам одинаковой длины и накапливает результат в аккумуляторе.

Синтаксис

arrayFold(λ(acc, x1 [, x2, x3, ... xN]), arr1 [, arr2, arr3, ... arrN], acc)

Аргументы

λ(x, x1 [, x2, x3, ... xN]) — лямбда-функция λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN]), где F — операция, применяемая к acc и значениям массива x с последующим переиспользованием результата acc. Lambda function
arr1 [, arr2, arr3, ... arrN] — N массивов, над которыми выполняется операция. Array(T)
acc — аккумулятор, значение того же типа, что и тип возвращаемого значения лямбда-функции.

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

Возвращает конечное значение acc.

Примеры

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

SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;

Числа Фибоначчи

SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);

┌─fibonacci─┐
│         0 │
│         1 │
│         1 │
│         2 │
│         3 │
│         5 │
│         8 │
│        13 │
│        21 │
│        34 │
└───────────┘

Пример с несколькими массивами

SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;

arrayIntersect

Появилась в версии: v1.1

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

Синтаксис

arrayIntersect(arr, arr1, ..., arrN)

Аргументы

arrN — N массивов, из которых создаётся новый массив. Array(T).

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

Возвращает массив, содержащий уникальные элементы, присутствующие во всех N массивах. Array(T)

Примеры

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

SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection

┌─non_empty_intersection─┬─empty_intersection─┐
│ []                     │ [1]                │
└────────────────────────┴────────────────────┘

arrayJaccardIndex

Впервые появилась в версии v23.7

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

Синтаксис

arrayJaccardIndex(arr_x, arr_y)

Аргументы

arr_x — первый массив. Array(T)
arr_y — второй массив. Array(T)

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

Возвращает индекс Жаккара для массивов arr_x и arr_y Float64

Примеры

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

SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res

0.3333333333333333

arrayJoin

Впервые представлено в: v1.1

Функция arrayJoin принимает строку, содержащую массив, и разворачивает этот массив, создавая несколько строк — по одной для каждого элемента массива. В отличие от обычных функций в ClickHouse, которые преобразуют входные значения в выходные в пределах одной строки, агрегатные функции принимают группу строк и «сжимают» или «сводят» их в одну сводную строку (или в одно значение в сводной строке, если используются с GROUP BY).

Все значения в столбцах просто копируются, за исключением значений в столбце, к которому применяется эта функция; они заменяются соответствующим значением из массива.

Синтаксис

arrayJoin(arr)

Аргументы

arr — Массив для разворачивания. Array(T)

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

Возвращает набор строк, полученных из arr.

Примеры

Базовое использование

SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src

┌─dst─┬─\'Hello\'─┬─src─────┐
│   1 │ Hello     │ [1,2,3] │
│   2 │ Hello     │ [1,2,3] │
│   3 │ Hello     │ [1,2,3] │
└─────┴───────────┴─────────┘

arrayJoin влияет на все части запроса

-- Функция arrayJoin влияет на все секции запроса, включая секцию WHERE. Обратите внимание на результат 2, хотя подзапрос вернул 1 строку.

SELECT sum(1) AS impressions
FROM
(
    SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];

┌─impressions─┐
│           2 │
└─────────────┘

Использование нескольких функций arrayJoin

- Запрос может использовать несколько функций arrayJoin. В этом случае преобразование выполняется многократно, и количество строк увеличивается соответственно.

SELECT
    sum(1) AS impressions,
    arrayJoin(cities) AS city,
    arrayJoin(browsers) AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3

┌─impressions─┬─city─────┬─browser─┐
│           2 │ Istanbul │ Chrome  │
│           1 │ Istanbul │ Firefox │
│           2 │ Berlin   │ Chrome  │
│           1 │ Berlin   │ Firefox │
│           2 │ Bobruisk │ Chrome  │
│           1 │ Bobruisk │ Firefox │
└─────────────┴──────────┴─────────┘

Неожиданные результаты из-за оптимизаций

-- Использование нескольких arrayJoin с одинаковым выражением может не дать ожидаемого результата из-за оптимизаций.
-- В таких случаях рекомендуется модифицировать повторяющееся выражение массива дополнительными операциями, не влияющими на результат объединения.
- например: arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- технически корректно, но приведёт к уничтожению набора результатов
    arrayJoin(arrayConcat(dice, [])) as second_throw -- выражение намеренно изменено для принудительного повторного вычисления
FROM (
    SELECT [1, 2, 3, 4, 5, 6] as dice
);

┌─первый_бросок─┬─второй_бросок─┐
│           1 │            1 │
│           1 │            2 │
│           1 │            3 │
│           1 │            4 │
│           1 │            5 │
│           1 │            6 │
│           2 │            1 │
│           2 │            2 │
│           2 │            3 │
│           2 │            4 │
│           2 │            5 │
│           2 │            6 │
│           3 │            1 │
│           3 │            2 │
│           3 │            3 │
│           3 │            4 │
│           3 │            5 │
│           3 │            6 │
│           4 │            1 │
│           4 │            2 │
│           4 │            3 │
│           4 │            4 │
│           4 │            5 │
│           4 │            6 │
│           5 │            1 │
│           5 │            2 │
│           5 │            3 │
│           5 │            4 │
│           5 │            5 │
│           5 │            6 │
│           6 │            1 │
│           6 │            2 │
│           6 │            3 │
│           6 │            4 │
│           6 │            5 │
│           6 │            6 │
└───────────────┴───────────────┘

Использование синтаксиса ARRAY JOIN

-- Обратите внимание на синтаксис ARRAY JOIN в запросе `SELECT` ниже — он предоставляет более широкие возможности.
-- ARRAY JOIN позволяет одновременно преобразовывать несколько массивов с одинаковым количеством элементов.

SELECT
    sum(1) AS impressions,
    city,
    browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
    cities AS city,
    browsers AS browser
GROUP BY
    2,
    3

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Istanbul │ Firefox │
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
└─────────────┴──────────┴─────────┘

Использование типа Tuple

-- Также можно использовать кортеж (Tuple)

SELECT
    sum(1) AS impressions,
    (arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
    t.2 AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Istanbul │ Firefox │
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
└─────────────┴──────────┴─────────┘

arrayLast

Добавлена в версии: v1.1

Возвращает последний элемент исходного массива, для которого лямбда-функция func(x [, y1, y2, ... yN]) возвращает true, в противном случае возвращает значение по умолчанию.

Синтаксис

arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, применяемая к элементам исходного массива (x) и массивам условий (y). Lambda function. - source — исходный массив для обработки. Array(T). - [, cond1, ... , condN] — необязательный параметр. N массивов условий, передающих дополнительные аргументы в лямбда-функцию. Array(T).

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

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

Примеры

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

SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

Совпадений не найдено

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

0 UInt8

arrayLastIndex

Добавлена в версии: v1.1

Возвращает индекс последнего элемента в исходном массиве, для которого func(x[, y1, y2, ... yN]) возвращает true, в противном случае возвращает '0'.

Синтаксис

arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, применяемая к элементам исходного массива (x) и массивов-условий (y). Lambda function
source_arr — исходный массив для обработки. Array(T)
[, cond1_arr, ... , condN_arr] — необязательный параметр. N массивов-условий, передающих дополнительные аргументы в лямбда-функцию. Array(T)

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

Возвращает индекс последнего элемента исходного массива, для которого func возвращает true, в противном случае возвращает 0 UInt32

Примеры

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

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);

Совпадений не найдено

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);

arrayLastOrNull

Добавлена в версии v1.1

Возвращает последний элемент исходного массива, для которого лямбда func(x [, y1, y2, ... yN]) возвращает true, в противном случае возвращает NULL.

Синтаксис

arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x [, y1, ..., yN]) — лямбда-функция, которая обрабатывает элементы исходного массива (x) и массивов условий (y). Лямбда‑функция.

source_arr — исходный массив для обработки. Array(T).
[, cond1_arr, ... , condN_arr] — необязательно. N массивов условий, предоставляющих дополнительные аргументы лямбда‑функции. Array(T).

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

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

Примеры

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

SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

Совпадений не найдено

SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

NULL Nullable(UInt8)

arrayLevenshteinDistance

Добавлена в версии: v25.4

Вычисляет расстояние Левенштейна между двумя массивами.

Синтаксис

arrayLevenshteinDistance(from, to)

Аргументы

from — первый массив. Array(T). - to — второй массив. Array(T).

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

Расстояние Левенштейна между первым и вторым массивами. Float64

Примеры

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

SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])

arrayLevenshteinDistanceWeighted

Введена в версии: v25.4

Вычисляет расстояние Левенштейна для двух массивов с настраиваемыми весами для каждого элемента. Число элементов в массиве и число весов должно совпадать.

Синтаксис

arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)

Аргументы

from — первый массив. Array(T). - to — второй массив. Array(T). - from_weights — веса элементов первого массива. Array((U)Int*|Float*)
to_weights — веса элементов второго массива. Array((U)Int*|Float*)

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

Расстояние Левенштейна между первым и вторым массивами с пользовательскими весами для каждого элемента типа Float64

Примеры

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

SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])

arrayMap

Введена в версии: v1.1

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

Синтаксис

arrayMap(func, arr)

Аргументы

func — лямбда-функция, которая применяется к элементам исходного массива (x) и массивов условий (y). Lambda function
arr — N массивов для обработки. Array(T)

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

Возвращает массив из результатов выполнения лямбда-функции Array(T)

Примеры

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

SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;

[3, 4, 5]

Создание кортежа из элементов разных массивов

SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res

[(1, 4),(2, 5),(3, 6)]

arrayMax

Добавлена в: v21.1

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

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

Синтаксис

arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — Необязательный параметр. Лямбда-функция, которая применяется к элементам исходного массива (x) и массивов условий (y). Lambda function
source_arr — Исходный массив для обработки. Array(T)
[, cond1_arr, ... , condN_arr] — Необязательный параметр. N массивов условий, передающих дополнительные аргументы лямбда-функции. Array(T)

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

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

Примеры

Базовый пример

SELECT arrayMax([5, 3, 2, 7]);

Использование с лямбда-функцией

SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

arrayMin

Впервые появилась в версии: v21.1

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

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

Синтаксис

arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — Необязательный параметр. Лямбда-функция, которая применяется к элементам исходного массива (x) и массивов условий (y). Lambda function
source_arr — Исходный массив для обработки. Array(T)
cond1_arr, ... — Необязательные параметры. N массивов условий, предоставляющих дополнительные аргументы для лямбда-функции. Array(T)

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

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

Примеры

Базовый пример

SELECT arrayMin([5, 3, 2, 7]);

Использование с лямбда-функцией

SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

arrayNormalizedGini

Введена в версии: v25.1

Вычисляет нормированный коэффициент Джини.

Синтаксис

arrayNormalizedGini(predicted, label)

Аргументы

predicted — Предсказанное значение. Array(T)
label — Фактическое значение. Array(T)

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

Кортеж, содержащий коэффициент Джини для предсказанных значений, коэффициент Джини для нормализованных значений и нормализованный коэффициент Джини (= отношение первых двух указанных коэффициентов Джини) Tuple(Float64, Float64, Float64)

Примеры

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

SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);

(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)

arrayPartialReverseSort

Появилась в версии: v23.2

Эта функция аналогична arrayReverseSort, но с дополнительным аргументом limit, который позволяет выполнять частичную сортировку.

Совет

Чтобы сохранить только отсортированные элементы, используйте arrayResize.

Синтаксис

arrayPartialReverseSort([f,] arr [, arr1, ... ,arrN], limit)

Аргументы

f(arr[, arr1, ... ,arrN]) — lambda-функция, применяемая к элементам массива arr. Lambda function
arr — Массив, который необходимо отсортировать. Array(T)
arr1, ... ,arrN — N дополнительных массивов в случае, если f принимает несколько аргументов. Array(T)
limit — Значение индекса, до которого будет выполняться сортировка. (U)Int*

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

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

Примеры

simple_int

SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])

[9, 5, 1, 3]

simple_string

SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])

['lasso','gladly','expenses','embolism']

retain_sorted

SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)

[9, 5]

lambda_simple

SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])

[1, 3, 5, 9]

lambda_complex

SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

[0, 1, 2]

arrayPartialShuffle

Введено в версии: v23.2

Возвращает массив того же размера, что и исходный, в котором элементы в диапазоне [1..limit] представляют собой случайное подмножество исходного массива. Оставшиеся элементы (limit..n] должны содержать элементы, не вошедшие в диапазон [1..limit], в неопределённом порядке. Значение limit должно быть в диапазоне [1..n]. Значения вне этого диапазона эквивалентны выполнению полного arrayShuffle:

Примечание

Эта функция не материализует константы.

Значение limit должно быть в диапазоне [1..N]. Значения вне этого диапазона эквивалентны выполнению полного arrayShuffle.

Синтаксис

arrayPartialShuffle(arr [, limit[, seed]])

Аргументы

arr — Массив, который нужно случайным образом перемешать. Array(T)
seed — Необязательный параметр. Инициализирующее значение (seed) для генератора случайных чисел. Если не задан, используется случайное значение. (U)Int*
limit — Необязательный параметр. Число, ограничивающее количество перестановок элементов, в диапазоне [1..N]. (U)Int*

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

Массив с частично перемешанными элементами. Array(T)

Примеры

no_limit1

SELECT arrayPartialShuffle([1, 2, 3, 4], 0)

[2, 4, 3, 1]

no_limit2

SELECT arrayPartialShuffle([1, 2, 3, 4])

[4, 1, 3, 2]

random_seed

SELECT arrayPartialShuffle([1, 2, 3, 4], 2)

[3, 4, 1, 2]

explicit_seed

SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)

[3, 2, 1, 4]

materialize

SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)

┌─arrayPartial⋯4]), 2, 42)─┬─arrayPartial⋯ 3], 2, 42)─┐
│ [3,2,1,4]                │ [3,2,1]                  │
│ [3,2,1,4]                │ [3,2,1]                  │
│ [4,3,2,1]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,4,1,2]                │ [3,2,1]                  │
│ [1,2,3,4]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,1,2,4]                │ [3,2,1]                  │
│ [1,3,2,4]                │ [3,2,1]                  │
└──────────────────────────┴──────────────────────────┘

arrayPartialSort

Добавлена в версии: v23.2

Эта функция аналогична arraySort, но с дополнительным аргументом limit, который позволяет выполнять частичную сортировку.

Совет

Чтобы оставить только отсортированные элементы, используйте arrayResize.

Синтаксис

arrayPartialSort([f,] arr [, arr1, ... ,arrN], limit)

Аргументы

f(arr[, arr1, ... ,arrN]) — Лямбда-функция, применяемая к элементам массива x. Lambda function
arr — Массив, который нужно отсортировать. Array(T)
arr1, ... ,arrN — N дополнительных массивов, если f принимает несколько аргументов. Array(T)
limit — Значение индекса, до которого (включительно) будет выполняться сортировка. (U)Int*

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

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

Примеры

simple_int

SELECT arrayPartialSort(2, [5, 9, 1, 3])

[1, 3, 5, 9]

simple_string

SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])

['embolism', 'expenses', 'gladly', 'lasso']

retain_sorted

SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)

[1, 3]

lambda_simple

SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])

[9, 5, 1, 3]

lambda_complex

SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

[2, 1, 0]

arrayPopBack

Добавлена в версии: v1.1

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

Синтаксис

arrayPopBack(arr)

Аргументы

arr — массив, у которого нужно удалить последний элемент. Array(T)

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

Возвращает массив, идентичный arr, но без его последнего элемента. Array(T)

Примеры

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

SELECT arrayPopBack([1, 2, 3]) AS res;

[1, 2]

arrayPopFront

Впервые появилась в версии: v1.1

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

Синтаксис

arrayPopFront(arr)

Аргументы

arr — массив, из которого нужно удалить первый элемент. Array(T)

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

Возвращает массив Array(T), идентичный arr, но без его первого элемента.

Примеры

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

SELECT arrayPopFront([1, 2, 3]) AS res;

[2, 3]

arrayProduct

Введена в версии: v21.1

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

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

Синтаксис

arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — Необязательный параметр. Лямбда‑функция, которая применяется к элементам исходного массива (x) и массивов условий (y). Lambda function
source_arr — Исходный массив для обработки. Array(T)
[, cond1_arr, ... , condN_arr] — Необязательный параметр. N массивов условий, предоставляющих дополнительные аргументы лямбда‑функции. Array(T)

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

Возвращает произведение элементов исходного массива или произведение элементов, возвращённых лямбда‑функцией, если она указана. Float64

Примеры

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

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

Использование с функцией Lambda

SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;

arrayPushBack

Добавлена в версии: v1.1

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

Синтаксис

arrayPushBack(arr, x)

Аргументы

arr — массив, в конец которого нужно добавить значение x. Array(T)
x —
Отдельное значение, которое нужно добавить в конец массива. Array(T).

Примечание

В массив с числами можно добавлять только числа, а в массив со строками — только строки.
При добавлении чисел ClickHouse автоматически приводит тип x к типу данных массива.
Может быть NULL. Функция добавляет элемент NULL в массив, а тип элементов массива преобразуется в Nullable.

Для получения дополнительной информации о типах данных в ClickHouse см. раздел Data types.

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

Возвращает массив, идентичный arr, но с добавленным в конец массива значением x Array(T)

Примеры

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

SELECT arrayPushBack(['a'], 'b') AS res;

['a','b']

arrayPushFront

Впервые появилась в версии: v1.1

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

Синтаксис

arrayPushFront(arr, x)

Аргументы

arr — Массив, к концу которого нужно добавить значение x. Array(T). - x —
Одно значение, которое нужно добавить в начало массива. Array(T).

Примечание

В массив с числами можно добавлять только числа, а в массив строк — только строки.
При добавлении чисел ClickHouse автоматически приводит тип x к типу данных массива.
Может быть NULL. Функция добавляет элемент NULL в массив, и тип элементов массива преобразуется в Nullable.

Дополнительную информацию о типах данных в ClickHouse см. в разделе Типы данных.

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

Возвращает массив, идентичный arr, но с дополнительным значением x в начале массива Array(T)

Примеры

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

SELECT arrayPushFront(['b'], 'a') AS res;

['a','b']

arrayROCAUC

Появилась в версии: v20.4

Вычисляет площадь под ROC-кривой (Receiver Operating Characteristic). ROC-кривая строится путем отображения True Positive Rate (TPR) по оси y и False Positive Rate (FPR) по оси x для всех порогов. Получаемое значение лежит в диапазоне от нуля до единицы, при этом большее значение указывает на лучшую производительность модели.

ROC AUC (также просто AUC) — это понятие в машинном обучении. Подробнее см. здесь, здесь и здесь.

Синтаксис

arrayROCAUC(scores, labels[, scale[, partial_offsets]])

Псевдонимы: arrayAUC

Аргументы

scores — оценки (скоры), которые возвращает модель предсказания. Array((U)Int*) или Array(Float*)
labels — метки объектов, обычно 1 для положительного примера и 0 для отрицательного. Array((U)Int*) или Enum
scale — необязательный параметр. Определяет, нужно ли возвращать нормированную площадь. Если false, вместо этого возвращает площадь под кривой TP (true positives, истинно положительные) × FP (false positives, ложно положительные). Значение по умолчанию: true. Bool
partial_offsets —
Массив из четырёх неотрицательных целых чисел для вычисления частичной площади под ROC-кривой (что эквивалентно вертикальной полосе в ROC-пространстве) вместо полного AUC. Эта опция полезна для распределённого вычисления ROC AUC. Массив должен содержать следующие элементы [higher_partitions_tp, higher_partitions_fp, total_positives, total_negatives]. Array из неотрицательных Integers. Необязательный параметр.
- higher_partitions_tp: количество положительных меток в разбиениях с более высокими значениями оценок.
- higher_partitions_fp: количество отрицательных меток в разбиениях с более высокими значениями оценок.
- total_positives: общее количество положительных примеров во всём наборе данных.
- total_negatives: общее количество отрицательных примеров во всём наборе данных.

Примечание

Когда используется arr_partial_offsets, arr_scores и arr_labels должны содержать только часть всего набора данных, соответствующую некоторому интервалу значений оценок. Набор данных должен быть разделён на смежные разбиения, где каждое разбиение содержит подмножество данных с оценками, попадающими в определённый диапазон. Например:

Одно разбиение может содержать все оценки в диапазоне [0, 0.5).
Другое разбиение может содержать оценки в диапазоне [0.5, 1.0].

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

Возвращает площадь под ROC-кривой (receiver operating characteristic). Float64

Примеры

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

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

0.75

arrayRandomSample

Появилась в: v23.10

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

Синтаксис

arrayRandomSample(arr, samples)

Аргументы

arr — Входной массив или многомерный массив, из которого выбираются элементы. Array(T)
samples — Количество элементов в случайной выборке. (U)Int*

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

Массив, содержащий случайную выборку элементов из входного массива. Array(T)

Примеры

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

SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;

['cherry','apple']

Использование многомерных массивов

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

[[3,4],[5,6]]

arrayReduce

Введена в версии: v1.1

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

Синтаксис

arrayReduce(agg_f, arr1 [, arr2, ... , arrN)])

Аргументы

agg_f — имя агрегатной функции, которое должно быть константой. String
arr1 [, arr2, ... , arrN)] — N массивов, соответствующих аргументам функции agg_f. Array(T)

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

Возвращает результат агрегатной функции.

Примеры

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

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

Появилась в версии: v20.4

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

Синтаксис

arrayReduceInRanges(agg_f, ranges, arr1 [, arr2, ... ,arrN)])

Аргументы

agg_f — имя агрегатной функции, которую следует использовать. String
ranges — диапазоны, по которым выполняется агрегация. Массив кортежей (i, r), содержащих индекс i, с которого нужно начать, и диапазон r, по которому выполняется агрегация. Array(T) или Tuple(T)
arr1 [, arr2, ... ,arrN)] — N массивов в качестве аргументов агрегатной функции. Array(T)

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

Возвращает массив с результатами работы агрегатной функции по заданным диапазонам — Array(T)

Примеры

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

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] │
└─────────────────────────────┘

arrayRemove

Добавлено в версии v25.11

Удаляет из массива все элементы, равные заданному значению. Значения NULL считаются равными.

Синтаксис

arrayRemove(arr, elem)

Псевдонимы: array_remove

Аргументы

arr — Array(T) - elem — T

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

Возвращает подмножество исходного массива типа Array(T)

Примеры

Пример 1

SELECT arrayRemove([1, 2, 2, 3], 2)

[1, 3]

Пример 2

SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)

['a', 'b']

arrayResize

Появилась в версии: v1.1

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

Синтаксис

arrayResize(arr, size[, extender])

Аргументы

arr — Массив, размер которого нужно изменить. Array(T)
size —
- Новая длина массива. Если size меньше исходного размера массива, массив усекается справа. Если size больше исходного размера массива, массив расширяется справа значениями extender или значениями по умолчанию для типа данных элементов массива.
extender — Значение, используемое для расширения массива. Может быть NULL.

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

Массив длины size. Array(T)

Примеры

Пример 1

SELECT arrayResize([1], 3);

[1,0,0]

Пример 2

SELECT arrayResize([1], 3, NULL);

[1,NULL,NULL]

arrayReverse

Добавлена в версии: v1.1

Меняет порядок элементов в заданном массиве на обратный.

Примечание

Функция reverse(arr) выполняет ту же функцию, но работает и с другими типами данных, а не только с массивами.

Синтаксис

arrayReverse(arr)

Аргументы

arr — Массив, который нужно развернуть. Array(T)

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

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

Примеры

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

SELECT arrayReverse([1, 2, 3])

[3,2,1]

arrayReverseFill

Впервые введена в версии: v20.1

Функция arrayReverseFill последовательно обрабатывает исходный массив от последнего элемента к первому, вычисляя лямбда-условие в каждой позиции с использованием элементов из исходного массива и массива условий. Когда условие оказывается ложным на позиции i, функция заменяет этот элемент элементом на позиции i+1 из текущего состояния массива. Последний элемент всегда сохраняется, независимо от условия.

Синтаксис

arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, которая применяется к элементам исходного массива (x) и массивов условий (y). Lambda function
source_arr — исходный массив для обработки. Array(T)
[, cond1_arr, ... , condN_arr] — Необязательный параметр. N массивов условий, передающих дополнительные аргументы лямбда-функции. Array(T)

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

Возвращает массив, в котором элементы исходного массива заменены результатами применения лямбда-функции. Array(T)

Примеры

Пример с одним массивом

SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res

[1, 2, 2, NULL]

Пример с двумя массивами

SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;

[5, 6, 6, 2]

arrayReverseSort

Введена в версии v1.1

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

Если сортируемый массив содержит -Inf, NULL, NaN или Inf, они будут отсортированы в следующем порядке:

-Inf
Inf
NaN
NULL

arrayReverseSort — это функция высшего порядка.

Синтаксис

arrayReverseSort([f,] arr [, arr1, ... ,arrN)

Аргументы

f(y1[, y2 ... yN]) — лямбда-функция, которая применяется к элементам массива x.
arr — массив, который нужно отсортировать. Array(T)
arr1, ..., yN — необязательные N дополнительных массивов, используемых, если f принимает несколько аргументов.

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

Возвращает массив x, отсортированный по убыванию, если лямбда-функция не задана; в противном случае возвращает массив, отсортированный в соответствии с логикой переданной лямбда-функции, после чего порядок элементов в нём инвертируется. Array(T).

Примеры

Пример 1

SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;

[5,3,4]

Пример 2

SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;

[4,3,5]

arrayReverseSplit

Появилась в версии: v20.1

Разбивает исходный массив на несколько массивов. Когда func(x[, y1, ..., yN]) возвращает ненулевое значение, массив будет разделён сразу после этого элемента. После последнего элемента массив не разделяется.

Синтаксис

arrayReverseSplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, которая применяется к элементам исходного массива (x) и массивам условий (y). Лямбда-функция
source_arr — исходный массив для обработки. Лямбда-функция
[, cond1_arr, ... , condN_arr] — необязательный параметр. N массивов условий, передающих дополнительные аргументы лямбда-функции. Array(T)

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

Возвращает массив массивов. Array(Array(T))

Примеры

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

SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

[[1], [2, 3, 4], [5]]

arrayRotateLeft

Введена в версии: v23.8

Выполняет циклический сдвиг элементов массива влево на заданное количество позиций. Отрицательные значения n рассматриваются как сдвиг вправо на абсолютное значение параметра.

Синтаксис

arrayRotateLeft(arr, n)

Аргументы

arr — массив, элементы которого нужно циклически сдвинуть. Array(T).
n — количество элементов для сдвига. (U)Int8/16/32/64.

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

Массив, циклически сдвинутый влево на указанное число элементов. Array(T)

Примеры

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

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

[3,4,5,6,1,2]

Отрицательное значение n

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

[5,6,1,2,3,4]

arrayRotateRight

Введена в версии v23.8

Выполняет циклический сдвиг массива вправо на указанное количество элементов. Отрицательные значения n интерпретируются как циклический сдвиг влево на абсолютное значение величины сдвига.

Синтаксис

arrayRotateRight(arr, n)

Аргументы

arr — массив, для которого выполняется циклический сдвиг элементов. Array(T)
n — количество элементов для сдвига. (U)Int8/16/32/64

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

Массив, циклически сдвинутый вправо на указанное количество элементов. Array(T)

Примеры

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

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

[5,6,1,2,3,4]

Отрицательное значение n

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

[3,4,5,6,1,2]

arrayShiftLeft

Появилась в версии: v23.8

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

Синтаксис

arrayShiftLeft(arr, n[, default])

Аргументы

arr — массив, элементы которого необходимо сдвинуть. Array(T). - n — количество элементов для сдвига. (U)Int8/16/32/64. - default — необязательный параметр. Значение по умолчанию для новых элементов.

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

Массив, сдвинутый влево на указанное количество элементов Array(T)

Примеры

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

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

[3,4,5,6,0,0]

Отрицательное значение n

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

[0,0,1,2,3,4]

Использование значения по умолчанию

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

[3,4,5,6,42,42]

arrayShiftRight

Появилась в версии v23.8

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

Синтаксис

arrayShiftRight(arr, n[, default])

Аргументы

arr — Массив, элементы которого сдвигаются. Array(T)
n — Число элементов, на которое выполняется сдвиг. (U)Int8/16/32/64
default — Необязательный параметр. Значение по умолчанию для новых элементов.

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

Массив, сдвинутый вправо на указанное число элементов. Array(T)

Примеры

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

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

[0, 0, 1, 2, 3, 4]

Отрицательное значение n

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

[3, 4, 5, 6, 0, 0]

Использование значения по умолчанию

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

[42, 42, 1, 2, 3, 4]

arrayShingles

Добавлена в версии v24.1

Генерирует массив шинглов (аналогов n-грамм для строк), то есть последовательных подмассивов входного массива заданной длины.

Синтаксис

arrayShingles(arr, l)

Аргументы

arr — Массив, для которого генерируется массив шинглов. Array(T)
l — Длина каждого шингла. (U)Int*

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

Массив сгенерированных шинглов Array(T)

Примеры

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

SELECT arrayShingles([1, 2, 3, 4], 3) as res;

[[1, 2, 3], [2, 3, 4]]

arrayShuffle

Добавлена в версии: v23.2

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

Примечание

Эта функция не материализует константы.

Синтаксис

arrayShuffle(arr [, seed])

Аргументы

arr — Массив для перемешивания. Array(T)
seed (optional) — Необязательный параметр. Начальное значение (seed), используемое для генерации случайных чисел. Если не указано, используется случайное значение. (U)Int*

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

Массив с перемешанными элементами. Array(T)

Примеры

Пример без seed (недетерминированные результаты)

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

[1,4,2,3]

Пример без заданного seed (стабильные результаты)

SELECT arrayShuffle([1, 2, 3, 4], 41);

[3,2,1,4]

arraySimilarity

Появилась в версии: v25.4

Вычисляет меру сходства двух массивов от 0 до 1 на основе взвешенного расстояния Левенштейна.

Синтаксис

arraySimilarity(from, to, from_weights, to_weights)

Аргументы

from — первый массив Array(T)
to — второй массив Array(T)
from_weights — веса для первого массива Array((U)Int*|Float*)
to_weights — веса для второго массива Array((U)Int*|Float*)

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

Возвращает меру сходства в диапазоне от 0 до 1 для двух массивов на основе взвешенного расстояния Левенштейна Float64

Примеры

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

SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);

0.2222222222222222

arraySlice

Введена в версии: v1.1

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

Синтаксис

arraySlice(arr, offset [, length])

Аргументы

arr — Массив, из которого берётся срез. Array(T)
offset — Смещение относительно края массива. Положительное значение задаёт смещение слева, отрицательное — смещение справа. Нумерация элементов массива начинается с 1. (U)Int*
length — Длина требуемого среза. Если указать отрицательное значение, функция вернёт открытый срез [offset, array_length - length]. Если параметр не указан, функция вернёт срез [offset, the_end_of_array]. (U)Int*

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

Возвращает срез массива из length элементов, начиная с указанного offset Array(T)

Примеры

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

SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;

[2, NULL, 4]

arraySort

Введена в версии: v1.1

Сортирует элементы переданного массива по возрастанию. Если указана лямбда-функция f, порядок сортировки определяется результатом применения лямбды к каждому элементу массива. Если лямбда принимает несколько аргументов, функции arraySort передаётся несколько массивов, элементам которых будут соответствовать аргументы f.

Если сортируемый массив содержит -Inf, NULL, NaN или Inf, они будут отсортированы в следующем порядке:

-Inf
Inf
NaN
NULL

arraySort — это функция высшего порядка.

Синтаксис

arraySort([f,] arr [, arr1, ... ,arrN])

Аргументы

f(y1[, y2 ... yN]) — лямбда-функция, применяемая к элементам массива x.
arr — массив, который нужно отсортировать. Array(T)
arr1, ..., yN — необязательные аргументы. N дополнительных массивов, если f принимает несколько аргументов.

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

Возвращает массив arr, отсортированный по возрастанию, если лямбда-функция не задана, в противном случае возвращает массив, отсортированный в соответствии с логикой, реализованной в переданной лямбда-функции. Array(T).

Примеры

Пример 1

SELECT arraySort([1, 3, 3, 0]);

[0,1,3,3]

Пример 2

SELECT arraySort(['hello', 'world', '!']);

['!','hello','world']

Пример 3

SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);

[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]

arraySplit

Добавлена в версии: v20.1

Разбивает исходный массив на несколько массивов. Когда func(x [, y1, ..., yN]) возвращает значение, отличное от нуля, массив будет разделён слева от этого элемента. Массив не будет разделён перед первым элементом.

Синтаксис

arraySplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — лямбда-функция, которая обрабатывает элементы исходного массива (x) и массивов условий (y). Lambda function.
source_arr — исходный массив для разбиения Array(T).
[, cond1_arr, ... , condN_arr] — необязательный параметр. N массивов условий, передающих дополнительные аргументы в лямбда-функцию. Array(T).

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

Возвращает массив массивов Array(Array(T))

Примеры

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

SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

[[1, 2, 3], [4, 5]]

arraySum

Введена в: v21.1

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

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

Синтаксис

arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Аргументы

func(x[, y1, ..., yN]) — Необязательный параметр. Лямбда-функция, которая применяется к элементам исходного массива (x) и массивов условий (y). Lambda function
source_arr — Исходный массив для обработки. Array(T)
, cond1_arr, ... , condN_arr] — Необязательный параметр. N массивов условий, предоставляющих дополнительные аргументы лямбда-функции. Array(T)

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

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

Примеры

Базовый пример

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

Использование с функцией Lambda

SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);

arraySymmetricDifference

Добавлено в: v25.4

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

Примечание

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

Синтаксис

arraySymmetricDifference(arr1, arr2, ... , arrN)

Аргументы

arrN — N массивов, из которых создаётся новый массив. Array(T).

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

Возвращает массив различных элементов, которые не присутствуют во всех исходных массивах Array(T).

Примеры

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

SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;

┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ []                         │ [3]                            │
└────────────────────────────┴────────────────────────────────┘

arrayUnion

Добавлена в: v24.10

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

Синтаксис

arrayUnion(arr1, arr2, ..., arrN)

Аргументы

arrN — N массивов, из которых формируется новый массив. Array(T)

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

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

Примеры

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

SELECT
arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example

┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1]   │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘

arrayUniq

Появилась в версии: v1.1

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

Например, SELECT arrayUniq([1,2], [3,4], [5,6]) сформирует следующие кортежи:

Позиция 1: (1,3,5)
Позиция 2: (2,4,6)

Затем будет подсчитано количество уникальных кортежей. В данном случае 2.

Все переданные массивы должны иметь одинаковую длину.

Совет

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

Синтаксис

arrayUniq(arr1[, arr2, ..., arrN])

Аргументы

arr1 — Массив, для которого нужно посчитать количество уникальных элементов. Array(T)
[, arr2, ..., arrN] — Необязательные аргументы. Дополнительные массивы, используемые для подсчёта количества уникальных кортежей элементов на соответствующих позициях в нескольких массивах. Array(T)

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

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

Примеры

Один аргумент

SELECT arrayUniq([1, 1, 2, 2])

Несколько аргументов

SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])

arrayWithConstant

Появилась в версии: v20.1

Создаёт массив длины length, заполненный константой x.

Синтаксис

arrayWithConstant(N, x)

Аргументы

length — количество элементов в массиве. (U)Int*
x — значение N элементов в массиве, произвольного типа.

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

Возвращает массив из N элементов со значением x. Array(T)

Примеры

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

SELECT arrayWithConstant(3, 1)

[1, 1, 1]

arrayZip

Появилась в версии: v20.1

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

Синтаксис

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

Аргументы

arr1, arr2, ... , arrN — N массивов для объединения в один массив. Array(T)

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

Возвращает массив с элементами исходных массивов, сгруппированными в кортежи. Типы данных в кортеже совпадают с типами входных массивов и следуют в том же порядке, в котором массивы передаются. Array(T)

Примеры

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

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

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

arrayZipUnaligned

Впервые добавлена в: v20.1

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

Синтаксис

arrayZipUnaligned(arr1, arr2, ..., arrN)

Аргументы

arr1, arr2, ..., arrN — N массивов, которые нужно объединить в один массив. Array(T)

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

Возвращает массив с элементами из исходных массивов, сгруппированными в кортежи. Типы данных в кортеже совпадают с типами входных массивов и следуют в том же порядке, в каком переданы массивы. Array(T) или Tuple(T1, T2, ...)

Примеры

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

SELECT arrayZipUnaligned(['a'], [1, 2, 3]);

[('a', 1),(NULL, 2),(NULL, 3)]

countEqual

Появилась в версии: v1.1

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

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

Синтаксис

countEqual(arr, x)

Аргументы

arr — Массив, в котором выполняется поиск. Array(T)
x — Значение в массиве, количество вхождений которого нужно посчитать. Любой тип.

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

Возвращает количество элементов в массиве, равных x UInt64

Примеры

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

SELECT countEqual([1, 2, NULL, NULL], NULL)

empty

Добавлена в версии: v1.1

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

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

Примечание

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

Функция также работает со строками (String) и UUID.

Синтаксис

empty(arr)

Аргументы

arr — входной массив типа Array(T)

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

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

Примеры

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

SELECT empty([]);

emptyArrayDate

Введена в версии: v1.1

Возвращает пустой массив типа Date

Синтаксис

emptyArrayDate()

Аргументы

Нет.

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

Пустой массив типа Date. Array(T)

Примеры

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

SELECT emptyArrayDate

[]

emptyArrayDateTime

Впервые представлена в версии v1.1

Возвращает пустой массив значений типа DateTime

Синтаксис

emptyArrayDateTime()

Аргументы

Отсутствуют.

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

Пустой массив DateTime. Array(T)

Примеры

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

SELECT emptyArrayDateTime

[]

emptyArrayFloat32

Появилась в версии: v1.1

Возвращает пустой массив типа Float32

Синтаксис

emptyArrayFloat32()

Аргументы

Отсутствуют.

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

Пустой массив Float32. Array(T)

Примеры

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

SELECT emptyArrayFloat32

[]

emptyArrayFloat64

Добавлена в: v1.1

Возвращает пустой массив типа Float64

Синтаксис

emptyArrayFloat64()

Аргументы

Отсутствуют.

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

Пустой массив Float64. Array(T)

Примеры

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

SELECT emptyArrayFloat64

[]

emptyArrayInt16

Добавлена в версии: v1.1

Возвращает пустой массив типа Int16

Синтаксис

emptyArrayInt16()

Аргументы

Отсутствуют.

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

Пустой массив типа Int16. Array(T)

Примеры

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

SELECT emptyArrayInt16

[]

emptyArrayInt32

Введена в: v1.1

Возвращает пустой массив типа Int32

Синтаксис

emptyArrayInt32()

Аргументы

Нет.

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

Пустой массив Int32. Array(T)

Примеры

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

SELECT emptyArrayInt32

[]

emptyArrayInt64

Впервые появилось в: v1.1

Возвращает пустой массив Int64

Синтаксис

emptyArrayInt64()

Аргументы

Отсутствуют.

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

Пустой массив Int64. Array(T)

Примеры

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

SELECT emptyArrayInt64

[]

emptyArrayInt8

Добавлена в версии: v1.1

Возвращает пустой массив типа Int8

Синтаксис

emptyArrayInt8()

Аргументы

Отсутствуют.

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

Пустой массив типа Int8. Array(T)

Примеры

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

SELECT emptyArrayInt8

[]

emptyArrayString

Добавлена в версии: v1.1

Возвращает пустой массив типа String

Синтаксис

emptyArrayString()

Аргументы

Нет.

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

Пустой массив строк. Array(T)

Примеры

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

SELECT emptyArrayString

[]

emptyArrayToSingle

Добавлено в: v1.1

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

Синтаксис

emptyArrayToSingle(arr)

Аргументы

arr — пустой массив. Array(T)

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

Массив с одним значением типа по умолчанию для массива. Array(T)

Примеры

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

CREATE TABLE test (
  a Array(Int32),
  b Array(String),
  c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO test VALUES ([], [], []);

SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;

┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0]                   │ ['']                  │ ['1970-01-01 01:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘

emptyArrayUInt16

Добавлена в: v1.1

Возвращает пустой массив UInt16

Синтаксис

emptyArrayUInt16()

Аргументы

Отсутствуют.

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

Пустой массив UInt16. Array(T)

Примеры

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

SELECT emptyArrayUInt16

[]

emptyArrayUInt32

Введено в версии: v1.1

Возвращает пустой массив типа UInt32

Синтаксис

emptyArrayUInt32()

Аргументы

Нет аргументов.

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

Пустой массив UInt32. Array(T)

Примеры

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

SELECT emptyArrayUInt32

[]

emptyArrayUInt64

Добавлена в: v1.1

Возвращает пустой массив UInt64

Синтаксис

emptyArrayUInt64()

Аргументы

Отсутствуют.

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

Пустой массив типа UInt64. Array(T)

Примеры

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

SELECT emptyArrayUInt64

[]

emptyArrayUInt8

Добавлена в версии v1.1

Возвращает пустой массив типа UInt8

Синтаксис

emptyArrayUInt8()

Аргументы

Отсутствуют.

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

Пустой массив типа UInt8. Array(T)

Примеры

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

SELECT emptyArrayUInt8

[]

has

Добавлена в: v1.1

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

Синтаксис

has(arr, x)

Аргументы

arr — исходный массив. Array(T)
x — значение, которое нужно найти в массиве.

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

Возвращает 1, если массив содержит указанный элемент, иначе 0. UInt8

Примеры

Базовое использование

SELECT has([1, 2, 3], 2)

Не найдено

SELECT has([1, 2, 3], 4)

hasAll

Добавлена в версии: v1.1

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

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

Синтаксис

hasAll(set, subset)

Аргументы

set — массив любого типа с набором элементов. Array(T)
subset — массив любого типа, который имеет общий супертип с set и содержит элементы, проверяемые на то, что они образуют подмножество set. Array(T)

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

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

Генерируется исключение NO_COMMON_TYPE, если элементы множества и подмножества не имеют общего супертипа.

Примеры

Пустые массивы

SELECT hasAll([], [])

Массивы, содержащие значения NULL

SELECT hasAll([1, Null], [Null])

Массивы, содержащие значения разных типов

SELECT hasAll([1.0, 2, 3, 4], [1, 3])

Массивы, содержащие значения типа String

SELECT hasAll(['a', 'b'], ['a'])

Массивы без общего типа данных

SELECT hasAll([1], ['a'])

Вызывает исключение NO_COMMON_TYPE

Массив массивов

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])

hasAny

Добавлена в версии: v1.1

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

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

Синтаксис

hasAny(arr_x, arr_y)

Аргументы

arr_x — массив любого типа с набором элементов. Array(T)
arr_y — массив любого типа, имеющий общий супертип с массивом arr_x. Array(T)

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

1, если arr_x и arr_y имеют по крайней мере один общий элемент.
0 — в противном случае.

Выбрасывает исключение NO_COMMON_TYPE, если какие-либо элементы двух массивов не имеют общего супертипа.

Примеры

Один массив пустой

SELECT hasAny([1], [])

Массивы, содержащие значения NULL

SELECT hasAny([Null], [Null, 1])

Массивы, содержащие значения иного типа

SELECT hasAny([-128, 1., 512], [1])

Массивы без общего типа

SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])

Вызывает исключение `NO_COMMON_TYPE`

Массив массивов

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])

hasSubstr

Введена в версии: v20.6

Проверяет, встречаются ли все элементы массива array2 в массиве array1 в точно таком же порядке. Соответственно, функция вернёт 1 тогда и только тогда, когда array1 = prefix + array2 + suffix.

Другими словами, функция проверяет, содержатся ли все элементы массива array2 в массиве array1, аналогично функции hasAll. Кроме того, она проверяет, что элементы расположены в одном и том же порядке в обоих массивах array1 и array2.

Функция вернёт 1, если array2 пустой.
Null обрабатывается как значение. Другими словами, hasSubstr([1, 2, NULL, 3, 4], [2,3]) вернёт 0. Однако hasSubstr([1, 2, NULL, 3, 4], [2,NULL,3]) вернёт 1.
Порядок значений в обоих массивах имеет значение.

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

Синтаксис

hasSubstr(arr1, arr2)

Аргументы

arr1 — Массив произвольного типа с набором элементов. Array(T)
arr2 — Массив произвольного типа с набором элементов. Array(T)

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

Возвращает 1, если массив arr1 содержит массив arr2. В противном случае возвращает 0. UInt8

Примеры

Оба массива пусты

SELECT hasSubstr([], [])

Массивы, содержащие значения NULL

SELECT hasSubstr([1, Null], [Null])

Массивы, содержащие значения разных типов

SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])

Массивы строк

SELECT hasSubstr(['a', 'b'], ['a'])

Массивы с корректным порядком

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])

Массивы с некорректным порядком

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])

Массив массивов

SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])

Массивы без единого типа

SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])

Вызывает исключение `NO_COMMON_TYPE`

indexOf

Добавлена в версии: v1.1

Функция возвращает индекс первого элемента со значением 'x' (начиная с 1), если он есть в массиве. Если массив не содержит искомого значения, функция возвращает 0.

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

Синтаксис

indexOf(arr, x)

Аргументы

arr — Массив, в котором выполняется поиск значения x. Array(T)
x — Значение первого совпадающего элемента в arr, индекс которого требуется вернуть. UInt64

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

Возвращает индекс (отсчёт от единицы) первого вхождения x в arr, если такое значение существует. В противном случае возвращает 0. UInt64

Примеры

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

SELECT indexOf([5, 4, 1, 3], 3)

Массив с NULL-значениями

SELECT indexOf([1, 3, NULL, NULL], NULL)

indexOfAssumeSorted

Добавлено в: v24.12

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

Примечание

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

Синтаксис

indexOfAssumeSorted(arr, x)

Аргументы

arr — отсортированный массив для поиска. Array(T)
x — значение первого совпадающего элемента в отсортированном массиве arr, индекс которого нужно вернуть. UInt64

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

Возвращает индекс (нумерация с единицы) первого x в arr, если такой элемент существует. В противном случае возвращает 0. UInt64

Примеры

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

SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)

length

Добавлена в: v1.1

Вычисляет длину строки или массива.

Для аргументов типа String или FixedString: вычисляет количество байт в строке.
Для аргументов типа Array: вычисляет количество элементов в массиве.
При применении к аргументу типа FixedString функция является константным выражением.

Обратите внимание, что количество байт в строке не совпадает с количеством Unicode "code points" (кодовых точек) и не совпадает с количеством Unicode "grapheme clusters" (того, что мы обычно называем "символами"), и не совпадает с видимой шириной строки.

В строках допустимо наличие нулевых байтов (ASCII NULL), и они также будут учитываться.

Синтаксис

length(x)

Псевдонимы: OCTET_LENGTH

Аргументы

x — значение, для которого вычисляется количество байт (для String/FixedString) или элементов (для Array). String или FixedString или Array(T)

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

Возвращает количество байт в String/FixedString x или количество элементов в массиве x. Тип: UInt64

Примеры

Пример для строки String

SELECT length('Hello, world!')

Пример массива

SELECT length(['Hello', 'world'])

пример constexpr

WITH 'hello' || toString(number) AS str
SELECT str,
isConstant(length(str)) AS str_length_is_constant,
isConstant(length(str::FixedString(6))) AS fixed_str_length_is_constant
FROM numbers(3)

┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │                      0 │                            1 │
│ hello1 │                      0 │                            1 │
│ hello2 │                      0 │                            1 │
└────────┴────────────────────────┴──────────────────────────────┘

пример Unicode

SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)

┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │            8 │                4 │ ёлка │           10 │                5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘

пример ascii_vs_utf8

SELECT 'ábc' AS str, length(str), lengthUTF8(str)

┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │            4 │               3 │
└─────┴──────────────┴─────────────────┘

notEmpty

Добавлена в: v1.1

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

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

Примечание

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

Функцию также можно применять к значениям типов String и UUID.

Синтаксис

notEmpty(arr)

Аргументы

arr — входной массив. Array(T)

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

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

Примеры

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

SELECT notEmpty([1,2]);

range

Введена в версии: v1.1

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

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

UInt8/16/32/64
Int8/16/32/64
Все аргументы start, end, step должны быть одним из указанных выше поддерживаемых типов. Элементы возвращаемого массива будут иметь тип — общий супертип аргументов.
Генерируется исключение, если функция возвращает массив с общей длиной больше числа элементов, указанного настройкой function_range_max_elements_in_block.
Возвращает NULL, если какой-либо аргумент имеет тип Nullable(Nothing). Генерируется исключение, если какой-либо аргумент имеет значение NULL (тип Nullable(T)).

Синтаксис

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

Аргументы

start — Необязательный параметр. Первый элемент массива. Обязателен, если используется step. Значение по умолчанию: 0. - end — Обязательный параметр. Число, до которого (не включительно) строится массив. - step — Необязательный параметр. Определяет шаг между элементами массива. Значение по умолчанию: 1.

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

Массив чисел от start до end - 1 с шагом step. Array(T)

Примеры

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

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

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

replicate

Добавлено в: v1.1

Создаёт массив, содержащий одно значение.

Синтаксис

replicate(x, arr)

Аргументы

x — значение, которым заполняется результирующий массив. Any
arr — массив. Array(T)

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

Возвращает массив той же длины, что и arr, заполненный значением x. Array(T)

Примеры

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

SELECT replicate(1, ['a', 'b', 'c']);

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

reverse

Добавлена в версии v1.1

Меняет порядок следования элементов во входном массиве или символов во входной строке на обратный.

Синтаксис

reverse(arr | str)

Аргументы

arr | str — Исходный массив или строка. Array(T) или String

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

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

Примеры

Массив в обратном порядке

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

[4, 3, 2, 1]

Реверс строки

SELECT reverse('abcd');

'dcba'

Функции расстояния

Все поддерживаемые функции описаны в документации по функциям расстояния.

array​

arrayAUCPR​

arrayAll​

arrayAvg​

arrayCompact​

arrayConcat​

arrayCount​

arrayCumSum​

arrayCumSumNonNegative​

arrayDifference​

arrayDistinct​

arrayDotProduct​

arrayElement​

arrayElementOrNull​

arrayEnumerate​

arrayEnumerateDense​

arrayEnumerateDenseRanked​

arrayEnumerateUniq​

arrayEnumerateUniqRanked​

arrayExcept​

arrayExists​

arrayFill​

arrayFilter​

arrayFirst​

arrayFirstIndex​

arrayFirstOrNull​

arrayFlatten​

arrayFold​

arrayIntersect​

arrayJaccardIndex​

arrayJoin​

arrayLast​

arrayLastIndex​

arrayLastOrNull​

arrayLevenshteinDistance​

arrayLevenshteinDistanceWeighted​

arrayMap​

arrayMax​

arrayMin​

arrayNormalizedGini​

arrayPartialReverseSort​

arrayPartialShuffle​

arrayPartialSort​

arrayPopBack​

arrayPopFront​

arrayProduct​

arrayPushBack​

arrayPushFront​

arrayROCAUC​

arrayRandomSample​

arrayReduce​

arrayReduceInRanges​

arrayRemove​

arrayResize​

arrayReverse​

arrayReverseFill​

arrayReverseSort​

arrayReverseSplit​

arrayRotateLeft​

arrayRotateRight​

arrayShiftLeft​

arrayShiftRight​

arrayShingles​

arrayShuffle​

arraySimilarity​

arraySlice​

arraySort​

arraySplit​

arraySum​

arraySymmetricDifference​

arrayUnion​

arrayUniq​

arrayWithConstant​

arrayZip​

arrayZipUnaligned​

countEqual​

empty​

emptyArrayDate​

emptyArrayDateTime​

emptyArrayFloat32​

array

arrayAUCPR

arrayAll

arrayAvg

arrayCompact

arrayConcat

arrayCount

arrayCumSum

arrayCumSumNonNegative

arrayDifference

arrayDistinct

arrayDotProduct

arrayElement

arrayElementOrNull

arrayEnumerate

arrayEnumerateDense

arrayEnumerateDenseRanked

arrayEnumerateUniq

arrayEnumerateUniqRanked

arrayExcept

arrayExists

arrayFill

arrayFilter

arrayFirst

arrayFirstIndex

arrayFirstOrNull

arrayFlatten

arrayFold

arrayIntersect

arrayJaccardIndex

arrayJoin

arrayLast

arrayLastIndex

arrayLastOrNull

arrayLevenshteinDistance

arrayLevenshteinDistanceWeighted

arrayMap

arrayMax

arrayMin

arrayNormalizedGini

arrayPartialReverseSort

arrayPartialShuffle

arrayPartialSort

arrayPopBack

arrayPopFront

arrayProduct

arrayPushBack

arrayPushFront

arrayROCAUC

arrayRandomSample

arrayReduce

arrayReduceInRanges

arrayRemove

arrayResize

arrayReverse

arrayReverseFill

arrayReverseSort

arrayReverseSplit

arrayRotateLeft

arrayRotateRight

arrayShiftLeft

arrayShiftRight

arrayShingles

arrayShuffle

arraySimilarity

arraySlice

arraySort

arraySplit

arraySum

arraySymmetricDifference

arrayUnion

arrayUniq

arrayWithConstant

arrayZip

arrayZipUnaligned

countEqual

empty

emptyArrayDate

emptyArrayDateTime

emptyArrayFloat32