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

Добавленный в: v1.1.0

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

Аргументы должны быть константами и иметь типы с общим супертипом. Нужно передать как минимум один аргумент, иначе будет неясно, массив какого типа создавать. Это означает, что эту функцию нельзя использовать для создания пустого массива. Для этого используйте функцию 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)

┌─a───────────────────────────┬─toTypeName(a)─────────────────────────┐
│ [5,'1998-06-16 00:00:00',5] │ Array(Variant(DateTime, Int32, Int8)) │
└─────────────────────────────┴───────────────────────────────────────┘

Добавленный в: v20.4.0

Вычисляет площадь под кривой точность-полнота (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: Общее количество положительных примеров во всём наборе данных.

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

Возвращает площадь под кривой точность-полнота (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 │
└─────────────────────────────────────────────────┘

Добавленный в: v1.1.0

Возвращает 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])

1

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

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

0

Добавленный в: v26.4.0

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

Синтаксис

arrayAutocorrelation(arr, [max_lag])

Аргументы

• arr — Массив чисел. Array(T)
• max_lag — Необязательный параметр. Максимальное число вычисляемых лагов. Должен быть неотрицательным целым числом. Integer

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

Возвращает массив значений типа Float64. Возвращает NaN, если дисперсия равна 0. Array(Float64)

Примеры

Линейный

SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);

[1,0.4,-0.1,-0.4,-0.4]

Симметричный

SELECT arrayAutocorrelation([10, 20, 10]);

[1,-0.6666666666666669,0.16666666666666674]

Константа

SELECT arrayAutocorrelation([5, 5, 5]);

[nan,nan,nan]

Ограничено

SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);

[1,0.4]

Добавленный в: v21.1.0

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

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

Синтаксис

arrayAvg([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)

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

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

Примеры

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

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

2.5

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

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

6.5

Добавленный в: v26.6.0

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

Значения NULL пропускаются и не включаются в результат. Размер результата не превышает K и может быть меньше, если входной массив содержит меньше не-NULL элементов, чем K. Тип элементов результата — не-Nullable версия типа элементов входного массива.

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

См. также:

• arrayTopK, которая возвращает K наибольших элементов.
• arrayPartialSort, которая помещает те же K элементов в позиции [1..K], но также сохраняет остальные элементы в неопределённом порядке и не пропускает значения NULL.

Синтаксис

arrayBottomK([f,] K, arr [, arr1, ... ,arrN])

Аргументы

• f(arr[, arr1, ... ,arrN]) — Необязательно. Лямбда-функция для вычисления ключа сортировки для каждого элемента. Лямбда-функция
• K — Число наименьших элементов, которые нужно вернуть. (U)Int8/16/32/64
• arr — Массив. Array(T)
• arr1, ... ,arrN — N дополнительных массивов, если f принимает несколько аргументов. Array(T)

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

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

Примеры

simple_int

SELECT arrayBottomK(3, [1, 5, 2, 7, 3])

[1,2,3]

skip_nulls

SELECT arrayBottomK(3, [1, NULL, 5, 2, NULL, 7])

[1,2,5]

fewer_than_k

SELECT arrayBottomK(5, [1, NULL, 2])

[1,2]

lambda_simple

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

[9,5]

lambda_multi

SELECT arrayBottomK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

['b','c']

Добавленный в: v20.1.0

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

Синтаксис

arrayCompact(arr)

Аргументы

• arr — Массив, из которого удаляются дубликаты. Array(T)

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

Возвращает массив без повторяющихся значений Array(T)

Примеры

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

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

[1,nan,2,3]

Добавленный в: v1.1.0

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

Синтаксис

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]

Добавленный в: v1.1.0

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

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

Синтаксис

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

Аргументы

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

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

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

Примеры

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

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

5

Добавленный в: v1.1.0

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

Синтаксис

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

Аргументы

• func — Необязательно. Лямбда-функция, применяемая к элементам массива на каждой позиции. Лямбда-функция
• 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]

Добавленный в: v18.12.0

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

Синтаксис

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

Аргументы

• func — Необязательно. Лямбда-функция, применяемая к элементам массива в каждой позиции. Лямбда-функция
• 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]

Добавленный в: v1.1.0

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

Синтаксис

arrayDifference(arr)

Аргументы

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

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

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

Примеры

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

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

[0,1,1,1]

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

SELECT arrayDifference([0, 10000000000000000000]);

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

Добавленный в: v1.1.0

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

Синтаксис

arrayDistinct(arr)

