ClickHouse/docs/ru/sql-reference/functions/array-functions.md

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

2030 lines
75 KiB
Markdown
Raw Normal View History

---
2022-08-26 17:37:11 +00:00
slug: /ru/sql-reference/functions/array-functions
sidebar_position: 35
sidebar_label: "Массивы"
---
# Массивы {#functions-for-working-with-arrays}
## empty {#function-empty}
Проверяет, является ли входной массив пустым.
**Синтаксис**
``` sql
empty([x])
```
Массив считается пустым, если он не содержит ни одного элемента.
2023-09-05 12:43:53 +00:00
:::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`.
2022-08-22 14:11:55 +00:00
:::
Функция также поддерживает работу с типами [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 │
└────────────────┘
```
2021-06-26 23:37:34 +00:00
## notEmpty {#function-notempty}
Проверяет, является ли входной массив непустым.
**Синтаксис**
``` sql
notEmpty([x])
```
Массив считается непустым, если он содержит хотя бы один элемент.
2023-09-05 12:43:53 +00:00
:::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`.
2022-08-22 14:11:55 +00:00
:::
Функция также поддерживает работу с типами [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 │
└──────────────────┘
```
2021-06-26 23:37:34 +00:00
## length {#array_functions-length}
Возвращает количество элементов в массиве.
Тип результата - UInt64.
Функция также работает для строк.
2021-06-29 13:27:54 +00:00
Функцию можно оптимизировать, если включить настройку [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`.
2021-06-26 23:37:34 +00:00
## 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}
Принимает пустой массив и возвращает массив из одного элемента, равного значению по умолчанию.
2021-06-20 12:23:18 +00:00
2021-06-18 17:53:52 +00:00
## range(end), range(\[start, \] end \[, step\]) {#range}
2021-06-17 00:16:34 +00:00
Возвращает массив чисел от `start` до `end - 1` с шагом `step`.
2021-06-16 23:34:59 +00:00
2021-06-17 09:02:06 +00:00
**Синтаксис**
2021-06-16 23:34:59 +00:00
``` sql
2021-06-18 17:53:52 +00:00
range([start, ] end [, step])
2021-06-16 23:34:59 +00:00
```
**Аргументы**
2021-06-20 12:37:28 +00:00
- `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)
2021-06-16 23:34:59 +00:00
**Возвращаемые значения**
2021-06-18 17:53:52 +00:00
- массив `UInt` чисел от `start` до `end - 1` с шагом `step`
2021-06-16 23:34:59 +00:00
2021-06-21 10:01:23 +00:00
**Особенности реализации**
2021-06-16 23:34:59 +00:00
- Не поддерживаются отрицательные значения аргументов: `start`, `end`, `step` имеют тип `UInt`.
2021-06-16 23:34:59 +00:00
- Если в результате запроса создаются массивы суммарной длиной больше, чем количество элементов, указанное настройкой [function_range_max_elements_in_block](../../operations/settings/settings.md#settings-function_range_max_elements_in_block), то генерируется исключение.
2021-06-16 23:34:59 +00:00
2023-07-04 10:20:48 +00:00
- Возвращает Null если любой аргумент Nullable(Nothing) типа. Генерируется исключение если любой аргумент Null (Nullable(T) тип).
2021-06-16 23:34:59 +00:00
**Примеры**
2021-06-18 17:53:52 +00:00
Запрос:
2021-06-16 23:34:59 +00:00
``` sql
2021-06-18 17:53:52 +00:00
SELECT range(5), range(1, 5), range(1, 5, 2);
2021-06-16 23:34:59 +00:00
```
Ответ:
2021-06-18 17:53:52 +00:00
```txt
┌─range(5)────┬─range(1, 5)─┬─range(1, 5, 2)─┐
│ [0,1,2,3,4] │ [1,2,3,4] │ [1,3] │
└─────────────┴─────────────┴────────────────┘
2021-06-16 23:34:59 +00:00
```
2021-06-18 17:53:52 +00:00
## 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)
DOCAPI-8530: Code blocks markup fix (#7060) * Typo fix. * Links fix. * Fixed links in docs. * More fixes. * docs/en: cleaning some files * docs/en: cleaning data_types * docs/en: cleaning database_engines * docs/en: cleaning development * docs/en: cleaning getting_started * docs/en: cleaning interfaces * docs/en: cleaning operations * docs/en: cleaning query_lamguage * docs/en: cleaning en * docs/ru: cleaning data_types * docs/ru: cleaning index * docs/ru: cleaning database_engines * docs/ru: cleaning development * docs/ru: cleaning general * docs/ru: cleaning getting_started * docs/ru: cleaning interfaces * docs/ru: cleaning operations * docs/ru: cleaning query_language * docs: cleaning interfaces/http * Update docs/en/data_types/array.md decorated ``` Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/nyc_taxi.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/ontime.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/interfaces/formats.md fixed error Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/custom_partitioning_key.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/dicts/external_dicts_dict_sources.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/date_time_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/jdbc.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * docs: fixed error * docs: fixed error
2019-09-23 15:31:46 +00:00
```
``` 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)
DOCAPI-8530: Code blocks markup fix (#7060) * Typo fix. * Links fix. * Fixed links in docs. * More fixes. * docs/en: cleaning some files * docs/en: cleaning data_types * docs/en: cleaning database_engines * docs/en: cleaning development * docs/en: cleaning getting_started * docs/en: cleaning interfaces * docs/en: cleaning operations * docs/en: cleaning query_lamguage * docs/en: cleaning en * docs/ru: cleaning data_types * docs/ru: cleaning index * docs/ru: cleaning database_engines * docs/ru: cleaning development * docs/ru: cleaning general * docs/ru: cleaning getting_started * docs/ru: cleaning interfaces * docs/ru: cleaning operations * docs/ru: cleaning query_language * docs: cleaning interfaces/http * Update docs/en/data_types/array.md decorated ``` Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/nyc_taxi.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/ontime.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/interfaces/formats.md fixed error Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/custom_partitioning_key.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/dicts/external_dicts_dict_sources.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/date_time_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/jdbc.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * docs: fixed error * docs: fixed error
2019-09-23 15:31:46 +00:00
```
``` 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)
DOCAPI-8530: Code blocks markup fix (#7060) * Typo fix. * Links fix. * Fixed links in docs. * More fixes. * docs/en: cleaning some files * docs/en: cleaning data_types * docs/en: cleaning database_engines * docs/en: cleaning development * docs/en: cleaning getting_started * docs/en: cleaning interfaces * docs/en: cleaning operations * docs/en: cleaning query_lamguage * docs/en: cleaning en * docs/ru: cleaning data_types * docs/ru: cleaning index * docs/ru: cleaning database_engines * docs/ru: cleaning development * docs/ru: cleaning general * docs/ru: cleaning getting_started * docs/ru: cleaning interfaces * docs/ru: cleaning operations * docs/ru: cleaning query_language * docs: cleaning interfaces/http * Update docs/en/data_types/array.md decorated ``` Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/nyc_taxi.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/ontime.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/interfaces/formats.md fixed error Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/custom_partitioning_key.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/dicts/external_dicts_dict_sources.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/date_time_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/jdbc.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * docs: fixed error * docs: fixed error
2019-09-23 15:31:46 +00:00
```
``` 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
```
CLICKHOUSE-2720: progress on website (#865) * update presentations * CLICKHOUSE-2936: redirect from clickhouse.yandex.ru and clickhouse.yandex.com * update submodule * lost files * CLICKHOUSE-2981: prefer sphinx docs over original reference * CLICKHOUSE-2981: docs styles more similar to main website + add flags to switch language links * update presentations * Less confusing directory structure (docs -> doc/reference/) * Minify sphinx docs too * Website release script: fail fast + pass docker hash on deploy * Do not underline links in docs * shorter * cleanup docker images * tune nginx config * CLICKHOUSE-3043: get rid of habrastorage links * Lost translation * CLICKHOUSE-2936: temporary client-side redirect * behaves weird in test * put redirect back * CLICKHOUSE-3047: copy docs txts to public too * move to proper file * remove old pages to avoid confusion * Remove reference redirect warning for now * Refresh README.md * Yellow buttons in docs * Use svg flags instead of unicode ones in docs * fix test website instance * Put flags to separate files * wrong flag * Copy Yandex.Metrica introduction from main page to docs * Yet another home page structure change, couple new blocks (CLICKHOUSE-3045) * Update Contacts section * CLICKHOUSE-2849: more detailed legal information * CLICKHOUSE-2978 preparation - split by files * More changes in Contacts block * Tune texts on index page * update presentations * One more benchmark * Add usage sections to index page, adapted from slides * Get the roadmap started, based on slides from last ClickHouse Meetup * CLICKHOUSE-2977: some rendering tuning * Get rid of excessive section in the end of getting started * Make headers linkable * CLICKHOUSE-2981: links to editing reference - https://github.com/yandex/ClickHouse/issues/849 * CLICKHOUSE-2981: fix mobile styles in docs * Ban crawling of duplicating docs * Open some external links in new tab * Ban old docs too * Lots of trivial fixes in english docs * Lots of trivial fixes in russian docs * Remove getting started copies in markdown * Add Yandex.Webmaster * Fix some sphinx warnings * More warnings fixed in english docs * More sphinx warnings fixed * Add code-block:: text * More code-block:: text * These headers look not that well * Better switch between documentation languages * merge use_case.rst into ya_metrika_task.rst * Edit the agg_functions.rst texts * Add lost empty lines
2017-06-13 04:15:47 +00:00
``` 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);
DOCAPI-8530: Code blocks markup fix (#7060) * Typo fix. * Links fix. * Fixed links in docs. * More fixes. * docs/en: cleaning some files * docs/en: cleaning data_types * docs/en: cleaning database_engines * docs/en: cleaning development * docs/en: cleaning getting_started * docs/en: cleaning interfaces * docs/en: cleaning operations * docs/en: cleaning query_lamguage * docs/en: cleaning en * docs/ru: cleaning data_types * docs/ru: cleaning index * docs/ru: cleaning database_engines * docs/ru: cleaning development * docs/ru: cleaning general * docs/ru: cleaning getting_started * docs/ru: cleaning interfaces * docs/ru: cleaning operations * docs/ru: cleaning query_language * docs: cleaning interfaces/http * Update docs/en/data_types/array.md decorated ``` Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/nyc_taxi.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/ontime.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/interfaces/formats.md fixed error Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/custom_partitioning_key.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/dicts/external_dicts_dict_sources.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/date_time_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/jdbc.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * docs: fixed error * docs: fixed error
2019-09-23 15:31:46 +00:00
```
``` text
┌─arrayResize([1], 3)─┐
│ [1,0,0] │
└─────────────────────┘
```
``` sql
SELECT arrayResize([1], 3, NULL);
DOCAPI-8530: Code blocks markup fix (#7060) * Typo fix. * Links fix. * Fixed links in docs. * More fixes. * docs/en: cleaning some files * docs/en: cleaning data_types * docs/en: cleaning database_engines * docs/en: cleaning development * docs/en: cleaning getting_started * docs/en: cleaning interfaces * docs/en: cleaning operations * docs/en: cleaning query_lamguage * docs/en: cleaning en * docs/ru: cleaning data_types * docs/ru: cleaning index * docs/ru: cleaning database_engines * docs/ru: cleaning development * docs/ru: cleaning general * docs/ru: cleaning getting_started * docs/ru: cleaning interfaces * docs/ru: cleaning operations * docs/ru: cleaning query_language * docs: cleaning interfaces/http * Update docs/en/data_types/array.md decorated ``` Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/nyc_taxi.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/getting_started/example_datasets/ontime.md fixed typo Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/interfaces/formats.md fixed error Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/custom_partitioning_key.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/dicts/external_dicts_dict_sources.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/utils/clickhouse-local.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/json_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/other_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/query_language/functions/date_time_functions.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/operations/table_engines/jdbc.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * docs: fixed error * docs: fixed error
2019-09-23 15:31:46 +00:00
```
``` text
┌─arrayResize([1], 3, NULL)─┐
│ [1,NULL,NULL] │
└───────────────────────────┘
```
## arraySlice {#arrayslice}
Возвращает срез массива.
``` sql
arraySlice(array, offset[, length])
```
**Аргументы**
2022-05-07 10:49:03 +00:00
- `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}
2019-04-19 15:18:57 +00:00
2019-04-23 19:43:20 +00:00
Возвращает массив `arr`, отсортированный в восходящем порядке. Если задана функция `func`, то порядок сортировки определяется результатом применения этой функции на элементы массива `arr`. Если `func` принимает несколько аргументов, то в функцию `arraySort` нужно передавать несколько массивов, которые будут соответствовать аргументам функции `func`. Подробные примеры рассмотрены в конце описания `arraySort`.
2019-04-19 15:18:57 +00:00
2019-04-23 12:56:22 +00:00
Пример сортировки целочисленных значений:
2019-04-19 15:18:57 +00:00
``` sql
2019-04-19 15:18:57 +00:00
SELECT arraySort([1, 3, 3, 0])
```
``` text
2019-04-19 15:18:57 +00:00
┌─arraySort([1, 3, 3, 0])─┐
│ [0,1,3,3] │
└─────────────────────────┘
```
2019-04-23 12:56:22 +00:00
Пример сортировки строковых значений:
2019-04-19 15:55:23 +00:00
``` sql
2019-04-19 15:55:23 +00:00
SELECT arraySort(['hello', 'world', '!'])
```
``` text
2019-04-19 15:55:23 +00:00
┌─arraySort(['hello', 'world', '!'])─┐
│ ['!','hello','world'] │
└────────────────────────────────────┘
```
2019-04-23 12:56:22 +00:00
Значения `NULL`, `NaN` и `Inf` сортируются по следующему принципу:
``` sql
2019-04-23 12:56:22 +00:00
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
```
``` text
2019-04-23 12:56:22 +00:00
┌─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`.
2019-04-23 12:56:22 +00:00
Функция `arraySort` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию. В этом случае порядок сортировки определяется результатом применения лямбда-функции на элементы массива.
2019-04-23 19:43:20 +00:00
Рассмотрим пример:
2019-04-19 15:18:57 +00:00
``` sql
2019-04-23 19:43:20 +00:00
SELECT arraySort((x) -> -x, [1, 2, 3]) as res;
```
``` text
2019-04-23 19:43:20 +00:00
┌─res─────┐
│ [3,2,1] │
└─────────┘
```
Для каждого элемента исходного массива лямбда-функция возвращает ключ сортировки, то есть \[1 \> -1, 2 \> -2, 3 \> -3\]. Так как `arraySort` сортирует элементы в порядке возрастания ключей, результат будет \[3, 2, 1\]. Как можно заметить, функция `x > -x` устанавливает [обратный порядок сортировки](#array_functions-reverse-sort).
2019-04-23 19:43:20 +00:00
2019-04-24 21:08:49 +00:00
Лямбда-функция может принимать несколько аргументов. В этом случае, в функцию `arraySort` нужно передавать несколько массивов, которые будут соответствовать аргументам лямбда-функции (массивы должны быть одинаковой длины). Следует иметь в виду, что результат будет содержать элементы только из первого массива; элементы из всех последующих массивов будут задавать ключи сортировки. Например:
2019-04-23 19:43:20 +00:00
``` sql
2019-04-23 19:43:20 +00:00
SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
2019-04-19 15:18:57 +00:00
```
2019-04-23 12:56:22 +00:00
``` text
2019-04-23 12:56:22 +00:00
┌─res────────────────┐
│ ['world', 'hello'] │
└────────────────────┘
2019-04-19 15:18:57 +00:00
```
Элементы, указанные во втором массиве (\[2,1\]), определяют ключ сортировки для элементов из исходного массива (\[hello, world\]), то есть \[hello \> 2, world \> 1\]. Так как лямбда-функция не использует `x`, элементы исходного массива не влияют на порядок сортировки. Таким образом, hello будет вторым элементом в отсортированном массиве, а world — первым.
2019-04-23 12:56:22 +00:00
2019-04-23 19:54:32 +00:00
Ниже приведены другие примеры.
2019-04-23 12:56:22 +00:00
``` sql
2019-04-23 19:43:20 +00:00
SELECT arraySort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
2019-04-23 12:56:22 +00:00
```
``` text
2019-04-23 12:56:22 +00:00
┌─res─────┐
2019-04-23 19:43:20 +00:00
│ [2,1,0] │
2019-04-23 12:56:22 +00:00
└─────────┘
```
``` sql
2019-04-23 19:54:32 +00:00
SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res;
```
``` text
2019-04-23 19:54:32 +00:00
┌─res─────┐
│ [2,1,0] │
└─────────┘
```
2019-04-23 12:56:22 +00:00
2023-09-05 12:43:53 +00:00
:::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).
2022-08-22 14:11:55 +00:00
:::
## arrayPartialSort(\[func,\] limit, arr, …) {#array_functions-sort}
2023-04-21 02:39:26 +00:00
То же, что и `arraySort` с дополнительным аргументом `limit`, позволяющим частичную сортировку. Возвращает массив того же размера, как и исходный, в котором элементы `[1..limit]` отсортированы в возрастающем порядке. Остальные элементы `(limit..N]` остаются в неспецифицированном порядке.
## arrayReverseSort(\[func,\] arr, …) {#array_functions-reverse-sort}
2019-04-19 15:18:57 +00:00
2019-04-23 19:43:20 +00:00
Возвращает массив `arr`, отсортированный в нисходящем порядке. Если указана функция `func`, то массив `arr` сначала сортируется в порядке, который определяется функцией `func`, а затем отсортированный массив переворачивается. Если функция `func` принимает несколько аргументов, то в функцию `arrayReverseSort` необходимо передавать несколько массивов, которые будут соответствовать аргументам функции `func`. Подробные примеры рассмотрены в конце описания функции `arrayReverseSort`.
2019-04-23 12:56:22 +00:00
Пример сортировки целочисленных значений:
``` sql
2019-04-23 12:56:22 +00:00
SELECT arrayReverseSort([1, 3, 3, 0]);
2019-04-19 15:55:23 +00:00
```
``` text
2019-04-19 15:55:23 +00:00
┌─arrayReverseSort([1, 3, 3, 0])─┐
│ [3,3,1,0] │
└────────────────────────────────┘
```
2019-04-23 12:56:22 +00:00
Пример сортировки строковых значений:
2019-04-19 15:55:23 +00:00
``` sql
2019-04-23 12:56:22 +00:00
SELECT arrayReverseSort(['hello', 'world', '!']);
2019-04-19 15:55:23 +00:00
```
``` text
2019-04-19 15:55:23 +00:00
┌─arrayReverseSort(['hello', 'world', '!'])─┐
│ ['world','hello','!'] │
└───────────────────────────────────────────┘
```
2019-04-19 15:18:57 +00:00
2019-04-23 12:56:22 +00:00
Значения `NULL`, `NaN` и `Inf` сортируются в следующем порядке:
``` sql
2019-04-23 12:56:22 +00:00
SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
```
``` text
2019-04-23 12:56:22 +00:00
┌─res───────────────────────────────────┐
│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────┘
```
- Значения `Inf` идут в начале массива.
- Значения `NULL` идут в конце массива.
- Значения `NaN` идут перед `NULL`.
- Значения `-Inf` идут перед `NaN`.
2019-04-23 12:56:22 +00:00
Функция `arrayReverseSort` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию. Например:
2019-04-23 12:56:22 +00:00
``` sql
2019-04-24 21:08:49 +00:00
SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
```
``` text
2019-04-24 21:08:49 +00:00
┌─res─────┐
│ [1,2,3] │
└─────────┘
```
В этом примере, порядок сортировки устанавливается следующим образом:
1. Сначала исходный массив (\[1, 2, 3\]) сортируется в том порядке, который определяется лямбда-функцией. Результатом будет массив \[3, 2, 1\].
2. Массив, который был получен на предыдущем шаге, переворачивается. То есть, получается массив \[1, 2, 3\].
2019-04-24 21:08:49 +00:00
Лямбда-функция может принимать на вход несколько аргументов. В этом случае, в функцию `arrayReverseSort` нужно передавать несколько массивов, которые будут соответствовать аргументам лямбда-функции (массивы должны быть одинаковой длины). Следует иметь в виду, что результат будет содержать элементы только из первого массива; элементы из всех последующих массивов будут определять ключи сортировки. Например:
``` sql
2019-04-23 12:56:22 +00:00
SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
2019-04-19 15:18:57 +00:00
```
``` text
2019-04-23 12:56:22 +00:00
┌─res───────────────┐
│ ['hello','world'] │
└───────────────────┘
2019-04-19 15:18:57 +00:00
```
2019-04-23 12:56:22 +00:00
2019-04-24 21:08:49 +00:00
В этом примере, массив сортируется следующим образом:
2019-04-23 12:56:22 +00:00
1. Сначала массив сортируется в том порядке, который определяется лямбда-функцией. Элементы, указанные во втором массиве (\[2,1\]), определяют ключи сортировки соответствующих элементов из исходного массива (\[hello, world\]). То есть, будет массив \[world, hello\].
2. Массив, который был отсортирован на предыдущем шаге, переворачивается. Получается массив \[hello, world\].
2019-04-23 12:56:22 +00:00
2019-04-23 19:54:32 +00:00
Ниже приведены ещё примеры.
2019-04-23 12:56:22 +00:00
``` sql
2019-04-23 19:43:20 +00:00
SELECT arrayReverseSort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
2019-04-23 12:56:22 +00:00
```
``` text
2019-04-23 12:56:22 +00:00
┌─res─────┐
2019-04-23 19:43:20 +00:00
│ [0,1,2] │
2019-04-23 12:56:22 +00:00
└─────────┘
2019-04-19 15:18:57 +00:00
```
``` sql
2019-04-23 19:54:32 +00:00
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
```
``` text
2019-04-23 19:54:32 +00:00
┌─res─────┐
│ [4,3,5] │
└─────────┘
```
2019-04-19 15:18:57 +00:00
## arrayPartialReverseSort(\[func,\] limit, arr, …) {#array_functions-sort}
2023-04-21 02:39:26 +00:00
То же, что и `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}
2020-02-02 22:41:39 +00:00
Вычисляет разность между соседними элементами массива. Возвращает массив, где первым элементом будет 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/).
**Возвращаемое значение**
2020-02-02 22:41:39 +00:00
Возвращает массив, содержащий только уникальные элементы исходного массива.
**Пример**
Запрос:
``` 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] │
└──────────────┴───────────┘
```
2020-12-24 09:13:49 +00:00
## 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) константой.
2021-03-15 12:54:51 +00:00
- `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] │
└─────────────────────────────┘
```
DOCS-624: Fixing links to nowhere (#10675) * enbaskakova-DOCSUP-652 (#101) * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" Co-authored-by: elenbaskakova <elenbaskakova@yandex-team.ru> Co-authored-by: BayoNet <da-daos@yandex.ru> * Revert "enbaskakova-DOCSUP-652 (#101)" (#107) This reverts commit 639fee7610f28e421d14e535b7def3f466e7efca. * CLICKHOUSEDOCS-624: Fixed links. Was 60, became 13. * CLICKHOUSEDOCS-624: Finished fix links in Enlish version. * CLICKHOUSEDOCS-624: Fixed RU links Co-authored-by: elenaspb2019 <47083263+elenaspb2019@users.noreply.github.com> Co-authored-by: elenbaskakova <elenbaskakova@yandex-team.ru> Co-authored-by: Sergei Shtykov <bayonet@yandex-team.ru>
2020-05-06 06:13:29 +00:00
## arrayReverse(arr) {#arrayreverse}
Возвращает массив того же размера, что и исходный массив, содержащий элементы в обратном порядке.
Пример:
``` sql
SELECT arrayReverse([1, 2, 3])
```
``` text
┌─arrayReverse([1, 2, 3])─┐
│ [3,2,1] │
└─────────────────────────┘
```
## reverse(arr) {#array-functions-reverse}
DOCS-624: Fixing links to nowhere (#10675) * enbaskakova-DOCSUP-652 (#101) * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * Update docs/en/sql_reference/aggregate_functions/combinators.md Co-Authored-By: BayoNet <da-daos@yandex.ru> * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" * "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited" Co-authored-by: elenbaskakova <elenbaskakova@yandex-team.ru> Co-authored-by: BayoNet <da-daos@yandex.ru> * Revert "enbaskakova-DOCSUP-652 (#101)" (#107) This reverts commit 639fee7610f28e421d14e535b7def3f466e7efca. * CLICKHOUSEDOCS-624: Fixed links. Was 60, became 13. * CLICKHOUSEDOCS-624: Finished fix links in Enlish version. * CLICKHOUSEDOCS-624: Fixed RU links Co-authored-by: elenaspb2019 <47083263+elenaspb2019@users.noreply.github.com> Co-authored-by: elenbaskakova <elenbaskakova@yandex-team.ru> Co-authored-by: Sergei Shtykov <bayonet@yandex-team.ru>
2020-05-06 06:13:29 +00:00
Синоним для [«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] │
└─────────────────────────────────────────────┘
```
2019-11-26 12:46:18 +00:00
## arrayCompact {#arraycompact}
2020-08-18 20:17:24 +00:00
Удаляет последовательно повторяющиеся элементы из массива. Порядок результирующих значений определяется порядком в исходном массиве.
2019-11-26 12:46:18 +00:00
**Синтаксис**
``` sql
2019-11-26 12:46:18 +00:00
arrayCompact(arr)
```
**Аргументы**
2019-11-26 12:46:18 +00:00
`arr` — [массив](../../sql-reference/functions/array-functions.md) для обхода.
2019-11-26 12:46:18 +00:00
**Возвращаемое значение**
Массив без последовательных дубликатов.
2019-11-26 12:46:18 +00:00
Тип: `Array`.
**Пример**
Запрос:
``` sql
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
2019-11-26 12:46:18 +00:00
```
Результат:
2019-11-26 12:46:18 +00:00
``` text
2019-11-26 12:46:18 +00:00
┌─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) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
2021-01-29 06:48:53 +00:00
## arrayMin {#array-min}
2021-02-05 19:14:52 +00:00
Возвращает значение минимального элемента в исходном массиве.
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
Если передана функция `func`, возвращается минимум из элементов массива, преобразованных этой функцией.
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
Функция `arrayMin` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
**Синтаксис**
```sql
arrayMin([func,] arr)
2021-02-05 19:14:52 +00:00
```
**Аргументы**
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
- `func` — функция. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — массив. [Array](../../sql-reference/data-types/array.md).
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
**Возвращаемое значение**
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
- Минимальное значение функции (или минимальный элемент массива).
2021-02-05 19:14:52 +00:00
2021-02-06 13:37:12 +00:00
Тип: если передана `func`, соответствует типу ее возвращаемого значения, иначе соответствует типу элементов массива.
2021-02-05 19:14:52 +00:00
**Примеры**
Запрос:
2021-01-29 06:48:53 +00:00
```sql
SELECT arrayMin([1, 2, 4]) AS res;
2021-02-05 19:14:52 +00:00
```
Результат:
2021-01-29 06:48:53 +00:00
```text
2021-02-05 19:14:52 +00:00
┌─res─┐
│ 1 │
└─────┘
```
Запрос:
2021-01-29 07:19:01 +00:00
```sql
SELECT arrayMin(x -> (-x), [1, 2, 4]) AS res;
2021-02-05 19:14:52 +00:00
```
Результат:
2021-01-29 06:48:53 +00:00
```text
2021-02-05 19:14:52 +00:00
┌─res─┐
│ -4 │
└─────┘
```
2021-01-29 06:48:53 +00:00
## arrayMax {#array-max}
2021-02-05 19:14:52 +00:00
Возвращает значение максимального элемента в исходном массиве.
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
Если передана функция `func`, возвращается максимум из элементов массива, преобразованных этой функцией.
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
Функция `arrayMax` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
**Синтаксис**
```sql
arrayMax([func,] arr)
2021-02-05 19:14:52 +00:00
```
**Аргументы**
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
- `func` — функция. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — массив. [Array](../../sql-reference/data-types/array.md).
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
**Возвращаемое значение**
2021-02-05 19:14:52 +00:00
2021-01-29 06:48:53 +00:00
- Максимальное значение функции (или максимальный элемент массива).
2021-02-05 19:14:52 +00:00
2021-02-06 13:37:12 +00:00
Тип: если передана `func`, соответствует типу ее возвращаемого значения, иначе соответствует типу элементов массива.
2021-02-05 19:14:52 +00:00
**Примеры**
Запрос:
```sql
SELECT arrayMax([1, 2, 4]) AS res;
2021-02-05 19:14:52 +00:00
```
Результат:
2021-01-29 06:48:53 +00:00
```text
2021-02-05 19:14:52 +00:00
┌─res─┐
│ 4 │
└─────┘
```
Запрос:
2021-01-29 06:48:53 +00:00
```sql
SELECT arrayMax(x -> (-x), [1, 2, 4]) AS res;
2021-02-05 19:14:52 +00:00
```
Результат:
2021-01-29 06:48:53 +00:00
```text
2021-02-05 19:14:52 +00:00
┌─res─┐
│ -1 │
└─────┘
```
2021-01-29 06:48:53 +00:00
## arraySum {#array-sum}
Возвращает сумму элементов в исходном массиве.
2021-01-29 06:48:53 +00:00
Если передана функция `func`, возвращается сумма элементов массива, преобразованных этой функцией.
Функция `arraySum` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
**Синтаксис**
```sql
arraySum([func,] arr)
```
**Аргументы**
2021-01-29 06:48:53 +00:00
- `func` — функция. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — массив. [Array](../../sql-reference/data-types/array.md).
2021-01-29 06:48:53 +00:00
**Возвращаемое значение**
- Сумма значений функции (или сумма элементов массива).
2021-02-06 13:37:12 +00:00
Тип: для 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).
2021-01-29 06:48:53 +00:00
**Примеры**
Запрос:
```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}
Возвращает среднее значение элементов в исходном массиве.
2021-01-29 06:48:53 +00:00
Если передана функция `func`, возвращается среднее значение элементов массива, преобразованных этой функцией.
Функция `arrayAvg` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
**Синтаксис**
```sql
arrayAvg([func,] arr)
```
**Аргументы**
2021-01-29 06:48:53 +00:00
- `func` — функция. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — массив. [Array](../../sql-reference/data-types/array.md).
2021-01-29 06:48:53 +00:00
**Возвращаемое значение**
- Среднее значение функции (или среднее значение элементов массива).
Тип: [Float64](../../sql-reference/data-types/float.md).
**Примеры**
Запрос:
```sql
SELECT arrayAvg([1, 2, 4]) AS res;
```
Результат:
```text
┌────────────────res─┐
│ 2.3333333333333335 │
└────────────────────┘
```
2021-01-29 06:48:53 +00:00
Запрос:
2021-01-29 06:48:53 +00:00
```sql
SELECT arrayAvg(x -> (x * x), [2, 4]) AS res;
```
Результат:
```text
┌─res─┐
│ 10 │
└─────┘
```
**Синтаксис**
2021-02-05 19:14:52 +00:00
``` sql
arraySum(arr)
```
**Возвращаемое значение**
- Число.
Тип: [Int](../../sql-reference/data-types/int-uint.md) или [Float](../../sql-reference/data-types/float.md).
**Аргументы**
2021-02-05 19:14:52 +00:00
- `arr` — [массив](../../sql-reference/data-types/array.md).
2021-02-05 19:14:52 +00:00
**Примеры**
Запрос:
```sql
SELECT arraySum([2,3]) AS res;
2021-02-05 19:14:52 +00:00
```
Результат:
``` text
┌─res─┐
│ 5 │
└─────┘
```
Запрос:
``` sql
SELECT arraySum(x -> x*x, [2, 3]) AS res;
2021-02-05 19:14:52 +00:00
```
Результат:
``` 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 │
└────────────────────────────────────────---──┘
```
2021-05-11 15:07:54 +00:00
## 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 │
└─────┴──────────────────────────────────────────────────────────────────────────────────────────┘
2021-06-17 00:31:38 +00:00
```
## 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] │
└─────────────────────┘
```