ClickHouse/docs/ru/sql-reference/functions/array-functions.md
2024-02-13 02:10:41 +01:00

2030 lines
75 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

---
slug: /ru/sql-reference/functions/array-functions
sidebar_position: 35
sidebar_label: "Массивы"
---
# Массивы {#functions-for-working-with-arrays}
## empty {#function-empty}
Проверяет, является ли входной массив пустым.
**Синтаксис**
``` sql
empty([x])
```
Массив считается пустым, если он не содержит ни одного элемента.
:::note Примечание
Функцию можно оптимизировать, если включить настройку [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns). При `optimize_functions_to_subcolumns = 1` функция читает только подстолбец [size0](../../sql-reference/data-types/array.md#array-size) вместо чтения и обработки всего столбца массива. Запрос `SELECT empty(arr) FROM TABLE` преобразуется к запросу `SELECT arr.size0 = 0 FROM TABLE`.
:::
Функция также поддерживает работу с типами [String](string-functions.md#empty) и [UUID](uuid-functions.md#empty).
**Параметры**
- `[x]` — массив на входе функции. [Array](../data-types/array.md).
**Возвращаемое значение**
- Возвращает `1` для пустого массива или `0` — для непустого массива.
Тип: [UInt8](../data-types/int-uint.md).
**Пример**
Запрос:
```sql
SELECT empty([]);
```
Ответ:
```text
┌─empty(array())─┐
│ 1 │
└────────────────┘
```
## notEmpty {#function-notempty}
Проверяет, является ли входной массив непустым.
**Синтаксис**
``` sql
notEmpty([x])
```
Массив считается непустым, если он содержит хотя бы один элемент.
:::note Примечание
Функцию можно оптимизировать, если включить настройку [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns). При `optimize_functions_to_subcolumns = 1` функция читает только подстолбец [size0](../../sql-reference/data-types/array.md#array-size) вместо чтения и обработки всего столбца массива. Запрос `SELECT notEmpty(arr) FROM table` преобразуется к запросу `SELECT arr.size0 != 0 FROM TABLE`.
:::
Функция также поддерживает работу с типами [String](string-functions.md#notempty) и [UUID](uuid-functions.md#notempty).
**Параметры**
- `[x]` — массив на входе функции. [Array](../data-types/array.md).
**Возвращаемое значение**
- Возвращает `1` для непустого массива или `0` — для пустого массива.
Тип: [UInt8](../data-types/int-uint.md).
**Пример**
Запрос:
```sql
SELECT notEmpty([1,2]);
```
Результат:
```text
┌─notEmpty([1, 2])─┐
│ 1 │
└──────────────────┘
```
## length {#array_functions-length}
Возвращает количество элементов в массиве.
Тип результата - UInt64.
Функция также работает для строк.
Функцию можно оптимизировать, если включить настройку [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns). При `optimize_functions_to_subcolumns = 1` функция читает только подстолбец [size0](../../sql-reference/data-types/array.md#array-size) вместо чтения и обработки всего столбца массива. Запрос `SELECT length(arr) FROM table` преобразуется к запросу `SELECT arr.size0 FROM TABLE`.
## emptyArrayUInt8, emptyArrayUInt16, emptyArrayUInt32, emptyArrayUInt64 {#emptyarrayuint8-emptyarrayuint16-emptyarrayuint32-emptyarrayuint64}
## emptyArrayInt8, emptyArrayInt16, emptyArrayInt32, emptyArrayInt64 {#emptyarrayint8-emptyarrayint16-emptyarrayint32-emptyarrayint64}
## emptyArrayFloat32, emptyArrayFloat64 {#emptyarrayfloat32-emptyarrayfloat64}
## emptyArrayDate, emptyArrayDateTime {#emptyarraydate-emptyarraydatetime}
## emptyArrayString {#emptyarraystring}
Принимает ноль аргументов и возвращает пустой массив соответствующего типа.
## emptyArrayToSingle {#emptyarraytosingle}
Принимает пустой массив и возвращает массив из одного элемента, равного значению по умолчанию.
## range(end), range(\[start, \] end \[, step\]) {#range}
Возвращает массив чисел от `start` до `end - 1` с шагом `step`.
**Синтаксис**
``` sql
range([start, ] end [, step])
```
**Аргументы**
- `start` — начало диапазона. Обязательно, когда указан `step`. По умолчанию равно `0`. Тип: [UInt](../data-types/int-uint.md)
- `end` — конец диапазона. Обязательный аргумент. Должен быть больше, чем `start`. Тип: [UInt](../data-types/int-uint.md)
- `step` — шаг обхода. Необязательный аргумент. По умолчанию равен `1`. Тип: [UInt](../data-types/int-uint.md)
**Возвращаемые значения**
- массив `UInt` чисел от `start` до `end - 1` с шагом `step`
**Особенности реализации**
- Не поддерживаются отрицательные значения аргументов: `start`, `end`, `step` имеют тип `UInt`.
- Если в результате запроса создаются массивы суммарной длиной больше, чем количество элементов, указанное настройкой [function_range_max_elements_in_block](../../operations/settings/settings.md#settings-function_range_max_elements_in_block), то генерируется исключение.
- Возвращает Null если любой аргумент Nullable(Nothing) типа. Генерируется исключение если любой аргумент Null (Nullable(T) тип).
**Примеры**
Запрос:
``` sql
SELECT range(5), range(1, 5), range(1, 5, 2);
```
Ответ:
```txt
┌─range(5)────┬─range(1, 5)─┬─range(1, 5, 2)─┐
│ [0,1,2,3,4] │ [1,2,3,4] │ [1,3] │
└─────────────┴─────────────┴────────────────┘
```
## array(x1, …), оператор \[x1, …\] {#arrayx1-operator-x1}
Создаёт массив из аргументов функции.
Аргументы должны быть константами и иметь типы, для которых есть наименьший общий тип. Должен быть передан хотя бы один аргумент, так как иначе непонятно, какого типа создавать массив. То есть, с помощью этой функции невозможно создать пустой массив (для этого используйте функции emptyArray\*, описанные выше).
Возвращает результат типа Array(T), где T - наименьший общий тип от переданных аргументов.
## arrayConcat {#arrayconcat}
Объединяет массивы, переданные в качестве аргументов.
``` sql
arrayConcat(arrays)
```
**Аргументы**
- `arrays` произвольное количество элементов типа [Array](../../sql-reference/functions/array-functions.md)
**Пример**
<!-- -->
``` sql
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
```
``` text
┌─res───────────┐
│ [1,2,3,4,5,6] │
└───────────────┘
```
## arrayElement(arr, n), operator arr\[n\] {#arrayelementarr-n-operator-arrn}
Достаёт элемент с индексом n из массива arr. n должен быть любым целочисленным типом.
Индексы в массиве начинаются с единицы.
Поддерживаются отрицательные индексы. В этом случае, будет выбран соответствующий по номеру элемент с конца. Например, arr\[-1\] - последний элемент массива.
Если индекс выходит за границы массива, то возвращается некоторое значение по умолчанию (0 для чисел, пустая строка для строк и т. п.), кроме случая с неконстантным массивом и константным индексом 0 (в этом случае будет ошибка `Array indices are 1-based`).
## has(arr, elem) {#hasarr-elem}
Проверяет наличие элемента elem в массиве arr.
Возвращает 0, если элемента в массиве нет, или 1, если есть.
`NULL` обрабатывается как значение.
``` sql
SELECT has([1, 2, NULL], NULL)
```
``` text
┌─has([1, 2, NULL], NULL)─┐
│ 1 │
└─────────────────────────┘
```
## hasAll {#hasall}
Проверяет, является ли один массив подмножеством другого.
``` sql
hasAll(set, subset)
```
**Аргументы**
- `set` массив любого типа с набором элементов.
- `subset` массив любого типа со значениями, которые проверяются на вхождение в `set`.
**Возвращаемые значения**
- `1`, если `set` содержит все элементы из `subset`.
- `0`, в противном случае.
**Особенности**
- Пустой массив является подмножеством любого массива.
- `NULL` обрабатывается как значение.
- Порядок значений в обоих массивах не имеет значения.
**Примеры**
`SELECT hasAll([], [])` возвращает 1.
`SELECT hasAll([1, Null], [Null])` возвращает 1.
`SELECT hasAll([1.0, 2, 3, 4], [1, 3])` возвращает 1.
`SELECT hasAll(['a', 'b'], ['a'])` возвращает 1.
`SELECT hasAll([1], ['a'])` возвращает 0.
`SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])` возвращает 0.
## hasAny {#hasany}
Проверяет, имеют ли два массива хотя бы один общий элемент.
``` sql
hasAny(array1, array2)
```
**Аргументы**
- `array1` массив любого типа с набором элементов.
- `array2` массив любого типа с набором элементов.
**Возвращаемые значения**
- `1`, если `array1` и `array2` имеют хотя бы один одинаковый элемент.
- `0`, в противном случае.
**Особенности**
- `NULL` обрабатывается как значение.
- Порядок значений в обоих массивах не имеет значения.
**Примеры**
`SELECT hasAny([1], [])` возвращает `0`.
`SELECT hasAny([Null], [Null, 1])` возвращает `1`.
`SELECT hasAny([-128, 1., 512], [1])` возвращает `1`.
`SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])` возвращает `0`.
`SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])` возвращает `1`.
## indexOf(arr, x) {#indexofarr-x}
Возвращает индекс первого элемента x (начиная с 1), если он есть в массиве, или 0, если его нет.
Пример:
``` sql
SELECT indexOf([1, 3, NULL, NULL], NULL)
```
``` text
┌─indexOf([1, 3, NULL, NULL], NULL)─┐
│ 3 │
└───────────────────────────────────┘
```
Элементы, равные `NULL`, обрабатываются как обычные значения.
## arrayCount(\[func,\] arr1, …) {#array-count}
Возвращает количество элементов массива `arr`, для которых функция `func` возвращает не 0. Если `func` не указана - возвращает количество ненулевых элементов массива.
Функция `arrayCount` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
## countEqual(arr, x) {#countequalarr-x}
Возвращает количество элементов массива, равных x. Эквивалентно arrayCount(elem -\> elem = x, arr).
`NULL` обрабатывается как значение.
Пример:
``` sql
SELECT countEqual([1, 2, NULL, NULL], NULL)
```
``` text
┌─countEqual([1, 2, NULL, NULL], NULL)─┐
│ 2 │
└──────────────────────────────────────┘
```
## arrayEnumerate(arr) {#array_functions-arrayenumerate}
Возвращает массив \[1, 2, 3, …, length(arr)\]
Эта функция обычно используется совместно с ARRAY JOIN. Она позволяет, после применения ARRAY JOIN, посчитать что-либо только один раз для каждого массива. Пример:
``` sql
SELECT
count() AS Reaches,
countIf(num = 1) AS Hits
FROM test.hits
ARRAY JOIN
GoalsReached,
arrayEnumerate(GoalsReached) AS num
WHERE CounterID = 160656
LIMIT 10
```
``` text
┌─Reaches─┬──Hits─┐
│ 95606 │ 31406 │
└─────────┴───────┘
```
В этом примере, Reaches - число достижений целей (строк, получившихся после применения ARRAY JOIN), а Hits - число хитов (строк, которые были до ARRAY JOIN). В данном случае, тот же результат можно получить проще:
``` sql
SELECT
sum(length(GoalsReached)) AS Reaches,
count() AS Hits
FROM test.hits
WHERE (CounterID = 160656) AND notEmpty(GoalsReached)
```
``` text
┌─Reaches─┬──Hits─┐
│ 95606 │ 31406 │
└─────────┴───────┘
```
Также эта функция может быть использована в функциях высшего порядка. Например, с её помощью можно достать индексы массива для элементов, удовлетворяющих некоторому условию.
## arrayEnumerateUniq(arr, …) {#arrayenumerateuniqarr}
Возвращает массив, такого же размера, как исходный, где для каждого элемента указано, какой он по счету среди элементов с таким же значением.
Например: arrayEnumerateUniq(\[10, 20, 10, 30\]) = \[1, 1, 2, 1\].
Эта функция полезна при использовании ARRAY JOIN и агрегации по элементам массива.
Пример:
``` sql
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
```
``` text
┌──GoalID─┬─Reaches─┬─Visits─┐
│ 53225 │ 3214 │ 1097 │
│ 2825062 │ 3188 │ 1097 │
│ 56600 │ 2803 │ 488 │
│ 1989037 │ 2401 │ 365 │
│ 2830064 │ 2396 │ 910 │
│ 1113562 │ 2372 │ 373 │
│ 3270895 │ 2262 │ 812 │
│ 1084657 │ 2262 │ 345 │
│ 56599 │ 2260 │ 799 │
│ 3271094 │ 2256 │ 812 │
└─────────┴─────────┴────────┘
```
В этом примере, для каждого идентификатора цели, посчитано количество достижений целей (каждый элемент вложенной структуры данных Goals является достижением целей) и количество визитов. Если бы не было ARRAY JOIN, мы бы считали количество визитов как sum(Sign). Но в данном случае, строчки были размножены по вложенной структуре Goals, и чтобы после этого учесть каждый визит один раз, мы поставили условие на значение функции arrayEnumerateUniq(Goals.ID).
Функция arrayEnumerateUniq может принимать несколько аргументов - массивов одинаковых размеров. В этом случае, уникальность считается для кортежей элементов на одинаковых позициях всех массивов.
``` sql
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]) AS res
```
``` text
┌─res───────────┐
│ [1,2,1,1,2,1] │
└───────────────┘
```
Это нужно при использовании ARRAY JOIN с вложенной структурой данных и затем агрегации по нескольким элементам этой структуры.
## arrayPopBack {#arraypopback}
Удаляет последний элемент из массива.
``` sql
arrayPopBack(array)
```
**Аргументы**
- `array` массив.
**Пример**
``` sql
SELECT arrayPopBack([1, 2, 3]) AS res;
```
``` text
┌─res───┐
│ [1,2] │
└───────┘
```
## arrayPopFront {#arraypopfront}
Удаляет первый элемент из массива.
``` sql
arrayPopFront(array)
```
**Аргументы**
- `array` массив.
**Пример**
``` sql
SELECT arrayPopFront([1, 2, 3]) AS res;
```
``` text
┌─res───┐
│ [2,3] │
└───────┘
```
## arrayPushBack {#arraypushback}
Добавляет один элемент в конец массива.
``` sql
arrayPushBack(array, single_value)
```
**Аргументы**
- `array` массив.
- `single_value` значение добавляемого элемента. В массив с числами можно добавить только числа, в массив со строками только строки. При добавлении чисел ClickHouse автоматически приводит тип `single_value` к типу данных массива. Подробнее о типах данных в ClickHouse читайте в разделе «[Типы данных](../../sql-reference/functions/array-functions.md#data_types)». Может быть равно `NULL`, в этом случае функция добавит элемент `NULL` в массив, а тип элементов массива преобразует в `Nullable`.
**Пример**
``` sql
SELECT arrayPushBack(['a'], 'b') AS res;
```
``` text
┌─res───────┐
│ ['a','b'] │
└───────────┘
```
## arrayPushFront {#arraypushfront}
Добавляет один элемент в начало массива.
``` sql
arrayPushFront(array, single_value)
```
**Аргументы**
- `array` массив.
- `single_value` значение добавляемого элемента. В массив с числами можно добавить только числа, в массив со строками только строки. При добавлении чисел ClickHouse автоматически приводит тип `single_value` к типу данных массива. Подробнее о типах данных в ClickHouse читайте в разделе «[Типы данных](../../sql-reference/functions/array-functions.md#data_types)». Может быть равно `NULL`, в этом случае функция добавит элемент `NULL` в массив, а тип элементов массива преобразует в `Nullable`.
**Пример**
``` sql
SELECT arrayPushFront(['b'], 'a') AS res;
```
``` text
┌─res───────┐
│ ['a','b'] │
└───────────┘
```
## arrayResize {#arrayresize}
Изменяет длину массива.
``` sql
arrayResize(array, size[, extender])
```
**Аргументы**
- `array` — массив.
- `size` — необходимая длина массива.
- Если `size` меньше изначального размера массива, то массив обрезается справа.
- Если `size` больше изначального размера массива, массив дополняется справа значениями `extender` или значениями по умолчанию для типа данных элементов массива.
- `extender` — значение для дополнения массива. Может быть `NULL`.
**Возвращаемое значение:**
Массив длины `size`.
**Примеры вызовов**
``` sql
SELECT arrayResize([1], 3);
```
``` text
┌─arrayResize([1], 3)─┐
│ [1,0,0] │
└─────────────────────┘
```
``` sql
SELECT arrayResize([1], 3, NULL);
```
``` text
┌─arrayResize([1], 3, NULL)─┐
│ [1,NULL,NULL] │
└───────────────────────────┘
```
## arraySlice {#arrayslice}
Возвращает срез массива.
``` sql
arraySlice(array, offset[, length])
```
**Аргументы**
- `array` массив данных.
- `offset` отступ от края массива. Положительное значение - отступ слева, отрицательное значение - отступ справа. Отсчёт элементов массива начинается с 1.
- `length` длина необходимого среза. Если указать отрицательное значение, то функция вернёт открытый срез `[offset, array_length - length]`. Если не указать значение, то функция вернёт срез `[offset, the_end_of_array]`.
**Пример**
``` sql
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
```
``` text
┌─res────────┐
│ [2,NULL,4] │
└────────────┘
```
Элементы массива равные `NULL` обрабатываются как обычные значения.
## arraySort(\[func,\] arr, …) {#array_functions-sort}
Возвращает массив `arr`, отсортированный в восходящем порядке. Если задана функция `func`, то порядок сортировки определяется результатом применения этой функции на элементы массива `arr`. Если `func` принимает несколько аргументов, то в функцию `arraySort` нужно передавать несколько массивов, которые будут соответствовать аргументам функции `func`. Подробные примеры рассмотрены в конце описания `arraySort`.
Пример сортировки целочисленных значений:
``` sql
SELECT arraySort([1, 3, 3, 0])
```
``` text
┌─arraySort([1, 3, 3, 0])─┐
│ [0,1,3,3] │
└─────────────────────────┘
```
Пример сортировки строковых значений:
``` sql
SELECT arraySort(['hello', 'world', '!'])
```
``` text
┌─arraySort(['hello', 'world', '!'])─┐
│ ['!','hello','world'] │
└────────────────────────────────────┘
```
Значения `NULL`, `NaN` и `Inf` сортируются по следующему принципу:
``` sql
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
```
``` text
┌─arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf])─┐
│ [-inf,-4,1,2,3,inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────────────────────────┘
```
- Значения `-Inf` идут в начале массива.
- Значения `NULL` идут в конце массива.
- Значения `NaN` идут перед `NULL`.
- Значения `Inf` идут перед `NaN`.
Функция `arraySort` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию. В этом случае порядок сортировки определяется результатом применения лямбда-функции на элементы массива.
Рассмотрим пример:
``` sql
SELECT arraySort((x) -> -x, [1, 2, 3]) as res;
```
``` text
┌─res─────┐
│ [3,2,1] │
└─────────┘
```
Для каждого элемента исходного массива лямбда-функция возвращает ключ сортировки, то есть \[1 \> -1, 2 \> -2, 3 \> -3\]. Так как `arraySort` сортирует элементы в порядке возрастания ключей, результат будет \[3, 2, 1\]. Как можно заметить, функция `x > -x` устанавливает [обратный порядок сортировки](#array_functions-reverse-sort).
Лямбда-функция может принимать несколько аргументов. В этом случае, в функцию `arraySort` нужно передавать несколько массивов, которые будут соответствовать аргументам лямбда-функции (массивы должны быть одинаковой длины). Следует иметь в виду, что результат будет содержать элементы только из первого массива; элементы из всех последующих массивов будут задавать ключи сортировки. Например:
``` sql
SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
```
``` text
┌─res────────────────┐
│ ['world', 'hello'] │
└────────────────────┘
```
Элементы, указанные во втором массиве (\[2,1\]), определяют ключ сортировки для элементов из исходного массива (\[hello, world\]), то есть \[hello \> 2, world \> 1\]. Так как лямбда-функция не использует `x`, элементы исходного массива не влияют на порядок сортировки. Таким образом, hello будет вторым элементом в отсортированном массиве, а world — первым.
Ниже приведены другие примеры.
``` sql
SELECT arraySort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
```
``` text
┌─res─────┐
│ [2,1,0] │
└─────────┘
```
``` sql
SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res;
```
``` text
┌─res─────┐
│ [2,1,0] │
└─────────┘
```
:::note Примечание
Для улучшения эффективности сортировки применяется [преобразование Шварца](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A8%D0%B2%D0%B0%D1%80%D1%86%D0%B0).
:::
## arrayPartialSort(\[func,\] limit, arr, …) {#array_functions-sort}
То же, что и `arraySort` с дополнительным аргументом `limit`, позволяющим частичную сортировку. Возвращает массив того же размера, как и исходный, в котором элементы `[1..limit]` отсортированы в возрастающем порядке. Остальные элементы `(limit..N]` остаются в неспецифицированном порядке.
## arrayReverseSort(\[func,\] arr, …) {#array_functions-reverse-sort}
Возвращает массив `arr`, отсортированный в нисходящем порядке. Если указана функция `func`, то массив `arr` сначала сортируется в порядке, который определяется функцией `func`, а затем отсортированный массив переворачивается. Если функция `func` принимает несколько аргументов, то в функцию `arrayReverseSort` необходимо передавать несколько массивов, которые будут соответствовать аргументам функции `func`. Подробные примеры рассмотрены в конце описания функции `arrayReverseSort`.
Пример сортировки целочисленных значений:
``` sql
SELECT arrayReverseSort([1, 3, 3, 0]);
```
``` text
┌─arrayReverseSort([1, 3, 3, 0])─┐
│ [3,3,1,0] │
└────────────────────────────────┘
```
Пример сортировки строковых значений:
``` sql
SELECT arrayReverseSort(['hello', 'world', '!']);
```
``` text
┌─arrayReverseSort(['hello', 'world', '!'])─┐
│ ['world','hello','!'] │
└───────────────────────────────────────────┘
```
Значения `NULL`, `NaN` и `Inf` сортируются в следующем порядке:
``` sql
SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
```
``` text
┌─res───────────────────────────────────┐
│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────┘
```
- Значения `Inf` идут в начале массива.
- Значения `NULL` идут в конце массива.
- Значения `NaN` идут перед `NULL`.
- Значения `-Inf` идут перед `NaN`.
Функция `arrayReverseSort` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию. Например:
``` sql
SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
```
``` text
┌─res─────┐
│ [1,2,3] │
└─────────┘
```
В этом примере, порядок сортировки устанавливается следующим образом:
1. Сначала исходный массив (\[1, 2, 3\]) сортируется в том порядке, который определяется лямбда-функцией. Результатом будет массив \[3, 2, 1\].
2. Массив, который был получен на предыдущем шаге, переворачивается. То есть, получается массив \[1, 2, 3\].
Лямбда-функция может принимать на вход несколько аргументов. В этом случае, в функцию `arrayReverseSort` нужно передавать несколько массивов, которые будут соответствовать аргументам лямбда-функции (массивы должны быть одинаковой длины). Следует иметь в виду, что результат будет содержать элементы только из первого массива; элементы из всех последующих массивов будут определять ключи сортировки. Например:
``` sql
SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
```
``` text
┌─res───────────────┐
│ ['hello','world'] │
└───────────────────┘
```
В этом примере, массив сортируется следующим образом:
1. Сначала массив сортируется в том порядке, который определяется лямбда-функцией. Элементы, указанные во втором массиве (\[2,1\]), определяют ключи сортировки соответствующих элементов из исходного массива (\[hello, world\]). То есть, будет массив \[world, hello\].
2. Массив, который был отсортирован на предыдущем шаге, переворачивается. Получается массив \[hello, world\].
Ниже приведены ещё примеры.
``` sql
SELECT arrayReverseSort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
```
``` text
┌─res─────┐
│ [0,1,2] │
└─────────┘
```
``` sql
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
```
``` text
┌─res─────┐
│ [4,3,5] │
└─────────┘
```
## arrayPartialReverseSort(\[func,\] limit, arr, …) {#array_functions-sort}
То же, что и `arrayReverseSort` с дополнительным аргументом `limit`, позволяющим частичную сортировку. Возвращает массив того же размера, как и исходный, в котором элементы `[1..limit]` отсортированы в убывающем порядке. Остальные элементы `(limit..N]` остаются в неспецифицированном порядке.
## arrayUniq(arr, …) {#array-functions-arrayuniq}
Если передан один аргумент, считает количество разных элементов в массиве.
Если передано несколько аргументов, считает количество разных кортежей из элементов на соответствующих позициях в нескольких массивах.
Если необходимо получить список уникальных элементов массива, можно воспользоваться arrayReduce(groupUniqArray, arr).
## arrayJoin(arr) {#array-functions-arrayjoin}
Особенная функция. Смотрите раздел [«Функция arrayJoin»](array-join.md#functions_arrayjoin).
## arrayDifference {#arraydifference}
Вычисляет разность между соседними элементами массива. Возвращает массив, где первым элементом будет 0, вторым разность `a[1] - a[0]` и т. д. Тип элементов результирующего массива определяется правилами вывода типов при вычитании (напр. `UInt8` - `UInt8` = `Int16`).
**Синтаксис**
``` sql
arrayDifference(array)
```
**Аргументы**
- `array` [массив](https://clickhouse.com/docs/ru/data_types/array/).
**Возвращаемое значение**
Возвращает массив разностей между соседними элементами.
**Пример**
Запрос:
``` sql
SELECT arrayDifference([1, 2, 3, 4]);
```
Результат:
``` text
┌─arrayDifference([1, 2, 3, 4])─┐
│ [0,1,1,1] │
└───────────────────────────────┘
```
Пример переполнения из-за результирующего типа `Int64`:
Запрос:
``` sql
SELECT arrayDifference([0, 10000000000000000000]);
```
Результат:
``` text
┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616] │
└────────────────────────────────────────────┘
```
## arrayDistinct {#arraydistinct}
Принимает массив, возвращает массив, содержащий уникальные элементы.
**Синтаксис**
``` sql
arrayDistinct(array)
```
**Аргументы**
- `array` [массив](https://clickhouse.com/docs/ru/data_types/array/).
**Возвращаемое значение**
Возвращает массив, содержащий только уникальные элементы исходного массива.
**Пример**
Запрос:
``` sql
SELECT arrayDistinct([1, 2, 2, 3, 1]);
```
Ответ:
``` text
┌─arrayDistinct([1, 2, 2, 3, 1])─┐
│ [1,2,3] │
└────────────────────────────────┘
```
## arrayEnumerateDense(arr) {#array_functions-arrayenumeratedense}
Возвращает массив того же размера, что и исходный массив, с индексами исходного массива, указывающими, где каждый элемент впервые появляется в исходном массиве.
Пример:
``` sql
SELECT arrayEnumerateDense([10, 20, 10, 30])
```
``` text
┌─arrayEnumerateDense([10, 20, 10, 30])─┐
│ [1,2,1,3] │
└───────────────────────────────────────┘
```
## arrayIntersect(arr) {#array-functions-arrayintersect}
Принимает несколько массивов, возвращает массив с элементами, присутствующими во всех исходных массивах.
Пример:
``` sql
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS no_intersect,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS intersect
```
``` text
┌─no_intersect─┬─intersect─┐
│ [] │ [1] │
└──────────────┴───────────┘
```
## arrayReduce {#arrayreduce}
Применяет агрегатную функцию к элементам массива и возвращает ее результат. Имя агрегирующей функции передается как строка в одинарных кавычках `'max'`, `'sum'`. При использовании параметрических агрегатных функций, параметр указывается после имени функции в круглых скобках `'uniqUpTo(6)'`.
**Синтаксис**
```sql
arrayReduce(agg_func, arr1, arr2, ..., arrN)
```
**Аргументы**
- `agg_func` — Имя агрегатной функции, которая должна быть константой [string](../../sql-reference/data-types/string.md).
- `arr` — Любое количество столбцов типа [array](../../sql-reference/data-types/array.md) в качестве параметров агрегатной функции.
**Возвращаемое значение**
**Пример**
Запрос:
```sql
SELECT arrayReduce('max', [1, 2, 3]);
```
Результат:
```text
┌─arrayReduce('max', [1, 2, 3])─┐
│ 3 │
└───────────────────────────────┘
```
Если агрегатная функция имеет несколько аргументов, то эту функцию можно применять к нескольким массивам одинакового размера.
**Пример**
Запрос:
```sql
SELECT arrayReduce('maxIf', [3, 5], [1, 0]);
```
Результат:
```text
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│ 3 │
└──────────────────────────────────────┘
```
Пример с параметрической агрегатной функцией:
Запрос:
```sql
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
```
Результат:
```text
┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│ 4 │
└─────────────────────────────────────────────────────────────┘
```
## arrayReduceInRanges {#arrayreduceinranges}
Применяет агрегатную функцию к элементам массива в заданных диапазонах и возвращает массив, содержащий результат, соответствующий каждому диапазону. Функция вернет тот же результат, что и несколько `arrayReduce(agg_func, arraySlice(arr1, index, length), ...)`.
**Синтаксис**
```sql
arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN)
```
**Аргументы**
- `agg_func` — имя агрегатной функции, которая должна быть [строковой](../../sql-reference/data-types/string.md) константой.
- `ranges` — диапазоны для агрегирования, которые должны быть [массивом](../../sql-reference/data-types/array.md) of [кортежей](../../sql-reference/data-types/tuple.md) содержащих индекс и длину каждого диапазона.
- `arr` — любое количество столбцов типа [Array](../../sql-reference/data-types/array.md) в качестве параметров агрегатной функции.
**Возвращаемое значение**
- Массив, содержащий результаты агрегатной функции для указанных диапазонов.
Тип: [Array](../../sql-reference/data-types/array.md).
**Пример**
Запрос:
```sql
SELECT arrayReduceInRanges(
'sum',
[(1, 5), (2, 3), (3, 4), (4, 4)],
[1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
```
Результат:
```text
┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘
```
## arrayReverse(arr) {#arrayreverse}
Возвращает массив того же размера, что и исходный массив, содержащий элементы в обратном порядке.
Пример:
``` sql
SELECT arrayReverse([1, 2, 3])
```
``` text
┌─arrayReverse([1, 2, 3])─┐
│ [3,2,1] │
└─────────────────────────┘
```
## reverse(arr) {#array-functions-reverse}
Синоним для [«arrayReverse»](#arrayreverse)
## arrayFlatten {#arrayflatten}
Преобразует массив массивов в плоский массив.
Функция:
- Оперирует с массивами любой вложенности.
- Не изменяет массив, если он уже плоский.
Результирующий массив содержит все элементы исходных массивов.
**Синтаксис**
``` sql
flatten(array_of_arrays)
```
Синоним: `flatten`.
**Аргументы**
- `array_of_arrays` — [массив](../../sql-reference/functions/array-functions.md) массивов. Например, `[[1,2,3], [4,5]]`.
**Примеры**
``` sql
SELECT flatten([[[1]], [[2], [3]]]);
```
``` text
┌─flatten(array(array([1]), array([2], [3])))─┐
│ [1,2,3] │
└─────────────────────────────────────────────┘
```
## arrayCompact {#arraycompact}
Удаляет последовательно повторяющиеся элементы из массива. Порядок результирующих значений определяется порядком в исходном массиве.
**Синтаксис**
``` sql
arrayCompact(arr)
```
**Аргументы**
`arr` — [массив](../../sql-reference/functions/array-functions.md) для обхода.
**Возвращаемое значение**
Массив без последовательных дубликатов.
Тип: `Array`.
**Пример**
Запрос:
``` sql
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
```
Результат:
``` text
┌─arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])─┐
│ [1,nan,nan,2,3] │
└────────────────────────────────────────────┘
```
## arrayZip {#arrayzip}
Объединяет несколько массивов в один. Результирующий массив содержит соответственные элементы исходных массивов, сгруппированные в кортежи в указанном порядке аргументов.
**Синтаксис**
``` sql
arrayZip(arr1, arr2, ..., arrN)
```
**Аргументы**
- `arrN` — [массив](../data-types/array.md).
Функция принимает любое количество массивов, которые могут быть различных типов. Все массивы должны иметь одинаковую длину.
**Возвращаемое значение**
- Массив с элементами исходных массивов, сгруппированными в [кортежи](../data-types/tuple.md). Типы данных в кортежах соответствуют типам данных входных массивов и следуют в том же порядке, в котором переданы массивы.
Тип: [Массив](../data-types/array.md).
**Пример**
Запрос:
``` sql
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
```
Результат:
``` text
┌─arrayZip(['a', 'b', 'c'], [5, 2, 1])─┐
│ [('a',5),('b',2),('c',1)] │
└──────────────────────────────────────┘
```
## arrayMap(func, arr1, …) {#array-map}
Возвращает массив, полученный на основе результатов применения функции `func` к каждому элементу массива `arr`.
Примеры:
``` sql
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
```
``` text
┌─res─────┐
│ [3,4,5] │
└─────────┘
```
Следующий пример показывает, как создать кортежи из элементов разных массивов:
``` sql
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res;
```
``` text
┌─res─────────────────┐
│ [(1,4),(2,5),(3,6)] │
└─────────────────────┘
```
Функция `arrayMap` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
## arrayFilter(func, arr1, …) {#array-filter}
Возвращает массив, содержащий только те элементы массива `arr1`, для которых функция `func` возвращает не 0.
Примеры:
``` sql
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
```
``` text
┌─res───────────┐
│ ['abc World'] │
└───────────────┘
```
``` sql
SELECT
arrayFilter(
(i, x) -> x LIKE '%World%',
arrayEnumerate(arr),
['Hello', 'abc World'] AS arr)
AS res
```
``` text
┌─res─┐
│ [2] │
└─────┘
```
Функция `arrayFilter` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
## arrayFill(func, arr1, …) {#array-fill}
Перебирает `arr1` от первого элемента к последнему и заменяет `arr1[i]` на `arr1[i - 1]`, если `func` вернула 0. Первый элемент `arr1` остаётся неизменным.
Примеры:
``` sql
SELECT arrayFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
```
``` text
┌─res──────────────────────────────┐
│ [1,1,3,11,12,12,12,5,6,14,14,14] │
└──────────────────────────────────┘
```
Функция `arrayFill` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
## arrayReverseFill(func, arr1, …) {#array-reverse-fill}
Перебирает `arr1` от последнего элемента к первому и заменяет `arr1[i]` на `arr1[i + 1]`, если `func` вернула 0. Последний элемент `arr1` остаётся неизменным.
Примеры:
``` sql
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
```
``` text
┌─res────────────────────────────────┐
│ [1,3,3,11,12,5,5,5,6,14,NULL,NULL] │
└────────────────────────────────────┘
```
Функция `arrayReverseFill` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
## arraySplit(func, arr1, …) {#array-split}
Разделяет массив `arr1` на несколько. Если `func` возвращает не 0, то массив разделяется, а элемент помещается в левую часть. Массив не разбивается по первому элементу.
Примеры:
``` sql
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
``` text
┌─res─────────────┐
│ [[1,2,3],[4,5]] │
└─────────────────┘
```
Функция `arraySplit` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
## arrayReverseSplit(func, arr1, …) {#array-reverse-split}
Разделяет массив `arr1` на несколько. Если `func` возвращает не 0, то массив разделяется, а элемент помещается в правую часть. Массив не разбивается по последнему элементу.
Примеры:
``` sql
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
``` text
┌─res───────────────┐
│ [[1],[2,3,4],[5]] │
└───────────────────┘
```
Функция `arrayReverseSplit` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
## arrayExists(\[func,\] arr1, …) {#arrayexistsfunc-arr1}
Возвращает 1, если существует хотя бы один элемент массива `arr`, для которого функция func возвращает не 0. Иначе возвращает 0.
Функция `arrayExists` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) - в качестве первого аргумента ей можно передать лямбда-функцию.
## arrayAll(\[func,\] arr1, …) {#arrayallfunc-arr1}
Возвращает 1, если для всех элементов массива `arr`, функция `func` возвращает не 0. Иначе возвращает 0.
Функция `arrayAll` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) - в качестве первого аргумента ей можно передать лямбда-функцию.
## arrayFirst(func, arr1, …) {#array-first}
Возвращает первый элемент массива `arr1`, для которого функция func возвращает не 0.
Функция `arrayFirst` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
## arrayFirstIndex(func, arr1, …) {#array-first-index}
Возвращает индекс первого элемента массива `arr1`, для которого функция func возвращает не 0.
Функция `arrayFirstIndex` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
## arrayMin {#array-min}
Возвращает значение минимального элемента в исходном массиве.
Если передана функция `func`, возвращается минимум из элементов массива, преобразованных этой функцией.
Функция `arrayMin` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
**Синтаксис**
```sql
arrayMin([func,] arr)
```
**Аргументы**
- `func` — функция. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — массив. [Array](../../sql-reference/data-types/array.md).
**Возвращаемое значение**
- Минимальное значение функции (или минимальный элемент массива).
Тип: если передана `func`, соответствует типу ее возвращаемого значения, иначе соответствует типу элементов массива.
**Примеры**
Запрос:
```sql
SELECT arrayMin([1, 2, 4]) AS res;
```
Результат:
```text
┌─res─┐
│ 1 │
└─────┘
```
Запрос:
```sql
SELECT arrayMin(x -> (-x), [1, 2, 4]) AS res;
```
Результат:
```text
┌─res─┐
│ -4 │
└─────┘
```
## arrayMax {#array-max}
Возвращает значение максимального элемента в исходном массиве.
Если передана функция `func`, возвращается максимум из элементов массива, преобразованных этой функцией.
Функция `arrayMax` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
**Синтаксис**
```sql
arrayMax([func,] arr)
```
**Аргументы**
- `func` — функция. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — массив. [Array](../../sql-reference/data-types/array.md).
**Возвращаемое значение**
- Максимальное значение функции (или максимальный элемент массива).
Тип: если передана `func`, соответствует типу ее возвращаемого значения, иначе соответствует типу элементов массива.
**Примеры**
Запрос:
```sql
SELECT arrayMax([1, 2, 4]) AS res;
```
Результат:
```text
┌─res─┐
│ 4 │
└─────┘
```
Запрос:
```sql
SELECT arrayMax(x -> (-x), [1, 2, 4]) AS res;
```
Результат:
```text
┌─res─┐
│ -1 │
└─────┘
```
## arraySum {#array-sum}
Возвращает сумму элементов в исходном массиве.
Если передана функция `func`, возвращается сумма элементов массива, преобразованных этой функцией.
Функция `arraySum` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
**Синтаксис**
```sql
arraySum([func,] arr)
```
**Аргументы**
- `func` — функция. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — массив. [Array](../../sql-reference/data-types/array.md).
**Возвращаемое значение**
- Сумма значений функции (или сумма элементов массива).
Тип: для Decimal чисел в исходном массиве (если функция `func` была передана, то для чисел, преобразованных ею) — [Decimal128](../../sql-reference/data-types/decimal.md), для чисел с плавающей точкой — [Float64](../../sql-reference/data-types/float.md), для беззнаковых целых чисел — [UInt64](../../sql-reference/data-types/int-uint.md), для целых чисел со знаком — [Int64](../../sql-reference/data-types/int-uint.md).
**Примеры**
Запрос:
```sql
SELECT arraySum([2, 3]) AS res;
```
Результат:
```text
┌─res─┐
│ 5 │
└─────┘
```
Запрос:
```sql
SELECT arraySum(x -> x*x, [2, 3]) AS res;
```
Результат:
```text
┌─res─┐
│ 13 │
└─────┘
```
## arrayAvg {#array-avg}
Возвращает среднее значение элементов в исходном массиве.
Если передана функция `func`, возвращается среднее значение элементов массива, преобразованных этой функцией.
Функция `arrayAvg` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
**Синтаксис**
```sql
arrayAvg([func,] arr)
```
**Аргументы**
- `func` — функция. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — массив. [Array](../../sql-reference/data-types/array.md).
**Возвращаемое значение**
- Среднее значение функции (или среднее значение элементов массива).
Тип: [Float64](../../sql-reference/data-types/float.md).
**Примеры**
Запрос:
```sql
SELECT arrayAvg([1, 2, 4]) AS res;
```
Результат:
```text
┌────────────────res─┐
│ 2.3333333333333335 │
└────────────────────┘
```
Запрос:
```sql
SELECT arrayAvg(x -> (x * x), [2, 4]) AS res;
```
Результат:
```text
┌─res─┐
│ 10 │
└─────┘
```
**Синтаксис**
``` sql
arraySum(arr)
```
**Возвращаемое значение**
- Число.
Тип: [Int](../../sql-reference/data-types/int-uint.md) или [Float](../../sql-reference/data-types/float.md).
**Аргументы**
- `arr` — [массив](../../sql-reference/data-types/array.md).
**Примеры**
Запрос:
```sql
SELECT arraySum([2,3]) AS res;
```
Результат:
``` text
┌─res─┐
│ 5 │
└─────┘
```
Запрос:
``` sql
SELECT arraySum(x -> x*x, [2, 3]) AS res;
```
Результат:
``` text
┌─res─┐
│ 13 │
└─────┘
```
## arrayCumSum(\[func,\] arr1, …) {#arraycumsumfunc-arr1}
Возвращает массив из частичных сумм элементов исходного массива (сумма с накоплением). Если указана функция `func`, то значения элементов массива преобразуются этой функцией перед суммированием.
Функция `arrayCumSum` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) - в качестве первого аргумента ей можно передать лямбда-функцию.
Пример:
``` sql
SELECT arrayCumSum([1, 1, 1, 1]) AS res
```
``` text
┌─res──────────┐
│ [1, 2, 3, 4] │
└──────────────┘
```
## arrayAUC {#arrayauc}
Вычисляет площадь под кривой.
**Синтаксис**
``` sql
arrayAUC(arr_scores, arr_labels)
```
**Аргументы**
- `arr_scores` — оценка, которую дает модель предсказания.
- `arr_labels` — ярлыки выборок, обычно 1 для содержательных выборок и 0 для бессодержательных выборок.
**Возвращаемое значение**
Значение площади под кривой.
Тип данных: `Float64`.
**Пример**
Запрос:
``` sql
SELECT arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
Результат:
``` text
┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│ 0.75 │
└────────────────────────────────────────---──┘
```
## arrayProduct {#arrayproduct}
Возвращает произведение элементов [массива](../../sql-reference/data-types/array.md).
**Синтаксис**
``` sql
arrayProduct(arr)
```
**Аргументы**
- `arr` — [массив](../../sql-reference/data-types/array.md) числовых значений.
**Возвращаемое значение**
- Произведение элементов массива.
Тип: [Float64](../../sql-reference/data-types/float.md).
**Примеры**
Запрос:
``` sql
SELECT arrayProduct([1,2,3,4,5,6]) as res;
```
Результат:
``` text
┌─res───┐
│ 720 │
└───────┘
```
Запрос:
``` sql
SELECT arrayProduct([toDecimal64(1,8), toDecimal64(2,8), toDecimal64(3,8)]) as res, toTypeName(res);
```
Возвращаемое значение всегда имеет тип [Float64](../../sql-reference/data-types/float.md). Результат:
``` text
┌─res─┬─toTypeName(arrayProduct(array(toDecimal64(1, 8), toDecimal64(2, 8), toDecimal64(3, 8))))─┐
│ 6 │ Float64 │
└─────┴──────────────────────────────────────────────────────────────────────────────────────────┘
```
## arrayRotateLeft
Поворачивает [массив](../../sql-reference/data-types/array.md) влево на заданное число элементов.
Если количество элементов отрицательно, то массив поворачивается вправо.
**Синтаксис**
``` sql
arrayRotateLeft(arr, n)
```
**Аргументы**
- `arr` — [Массив](../../sql-reference/data-types/array.md).
- `n` — Число элементов, на которое нужно повернуть массив.
**Возвращаемое значение**
- Массив, повернутый на заданное число элементов влево.
Тип: [Массив](../../sql-reference/data-types/array.md).
**Примеры**
Запрос:
``` sql
SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;
```
Результат:
``` text
┌─res───────────┐
│ [3,4,5,6,1,2] │
└───────────────┘
```
Запрос:
``` sql
SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;
```
Результат:
``` text
┌─res───────────┐
│ [5,6,1,2,3,4] │
└───────────────┘
```
Запрос:
``` sql
SELECT arrayRotateLeft(['a','b','c','d','e'], 3) as res;
```
Результат:
``` text
┌─res───────────────────┐
│ ['d','e','a','b','c'] │
└───────────────────────┘
```
## arrayRotateRight
Поворачивает [массив](../../sql-reference/data-types/array.md) вправо на заданное число элементов.
Если количество элементов отрицательно, то массив поворачивается влево.
**Синтаксис**
``` sql
arrayRotateRight(arr, n)
```
**Аргументы**
- `arr` — [Массив](../../sql-reference/data-types/array.md).
- `n` — Число элементов, на которое нужно повернуть массив.
**Возвращаемое значение**
- Массив, повернутый на заданное число элементов вправо.
Тип: [Массив](../../sql-reference/data-types/array.md).
**Примеры**
Запрос:
``` sql
SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;
```
Результат:
``` text
┌─res───────────┐
│ [5,6,1,2,3,4] │
└───────────────┘
```
Запрос:
``` sql
SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;
```
Результат:
``` text
┌─res───────────┐
│ [3,4,5,6,1,2] │
└───────────────┘
```
Запрос:
``` sql
SELECT arrayRotateRight(['a','b','c','d','e'], 3) as res;
```
Результат:
``` text
┌─res───────────────────┐
│ ['c','d','e','a','b'] │
└───────────────────────┘
```
## arrayShiftLeft
Сдвигает [массив](../../sql-reference/data-types/array.md) влево на заданное число элементов.
Новые элементы заполняются переданным аргументом или значением по умолчанию для типа элементов массива.
Если количество элементов отрицательно, то массив сдвигается вправо.
**Синтаксис**
``` sql
arrayShiftLeft(arr, n[, default])
```
**Аргументы**
- `arr` — [Массив](../../sql-reference/data-types/array.md).
- `n` — Число элементов, на которое нужно сдвинуть массив.
- `default` — Опциональный. Значение по умолчанию для новых элементов.
**Возвращаемое значение**
- Массив, сдвинутый на заданное число элементов влево.
Тип: [Массив](../../sql-reference/data-types/array.md).
**Примеры**
Запрос:
``` sql
SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;
```
Результат:
``` text
┌─res───────────┐
│ [3,4,5,6,0,0] │
└───────────────┘
```
Запрос:
``` sql
SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;
```
Результат:
``` text
┌─res───────────┐
│ [0,0,1,2,3,4] │
└───────────────┘
```
Запрос:
``` sql
SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;
```
Результат:
``` text
┌─res─────────────┐
│ [3,4,5,6,42,42] │
└─────────────────┘
```
Запрос:
``` sql
SELECT arrayShiftLeft(['a','b','c','d','e','f'], 3, 'foo') as res;
```
Результат:
``` text
┌─res─────────────────────────────┐
│ ['d','e','f','foo','foo','foo'] │
└─────────────────────────────────┘
```
Запрос:
``` sql
SELECT arrayShiftLeft([1,2,3,4,5,6] :: Array(UInt16), 2, 4242) as res;
```
Результат:
``` text
┌─res─────────────────┐
│ [3,4,5,6,4242,4242] │
└─────────────────────┘
```
## arrayShiftRight
Сдвигает [массив](../../sql-reference/data-types/array.md) вправо на заданное число элементов.
Новые элементы заполняются переданным аргументом или значением по умолчанию для типа элементов массива.
Если количество элементов отрицательно, то массив сдвигается влево.
**Синтаксис**
``` sql
arrayShiftRight(arr, n[, default])
```
**Аргументы**
- `arr` — [Массив](../../sql-reference/data-types/array.md).
- `n` — Число элементов, на которое нужно сдвинуть массив.
- `default` — Опциональный. Значение по умолчанию для новых элементов.
**Возвращаемое значение**
- Массив, сдвинутый на заданное число элементов вправо.
Тип: [Массив](../../sql-reference/data-types/array.md).
**Примеры**
Запрос:
``` sql
SELECT arrayShiftRight([1,2,3,4,5,6], 2) as res;
```
Результат:
``` text
┌─res───────────┐
│ [0,0,1,2,3,4] │
└───────────────┘
```
Запрос:
``` sql
SELECT arrayShiftRight([1,2,3,4,5,6], -2) as res;
```
Результат:
``` text
┌─res───────────┐
│ [3,4,5,6,0,0] │
└───────────────┘
```
Запрос:
``` sql
SELECT arrayShiftRight([1,2,3,4,5,6], 2, 42) as res;
```
Результат:
``` text
┌─res─────────────┐
│ [42,42,1,2,3,4] │
└─────────────────┘
```
Запрос:
``` sql
SELECT arrayShiftRight(['a','b','c','d','e','f'], 3, 'foo') as res;
```
Результат:
``` text
┌─res─────────────────────────────┐
│ ['foo','foo','foo','a','b','c'] │
└─────────────────────────────────┘
```
Запрос:
``` sql
SELECT arrayShiftRight([1,2,3,4,5,6] :: Array(UInt16), 2, 4242) as res;
```
Результат:
``` text
┌─res─────────────────┐
│ [4242,4242,1,2,3,4] │
└─────────────────────┘
```