Аргументы

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

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

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

Примеры

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

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

[1,2,3]

Добавленный в: v23.5.0

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

Синтаксис

arrayDotProduct(v1, v2)

Аргументы

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

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

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

(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

Добавленный в: v1.1.0

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

Если n является массивом целых чисел, возвращает массив элементов в указанных позициях (операция выборки). Это эквивалентно arrayMap(i -> arr[i], n), но имеет отдельную, более эффективную реализацию. Для позиций за границами массива возвращается значение по умолчанию, как и для скалярного индекса. Элементы индекса могут быть nullable. Индекс NULL возвращает NULL (и делает тип элемента результата nullable), если тип элемента можно обернуть в Nullable; для типов элементов, которые не могут находиться внутри Nullable (таких как Array, Map), индекс NULL вместо этого возвращает значение по умолчанию. Это то же поведение, что и для скалярного индекса NULL.

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

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

Первым аргументом также может быть QBit: n-й элемент вектора восстанавливается с полной точностью типа элемента QBit, при этом считываются только битовые плоскости группы stride, содержащей этот элемент.

Синтаксис

arrayElement(arr, n)

Аргументы

• arr — Массив, в котором выполняется поиск. Array(T) или QBit. - n — Позиция элемента, который требуется получить, или массив позиций. Позиции могут быть Nullable. (U)Int* или Array((U)Int*).

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

Если n — скаляр, возвращает элемент типа T. Если n — массив, возвращает Array(Nullable(T)), если элементы индекса могут быть Nullable и T можно обернуть в Nullable, в противном случае — Array(T). Any или Array(T) или Array(Nullable(T))

Примеры

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

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

2

Индексация с отрицательными индексами

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

3

Использование нотации [n]

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

2

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

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

0

Массив индексов

SELECT [10, 20, 30, 40][[2, 4, 1]]

[20,40,10]

Добавленный в: v1.1.0

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

Если n является массивом целых чисел, возвращает массив элементов в указанных позициях. Это эквивалентно arrayMap(i -> arrayElementOrNull(arr, i), n), но имеет отдельную, более эффективную реализацию. Позиции за пределами массива и индексы NULL дают значения NULL в результирующем массиве в соответствии с тем же правилом, что и для скалярного индекса.

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

Синтаксис

arrayElementOrNull(arr, n)

Аргументы

• arr — массив для поиска. Array(T). - n — позиция извлекаемого элемента или массив позиций. Позиции могут быть Nullable. (U)Int* или Array((U)Int*).

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

Если n — скаляр, возвращает Nullable(T), если T можно обернуть в Nullable, в противном случае — T. Если n — массив, возвращает Array(Nullable(T)), если T можно обернуть в Nullable, в противном случае — Array(T). Any или Nullable(T) или Array(T) или Array(Nullable(T))

Примеры

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

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

2

Индексация с отрицательными индексами

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

3

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

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

\N

Массив индексов

SELECT arrayElementOrNull([10, 20, 30], [1, 5, 2])

[10,NULL,20]

Добавленный в: v1.1.0

Возвращает массив [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 │
└────┴────────────────┴─────────────┴─────┘

Добавленный в: v18.12.0

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

Синтаксис

arrayEnumerateDense(arr)

Аргументы

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

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

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

Примеры

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

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

[1,2,1,3]

Добавленный в: v20.1.0

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

Синтаксис

arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)

Аргументы

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

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

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

Примеры

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

-- With clear_depth=1 and max_array_depth=1, the result is identical to what arrayEnumerateDense would give.

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

[1,2,1,3]

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

-- In this example, arrayEnumerateDenseRanked is used to obtain an array indicating, for each element of the
-- multidimensional array, what its position is among elements of the same value.
-- For the first row of the passed array, [10, 10, 30, 20], the corresponding first row of the result is [1, 1, 2, 3],
-- indicating that 10 is the first number encountered in position 1 and 2, 30 the second number encountered in position 3
-- and 20 is the third number encountered in position 4.
-- For the second row, [40, 50, 10, 30], the corresponding second row of the result is [4,5,1,2], indicating that 40
-- and 50 are the fourth and fifth numbers encountered in position 1 and 2 of that row, that another 10
-- (the first encountered number) is in position 3 and 30 (the second number encountered) is in the last position.

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

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

Пример с увеличенным значением clear_depth

-- Changing clear_depth=2 results in the enumeration occurring separately for each row anew.

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

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

Добавленный в: v1.1.0

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

Эта функция полезна при использовании 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

-- Each goal ID has a calculation of the number of conversions (each element in the Goals nested data structure is a goal that was reached, which we refer to as a conversion)
-- and the number of sessions. Without ARRAY JOIN, we would have counted the number of sessions as sum(Sign). But in this particular case,
-- the rows were multiplied by the nested Goals structure, so in order to count each session one time after this, we apply a condition to the
-- value of the arrayEnumerateUniq(Goals.ID) function.

CREATE TABLE visits (CounterID UInt32, Sign Int8, Goals Nested(ID UInt32)) ENGINE = Memory;

INSERT INTO visits VALUES
    (160656, 1, [53225, 53225, 56600]),
    (160656, 1, [53225, 2825062]),
    (160656, 1, [56600, 56600, 2825062]),
    (160657, 1, [53225]);

SELECT
    Goals.ID AS GoalID,
    sum(Sign) AS Reaches,
    sumIf(Sign, num = 1) AS Visits
FROM visits
ARRAY JOIN
    Goals,
    arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC, GoalID
LIMIT 10

┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │       3 │      2 │
│   56600 │       3 │      2 │
│ 2825062 │       2 │      2 │
└─────────┴─────────┴────────┘

Добавленный в: v20.1.0

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

Синтаксис

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

-- With clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniq would give for the same array.

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

[1,1,2]

Пример 2

-- with clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniqwould give for the same array.

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

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

Пример 3

-- In this example, arrayEnumerateUniqRanked is used to obtain an array indicating,
-- for each element of the multidimensional array, what its position is among elements
-- of the same value. For the first row of the passed array, [1, 2, 3], the corresponding
-- result is [1, 1, 1], indicating that this is the first time 1, 2 and 3 are encountered.
-- For the second row of the provided array, [2, 2, 1], the corresponding result is [2, 3, 3],
-- indicating that 2 is encountered for a second and third time, and 1 is encountered
-- for the second time. Likewise, for the third row of the provided array [3] the
-- corresponding result is [2] indicating that 3 is encountered for the second time.

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

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

Пример 4

-- Changing clear_depth=2, results in elements being enumerated separately for each row.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

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

Добавленный в: v25.9.0

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

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

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

1. Порядок элементов из source сохраняется
2. Дубликаты в source сохраняются, если их нет в except
3. 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'])

['apple','cherry']

Добавленный в: v1.1.0

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

Синтаксис

arrayExists(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)

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

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

Примеры

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

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

0

Добавленный в: v20.1.0

Функция 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]), которая применяется к элементам исходного массива (x) и массивов условий (y). Лямбда-функция
• source_arr — исходный массив для обработки. Лямбда-функция
• [, 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]

