Функции массивов

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)

Received exception from server (version 25.4.3):
Code: 386. DB::Exception: Received from localhost:9000. DB::Exception:
There is no supertype for types Int32, DateTime, Int8 ...

arrayAUCPR

Представлено в: v20.4

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

Синтаксис

arrayAUCPR(scores, labels[, partial_offsets])

Аргументы

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). Lambda function
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

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

примечание

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

Синтаксис

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)

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

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

примечание

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

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

Примеры

Пример массива

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

32    UInt16

Пример кортежа

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. В этом случае будет ошибка Индексы массива начинаются с 1.

примечание

Массивы в 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 индексируются с единицы.

Синтаксис

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

Примеры

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

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

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

-- 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.

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

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

[1, 1, 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]]

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]

с_nulls1

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

[1, NULL, NULL]

с_nulls2

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

[1]

строки

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

['apple', 'cherry']

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 последовательно обрабатывает исходный массив с первого элемента до последнего, оценивая условие лямбды на каждой позиции с использованием элементов из исходного и условных массивов. Когда лямбда-функция оценивается как ложная на позиции 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). Лямбда-функция.
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]) — Лямбда-функция, которая работает с элементами исходного массива (x) и массивами условий (y). Лямбда-функция.
source_arr — Исходный массив для обработки. Array(T).
[, cond1_arr, ... , condN_arr] — Необязательные. N массивов условий, предоставляющих дополнительные аргументы для лямбда-функции. Array(T).

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

Возвращает индекс первого элемента исходного массива, для которого func истинен, в противном случае возвращает 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). Lambda function
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)

Аргументы

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

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

┌─impressions─┬─city─────┬─browser─┐
│           2 │ Istanbul │ Chrome  │
│           1 │ Istanbul │ Firefox │
│           2 │ Berlin   │ Chrome  │
│           1 │ Berlin   │ Firefox │
│           2 │ Bobruisk │ Chrome  │
│           1 │ Bobruisk │ 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

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

Использование 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

┌─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). Лямбда-функция.
source — Исходный массив для обработки. Array(T).
[, cond1, ... , condN] — Необязательно. N условных массивов, предоставляющих дополнительные аргументы для лямбда-функции. Array(T).

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

Возвращает последний элемент исходного массива, для которого func истинно, в противном случае возвращает значение по умолчанию для 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). Лямбда-функция
source_arr — Исходный массив для обработки. Array(T)
[, cond1_arr, ... , condN_arr] — Необязательно. N условных массивов, предоставляющих дополнительные аргументы для лямбда-функции. Array(T)

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

Возвращает индекс последнего элемента исходного массива, для которого func истинно, в противном случае возвращает 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). Лямбда-функция.
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). Лямбда-функция.
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). Лямбда-функция.
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]) — Лямбда-функция, которую нужно применить к элементам массива x. Лямбда-функция.
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], в неопределенном порядке. Значение ограничения должно находиться в диапазоне [1..n]. Значения за пределами этого диапазона эквивалентны выполнению полной arrayShuffle:

примечание

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

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

Синтаксис

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

Аргументы

arr — Массив для перетасовки. Array(T).
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. Лямбда-функция.
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, но без последнего элемента arr Array(T).

Примеры

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

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

[1, 2]

arrayPopFront

Введено в: v1.1

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

Синтаксис

arrayPopFront(arr)

Аргументы

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

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

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

Примеры

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

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). Лямбда-функция.
source_arr — Исходный массив для обработки. Array(T).
[, cond1_arr, ... , condN_arr] — Необязательно. N условных массивов, предоставляющих дополнительные аргументы для лямбда-функции. Array(T).

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

Возвращает произведение элементов в исходном массиве, или произведение элементов результатов лямбды, если предоставлено. Float64.

Примеры

Основной пример

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

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

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 смотрите Типы данных.

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

Возвращает массив, идентичный 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). ROC-кривая создаётся путём построения доли истинных положительных (TPR) на оси y и доли ложных положительных (FPR) на оси x по всем порогам. Полученное значение варьируется от нуля до единицы, при этом более высокое значение указывает на лучшую производительность модели.

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

Синтаксис

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

Аргументы

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

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

--If an aggregate function takes multiple arguments, then this function must be applied to multiple arrays of the same size.

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

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). Лямбда-функция.
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 передаётся несколько массивов, которые будут соответствовать аргументам func.

Если массив для сортировки содержит -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

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

Синтаксис

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) — Опционально. Начальное значение для генерации случайных чисел. Если не указано, используется случайное. (U)Int*

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

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

Примеры

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

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

[1,4,2,3]

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

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).Лямбда-функция.
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). Лямбда-функция
source_arr — Исходный массив для обработки. Array(T)
, cond1_arr, ... , condN_arr] — Опционально. N массивов условий, предоставляющих дополнительные аргументы для лямбда-функции. Array(T)

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

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

Примеры

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

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

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

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)

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

Примеры

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

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;.

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

Синтаксис

empty(arr)

Аргументы

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

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

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

Примеры

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

SELECT empty([]);

emptyArrayDate

Представлено в: v1.1

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

Синтаксис

emptyArrayDate()

Аргументы

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

Пустой массив дат. 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

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

Синтаксис

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

Массивы, содержащие строковые значения

SELECT hasAll(['a', 'b'], ['a'])

Массивы без общего типа

SELECT hasAll([1], ['a'])

Raises a NO_COMMON_TYPE exception

Массив массивов

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

Raises a `NO_COMMON_TYPE` exception

Массив массивов

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

hasSubstr

Представлено в: v20.6

Проверяет, появляются ли все элементы массива2 в массиве1 в том же точном порядке. Таким образом, функция вернет 1, если и только если массив1 = префикс + массив2 + суффикс.

Иными словами, функции проверят, содержатся ли все элементы массива2 в массиве1, как функция hasAll. В дополнение к этому проверяется, что элементы наблюдаются в том же порядке в обоих массиве1 и массиве2.

Функция вернет 1, если массив2 пустой.
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'])

Raises a `NO_COMMON_TYPE` exception

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

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

Примеры

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

SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)

length

Представлено в: v1.1

Вычисляет длину строки или массива.

Для строковых или фиксированных строковых аргументов: вычисляет количество байтов в строке.
Для аргументов массива: вычисляет количество элементов в массиве.
Если применяется к аргументу фиксированной строки, функция является константным выражением.

Обратите внимание, что количество байтов в строке не равно количеству Unicode "кодовых точек" и не равно количеству Unicode "графемных кластеров" (то, что мы обычно называем "символами") и не равно видимой ширине строки.

Разрешено наличие ASCII NULL байтов в строках, и они также будут учитываться.

Синтаксис

length(x)

Аргументы

x — Значение, для которого нужно вычислить количество байтов (для String/FixedString) или элементов (для Array). String или FixedString или Array(T)

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

Возвращает количество байтов в строке/фиксированной строке x / количество элементов в массиве x UInt64

Примеры

Пример строки

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.

Функция также работает для строк или 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'

Distance functions

Все поддерживаемые функции описаны в документации по функциям расстояния.

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​

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​

emptyArrayFloat64​

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

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

emptyArrayFloat64