Добавленный в: v1.1.0

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

Синтаксис

arrayFilter(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)

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

Возвращает подмножество исходного массива 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]

Добавленный в: v1.1.0

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

Синтаксис

arrayFirst(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).

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

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

Примеры

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

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

b

Нет совпадений

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

0	UInt8

Добавленный в: v1.1.0

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

Синтаксис

arrayFirstIndex(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 возвращает true, в противном случае возвращает 0 UInt32

Примеры

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

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

2

Нет совпадений

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

0

Добавленный в: v1.1.0

Возвращает первый элемент исходного массива, для которого 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 возвращает true; в противном случае возвращает NULL.

Примеры

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

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

b

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

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

\N	Nullable(UInt8)

Добавленный в: v20.1.0

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

Функция:

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

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

Синтаксис

arrayFlatten(arr)

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

Аргументы

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

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

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

Примеры

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

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

[1,2,3]

Добавленный в: v23.10.0

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

Синтаксис

arrayFold(λ

Аргументы

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

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

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

Примеры

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

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

23

Последовательность Фибоначчи

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;

300

Добавленный в: v1.1.0

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

Синтаксис

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

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

Добавленный в: v23.7.0

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

Синтаксис

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

Добавленный в: v1.1.0

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

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

unnest (начиная с версии 26.5) — регистронезависимый псевдоним arrayJoin в форме вызова функции (SELECT unnest(arr)). Синтаксис PostgreSQL с источником-таблицей не поддерживается (FROM unnest(...), CROSS JOIN UNNEST(...) и LATERAL). Для таких запросов используйте предложение ARRAY JOIN.

arrayJoin, в том числе через его псевдоним unnest, нельзя использовать в условии JOIN ON, которое вычисляется во время выполнения JOIN, поскольку такое условие должно сохранять количество строк. Условие, применимое только к одной стороне, а также ключ равенства с arrayJoin извлекаются до JOIN и не затрагиваются. Условие ALL INNER JOIN без дизъюнкции также не затрагивается, поскольку в этом случае условие применяется уже после JOIN. Если разворачивание зависит только от одной стороны, перенесите его в ARRAY JOIN в подзапросе до JOIN; условие, аргумент arrayJoin которого обращается к столбцам с обеих сторон, необходимо реструктурировать.

Синтаксис

arrayJoin(arr)

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

Аргументы

• 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 влияет на все части запроса

-- The arrayJoin function affects all sections of the query, including the WHERE section. Notice the result 2, even though the subquery returned 1 row.

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

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

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

-- A query can use multiple arrayJoin functions. In this case, the transformation is performed multiple times and the rows are multiplied.

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
ORDER BY
    city,
    browser

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

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

-- Using multiple arrayJoin with the same expression may not produce the expected result due to optimizations.
-- For these cases, consider modifying the repeated array expression with extra operations that do not affect join result.
-- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- is technically correct, but will annihilate result set
    arrayJoin(arrayConcat(dice, [])) as second_throw -- intentionally changed expression to force re-evaluation
FROM (
    SELECT [1, 2, 3, 4, 5, 6] as dice
);

┌─first_throw─┬─second_throw─┐
│           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

-- Note the ARRAY JOIN syntax in the `SELECT` query below, which provides broader possibilities.
-- ARRAY JOIN allows you to convert multiple arrays with the same number of elements at a time.

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
ORDER BY
    2,
    3

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

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

-- You can also use 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
ORDER BY
    2,
    3

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

Добавленный в: v1.1.0

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

Синтаксис

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

Аргументы

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

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

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

Примеры

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

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

c

Нет совпадений

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

0	UInt8

Добавленный в: v1.1.0

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

Синтаксис

arrayLastIndex(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 возвращает true; в противном случае возвращает 0 UInt32

Примеры

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

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

3

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

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

0

Добавленный в: v1.1.0

Возвращает последний элемент исходного массива, для которого лямбда-функция 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'])

c

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

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

\N	Nullable(UInt8)

Добавленный в: v25.4.0

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

Синтаксис

arrayLevenshteinDistance(from, to)

Аргументы

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

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

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

Примеры

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

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

1

Добавленный в: v25.4.0

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

Синтаксис

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])

14

Добавленный в: v1.1.0

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

Синтаксис

arrayMap(func, arr)

Аргументы

• func — Лямбда-функция, которая применяется к элементам исходного массива (x) и массивов условий (y). Лямбда-функция
• 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)]

Добавленный в: v21.1.0

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

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

Синтаксис

arrayMax([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)

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

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

Примеры

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

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

7

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

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

12

Добавленный в: v21.1.0

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

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

Синтаксис

arrayMin([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)

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

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

Примеры

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

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

2

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

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

4

Добавленный в: v25.1.0

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

Синтаксис

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)

Добавленный в: v23.2.0

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

Синтаксис

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

Аргументы

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

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

Возвращает массив того же размера, что и исходный, в котором элементы в диапазоне [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]

Добавленный в: v23.2.0

Возвращает массив того же размера, что и исходный, где элементы в диапазоне [1..limit] представляют собой случайное подмножество исходного массива. Оставшаяся часть (limit..n] содержит элементы, не входящие в диапазон [1..limit], в неопределённом порядке. Значение 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])

[2,3,4,1]

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]

материализовать

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

┌─arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42)─┬─arrayPartialShuffle([1, 2, 3], 2, 42)─┐
│ [3,2,1,4]                                             │ [3,2,1]                               │
│ [3,2,1,4]                                             │ [3,1,2]                               │
│ [4,3,2,1]                                             │ [1,3,2]                               │
│ [1,4,3,2]                                             │ [2,1,3]                               │
│ [3,4,1,2]                                             │ [3,2,1]                               │
│ [1,2,3,4]                                             │ [3,2,1]                               │
│ [1,4,3,2]                                             │ [1,2,3]                               │
│ [1,4,3,2]                                             │ [3,2,1]                               │
│ [3,1,2,4]                                             │ [3,2,1]                               │
│ [1,3,2,4]                                             │ [2,1,3]                               │
└───────────────────────────────────────────────────────┴───────────────────────────────────────┘

Добавленный в: v23.2.0

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

Синтаксис

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

Аргументы

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

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

Возвращает массив того же размера, что и исходный, в котором элементы в диапазоне [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]

Добавленный в: v1.1.0

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

Синтаксис

arrayPopBack(arr)

Аргументы

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

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

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

Примеры

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

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

[1,2]

Добавленный в: v1.1.0

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

Синтаксис

arrayPopFront(arr)

Аргументы

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

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

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

Примеры

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

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

[2,3]

Добавленный в: v21.1.0

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

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

Синтаксис

arrayProduct([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)

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

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

Примеры

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

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

24

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

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

16

Добавленный в: v1.1.0

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

Синтаксис

arrayPushBack(arr, x)

Аргументы

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

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

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

Примеры

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

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

['a','b']

Добавленный в: v1.1.0

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

Синтаксис

arrayPushFront(arr, x)

Аргументы

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

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

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

Примеры

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

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

['a','b']

Добавленный в: v20.4.0

Вычисляет площадь под 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) x 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: Общее количество отрицательных примеров во всём наборе данных.

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

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

Примеры

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

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

0.75

Добавленный в: v23.10.0

Возвращает подмножество из 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]]

Добавленный в: v1.1.0

Применяет агрегатную функцию к элементам массива и возвращает результат. Имя агрегатной функции передаётся в виде строки в одинарных кавычках: '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 │
└─────────────────────────────────────────────────────────────┘

Добавленный в: v20.4.0

Применяет агрегатную функцию к элементам массива в заданных диапазонах и возвращает массив с результатом для каждого диапазона. Функция вернёт тот же результат, что и несколько вызовов 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] │
└─────────────────────────────┘

Добавленный в: v25.11.0

Удаляет из массива все элементы, равные указанному значению. NULL считается равным 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']

Добавлено в: v1.1.0

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

Синтаксис

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]

Добавленный в: v1.1.0

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

Синтаксис

arrayReverse(arr)

Аргументы

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

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

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

Примеры

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

SELECT arrayReverse([1, 2, 3])

[3,2,1]

Добавленный в: v20.1.0

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

Синтаксис

arrayReverseFill(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)

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

Возвращает массив, в котором элементы исходного массива заменены результатами лямбда-функции. 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]

Добавленный в: v1.1.0

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

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

1. -Inf
2. Inf
3. NaN
4. NULL

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

Синтаксис

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

Аргументы

• f(y1[, y2 ... yN]) — лямбда-функция, применяемая к элементам массива x. - arr — массив, который нужно отсортировать. Array(T) - arr1, ..., arrN — необязательно. 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]

Добавленный в: v20.1.0

Разбивает исходный массив на несколько массивов. Когда 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]]

Добавленный в: v23.8.0

Циклически сдвигает массив влево на указанное число элементов. Отрицательные значения 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]

Добавленный в: v23.8.0

Циклически сдвигает массив вправо на указанное число элементов. Отрицательные значения 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]

Добавленный в: v23.8.0

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

Синтаксис

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]

Добавленный в: v23.8.0

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

Синтаксис

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]

Добавленный в: v24.1.0

Генерирует массив шинглов (по аналогии с 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]]

Добавленный в: v23.2.0

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

Синтаксис

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]

Добавленный в: v25.4.0

Вычисляет степень сходства двух массивов в диапазоне от 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

Добавленный в: v1.1.0

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

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

Синтаксис

arraySlice(arr, offset [, length])

Аргументы

• arr — Массив, из которого берётся срез. Array(T) или QBit
• 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]

Добавленный в: v1.1.0

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

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

1. -Inf
2. Inf
3. NaN
4. NULL

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

Синтаксис

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

Аргументы

• f(y1[, y2 ... yN]) — лямбда-функция, применяемая к элементам массива x. - arr — массив, который необходимо отсортировать. Array(T) - arr1, ..., arrN — Необязательно. 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]

Добавленный в: v20.1.0

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

Синтаксис

arraySplit(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).

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

Возвращает массив массивов 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]]

Добавленный в: v21.1.0

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

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

Синтаксис

arraySum([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)

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

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

Примеры

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

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

10

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

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

8

Добавленный в: v25.4.0

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

Синтаксис

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

Добавленный в: v26.6.0

Возвращает массив из K наибольших элементов входного массива, отсортированных по убыванию. Если указана лямбда-функция f, элементы сравниваются по результату применения f к каждому элементу. Если f принимает несколько аргументов, в arrayTopK передаются дополнительные массивы; их элементы соответствуют аргументам f.

Значения NULL пропускаются и не включаются в результат. Размер результата не превышает K и может быть меньше, если входной массив содержит менее K значений, отличных от NULL. Тип элементов результата — соответствующий тип элементов входного массива без Nullable.

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

См. также arrayBottomK, которая возвращает K наименьших элементов.

Синтаксис

arrayTopK([f,] K, arr [, arr1, ... ,arrN])

Аргументы

• f(arr[, arr1, ... ,arrN]) — Необязательно. Лямбда-функция для вычисления ключа сортировки для каждого элемента. Лямбда-функция
• K — Количество наибольших элементов, которые нужно вернуть. (U)Int8/16/32/64
• arr — Массив. Array(T)
• arr1, ... ,arrN — N дополнительных массивов, если f принимает несколько аргументов. Array(T)

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

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

Примеры

simple_int

SELECT arrayTopK(3, [1, 5, 2, 7, 3])

[7,5,3]

skip_nulls

SELECT arrayTopK(3, [1, NULL, 5, 2, NULL, 7])

[7,5,2]

fewer_than_k

SELECT arrayTopK(5, [1, NULL, 2])

[2,1]

lambda_simple

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

[1,3]

lambda_multi

SELECT arrayTopK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

['a','c']

Добавленный в: v26.4.0

Транспонирует двумерный массив.

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

Синтаксис

arrayTranspose(arr)

Аргументы

• arr — двумерный массив для транспонирования. Все внутренние массивы должны иметь одинаковую длину. Array(Array(T))

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

Транспонированный двумерный массив, в котором элемент [i][j] результата равен элементу [j][i] исходного массива. Array(Array(T))

Примеры

Квадратная матрица

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

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

Неквадратная матрица

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

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

Строковые элементы

SELECT arrayTranspose([['a', 'b'], ['c', 'd']])

[['a','c'],['b','d']]

Добавленный в: v24.10.0

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

Синтаксис

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

Добавленный в: v1.1.0

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

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

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

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

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

Синтаксис

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

Аргументы

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

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

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

Примеры

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

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

2

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

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

3

Добавленный в: v20.1.0

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

Синтаксис

arrayWithConstant(N, x)

Аргументы

• length — Количество элементов в массиве. (U)Int*
• x — Значение для N элементов массива, любого типа.

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

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

Примеры

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

SELECT arrayWithConstant(3, 1)

[1,1,1]

Добавленный в: v20.1.0

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

Синтаксис

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)]

Добавленный в: v20.1.0

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

Синтаксис

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)]

Добавлено в: v1.1.0

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

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

Синтаксис

countEqual(arr, x)

Аргументы

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

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

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

Примеры

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

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

2

Добавленный в: v1.1.0

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

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

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

Синтаксис

empty(arr)

Аргументы

• arr — Входной массив. Array(T)

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

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

Примеры

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

SELECT empty([]);

1

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayDate()

Аргументы

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

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

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

Примеры

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

SELECT emptyArrayDate()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayDateTime()

Аргументы

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

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

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

Примеры

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

SELECT emptyArrayDateTime()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayFloat32()

Аргументы

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

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

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

Примеры

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

SELECT emptyArrayFloat32()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayFloat64()

Аргументы

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

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

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

Примеры

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

SELECT emptyArrayFloat64()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayInt16()

Аргументы

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

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

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

Примеры

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

SELECT emptyArrayInt16()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayInt32()

Аргументы

• Нет аргументов.

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

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

Примеры

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

SELECT emptyArrayInt32()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayInt64()

Аргументы

• Нет.

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

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

Примеры

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

SELECT emptyArrayInt64()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayInt8()

Аргументы

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

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

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

Примеры

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

SELECT emptyArrayInt8()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayString()

Аргументы

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

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

Пустой массив строк. Array(T)

Примеры

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

SELECT emptyArrayString()

[]

Добавленный в: v1.1.0

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

Синтаксис

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 00:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘

Добавлено в: v1.1.0

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

Синтаксис

emptyArrayUInt16()

Аргументы

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

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

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

Примеры

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

SELECT emptyArrayUInt16()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayUInt32()

Аргументы

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

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

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

Примеры

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

SELECT emptyArrayUInt32()

[]

Добавленный в: v1.1.0

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

Синтаксис

emptyArrayUInt64()

Аргументы

• Нет.

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

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

Примеры

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

SELECT emptyArrayUInt64()

[]

Добавлено в: v1.1.0

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

Синтаксис

emptyArrayUInt8()

Аргументы

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

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

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

Примеры

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

SELECT emptyArrayUInt8()

[]