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

1633 lines
49 KiB
Markdown
Raw Normal View History

2020-04-03 13:23:32 +00:00
---
toc_priority: 35
2020-06-19 10:11:29 +00:00
toc_title: Arrays
2020-04-03 13:23:32 +00:00
---
# Array Functions {#functions-for-working-with-arrays}
## empty {#function-empty}
Returns 1 for an empty array, or 0 for a non-empty array.
The result type is UInt8.
The function also works for strings.
2021-06-29 13:27:54 +00:00
Can be optimized by enabling the [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns) setting. With `optimize_functions_to_subcolumns = 1` the function reads only [size0](../../sql-reference/data-types/array.md#array-size) subcolumn instead of reading and processing the whole array column. The query `SELECT empty(arr) FROM table` transforms to `SELECT arr.size0 = 0 FROM TABLE`.
2021-06-23 00:15:11 +00:00
## notEmpty {#function-notempty}
Returns 0 for an empty array, or 1 for a non-empty array.
The result type is UInt8.
The function also works for strings.
2021-06-29 13:27:54 +00:00
Can be optimized by enabling the [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns) setting. With `optimize_functions_to_subcolumns = 1` the function reads only [size0](../../sql-reference/data-types/array.md#array-size) subcolumn instead of reading and processing the whole array column. The query `SELECT notEmpty(arr) FROM table` transforms to `SELECT arr.size0 != 0 FROM TABLE`.
2021-06-23 00:15:11 +00:00
## length {#array_functions-length}
Returns the number of items in the array.
The result type is UInt64.
The function also works for strings.
2021-06-29 13:27:54 +00:00
Can be optimized by enabling the [optimize_functions_to_subcolumns](../../operations/settings/settings.md#optimize-functions-to-subcolumns) setting. With `optimize_functions_to_subcolumns = 1` the function reads only [size0](../../sql-reference/data-types/array.md#array-size) subcolumn instead of reading and processing the whole array column. The query `SELECT length(arr) FROM table` transforms to `SELECT arr.size0 FROM TABLE`.
2021-06-23 00:15:11 +00:00
2020-03-20 10:10:48 +00:00
## emptyArrayUInt8, emptyArrayUInt16, emptyArrayUInt32, emptyArrayUInt64 {#emptyarrayuint8-emptyarrayuint16-emptyarrayuint32-emptyarrayuint64}
2020-03-20 10:10:48 +00:00
## emptyArrayInt8, emptyArrayInt16, emptyArrayInt32, emptyArrayInt64 {#emptyarrayint8-emptyarrayint16-emptyarrayint32-emptyarrayint64}
2020-03-20 10:10:48 +00:00
## emptyArrayFloat32, emptyArrayFloat64 {#emptyarrayfloat32-emptyarrayfloat64}
2020-03-20 10:10:48 +00:00
## emptyArrayDate, emptyArrayDateTime {#emptyarraydate-emptyarraydatetime}
2020-03-20 10:10:48 +00:00
## emptyArrayString {#emptyarraystring}
Accepts zero arguments and returns an empty array of the appropriate type.
2020-03-20 10:10:48 +00:00
## emptyArrayToSingle {#emptyarraytosingle}
Accepts an empty array and returns a one-element array that is equal to the default value.
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-18 17:53:52 +00:00
Returns an array of `UInt` numbers from `start` to `end - 1` by `step`.
2021-06-16 23:34:59 +00:00
**Syntax**
``` sql
2021-06-18 17:53:52 +00:00
range([start, ] end [, step])
2021-06-16 23:34:59 +00:00
```
2021-06-18 17:53:52 +00:00
2021-06-16 23:34:59 +00:00
**Arguments**
2021-06-20 12:37:28 +00:00
- `start` — The first element of the array. Optional, required if `step` is used. Default value: 0. [UInt](../data-types/int-uint.md)
2021-06-22 13:43:16 +00:00
- `end` — The number before which the array is constructed. Required. [UInt](../data-types/int-uint.md)
2021-06-20 12:37:28 +00:00
- `step` — Determines the incremental step between each element in the array. Optional. Default value: 1. [UInt](../data-types/int-uint.md)
2021-06-18 17:53:52 +00:00
2021-06-16 23:34:59 +00:00
**Returned value**
2021-06-18 17:53:52 +00:00
- Array of `UInt` numbers from `start` to `end - 1` by `step`.
2021-06-21 10:01:23 +00:00
**Implementation details**
2021-06-21 09:48:24 +00:00
2021-06-21 10:11:42 +00:00
- All arguments must be positive values: `start`, `end`, `step` are `UInt` data types, as well as elements of the returned array.
2021-06-21 09:48:24 +00:00
- An exception is thrown if query results in arrays with a total length of more than 100,000,000 elements.
2021-06-16 23:34:59 +00:00
**Examples**
2021-06-18 17:53:52 +00:00
Query:
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
```
Result:
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
```
2020-03-20 10:10:48 +00:00
## array(x1, …), operator \[x1, …\] {#arrayx1-operator-x1}
Creates an array from the function arguments.
2020-03-20 10:10:48 +00:00
The arguments must be constants and have types that have the smallest common type. At least one argument must be passed, because otherwise it isnt clear which type of array to create. That is, you cant use this function to create an empty array (to do that, use the emptyArray\* function described above).
Returns an Array(T) type result, where T is the smallest common type out of the passed arguments.
2020-03-20 10:10:48 +00:00
## arrayConcat {#arrayconcat}
Combines arrays passed as arguments.
2020-03-20 10:10:48 +00:00
``` sql
arrayConcat(arrays)
```
**Arguments**
- `arrays` Arbitrary number of arguments of [Array](../../sql-reference/data-types/array.md) type.
**Example**
2020-03-20 10:10:48 +00:00
<!-- -->
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
```
2020-03-20 10:10:48 +00:00
``` text
┌─res───────────┐
│ [1,2,3,4,5,6] │
└───────────────┘
```
2020-03-20 10:10:48 +00:00
## arrayElement(arr, n), operator arr\[n\] {#arrayelementarr-n-operator-arrn}
Get the element with the index `n` from the array `arr`. `n` must be any integer type.
Indexes in an array begin from one.
Negative indexes are supported. In this case, it selects the corresponding element numbered from the end. For example, `arr[-1]` is the last item in the array.
If the index falls outside of the bounds of an array, it returns some default value (0 for numbers, an empty string for strings, etc.), except for the case with a non-constant array and a constant index 0 (in this case there will be an error `Array indices are 1-based`).
2020-03-20 10:10:48 +00:00
## has(arr, elem) {#hasarr-elem}
2020-03-20 10:10:48 +00:00
Checks whether the arr array has the elem element.
Returns 0 if the element is not in the array, or 1 if it is.
`NULL` is processed as a value.
2020-03-20 10:10:48 +00:00
``` 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
```
2020-03-20 10:10:48 +00:00
``` text
┌─has([1, 2, NULL], NULL)─┐
│ 1 │
└─────────────────────────┘
```
2020-03-20 10:10:48 +00:00
## hasAll {#hasall}
Checks whether one array is a subset of another.
2020-03-20 10:10:48 +00:00
``` sql
hasAll(set, subset)
```
**Arguments**
- `set` Array of any type with a set of elements.
- `subset` Array of any type with elements that should be tested to be a subset of `set`.
**Return values**
- `1`, if `set` contains all of the elements from `subset`.
- `0`, otherwise.
**Peculiar properties**
- An empty array is a subset of any array.
- `Null` processed as a value.
2021-05-27 19:44:11 +00:00
- Order of values in both of arrays does not matter.
**Examples**
`SELECT hasAll([], [])` returns 1.
`SELECT hasAll([1, Null], [Null])` returns 1.
`SELECT hasAll([1.0, 2, 3, 4], [1, 3])` returns 1.
`SELECT hasAll(['a', 'b'], ['a'])` returns 1.
`SELECT hasAll([1], ['a'])` returns 0.
`SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])` returns 0.
2020-03-20 10:10:48 +00:00
## hasAny {#hasany}
Checks whether two arrays have intersection by some elements.
2020-03-20 10:10:48 +00:00
``` sql
hasAny(array1, array2)
```
**Arguments**
- `array1` Array of any type with a set of elements.
- `array2` Array of any type with a set of elements.
**Return values**
- `1`, if `array1` and `array2` have one similar element at least.
- `0`, otherwise.
**Peculiar properties**
- `Null` processed as a value.
2021-05-27 19:44:11 +00:00
- Order of values in both of arrays does not matter.
**Examples**
`SELECT hasAny([1], [])` returns `0`.
`SELECT hasAny([Null], [Null, 1])` returns `1`.
`SELECT hasAny([-128, 1., 512], [1])` returns `1`.
`SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])` returns `0`.
`SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])` returns `1`.
## hasSubstr {#hassubstr}
Checks whether all the elements of array2 appear in array1 in the same exact order. Therefore, the function will return 1, if and only if `array1 = prefix + array2 + suffix`.
``` sql
hasSubstr(array1, array2)
```
In other words, the functions will check whether all the elements of `array2` are contained in `array1` like
the `hasAll` function. In addition, it will check that the elements are observed in the same order in both `array1` and `array2`.
For Example:
- `hasSubstr([1,2,3,4], [2,3])` returns 1. However, `hasSubstr([1,2,3,4], [3,2])` will return `0`.
- `hasSubstr([1,2,3,4], [1,2,3])` returns 1. However, `hasSubstr([1,2,3,4], [1,2,4])` will return `0`.
**Arguments**
- `array1` Array of any type with a set of elements.
- `array2` Array of any type with a set of elements.
**Return values**
- `1`, if `array1` contains `array2`.
- `0`, otherwise.
**Peculiar properties**
- The function will return `1` if `array2` is empty.
- `Null` processed as a value. In other words `hasSubstr([1, 2, NULL, 3, 4], [2,3])` will return `0`. However, `hasSubstr([1, 2, NULL, 3, 4], [2,NULL,3])` will return `1`
- Order of values in both of arrays does matter.
**Examples**
`SELECT hasSubstr([], [])` returns 1.
`SELECT hasSubstr([1, Null], [Null])` returns 1.
`SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])` returns 0.
`SELECT hasSubstr(['a', 'b'], ['a'])` returns 1.
`SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])` returns 1.
`SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])` returns 0.
`SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])` returns 1.
2020-03-20 10:10:48 +00:00
## indexOf(arr, x) {#indexofarr-x}
2020-03-20 10:10:48 +00:00
Returns the index of the first x element (starting from 1) if it is in the array, or 0 if it is not.
Example:
2020-03-20 10:10:48 +00:00
``` 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
```
2020-03-20 10:10:48 +00:00
``` text
┌─indexOf([1, 3, NULL, NULL], NULL)─┐
│ 3 │
└───────────────────────────────────┘
```
Elements set to `NULL` are handled as normal values.
## arrayCount(\[func,\] arr1, …) {#array-count}
Returns the number of elements in the arr array for which func returns something other than 0. If func is not specified, it returns the number of non-zero elements in the array.
Note that the `arrayCount` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
2020-03-20 10:10:48 +00:00
## countEqual(arr, x) {#countequalarr-x}
2020-03-20 10:10:48 +00:00
Returns the number of elements in the array equal to x. Equivalent to arrayCount (elem -\> elem = x, arr).
`NULL` elements are handled as separate values.
Example:
2020-03-20 10:10:48 +00:00
``` 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
```
2020-03-20 10:10:48 +00:00
``` text
┌─countEqual([1, 2, NULL, NULL], NULL)─┐
│ 2 │
└──────────────────────────────────────┘
```
## arrayEnumerate(arr) {#array_functions-arrayenumerate}
2020-03-20 10:10:48 +00:00
Returns the array \[1, 2, 3, …, length (arr) \]
This function is normally used with ARRAY JOIN. It allows counting something just once for each array after applying ARRAY JOIN. Example:
2020-03-20 10:10:48 +00:00
``` 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
```
2020-03-20 10:10:48 +00:00
``` text
┌─Reaches─┬──Hits─┐
│ 95606 │ 31406 │
└─────────┴───────┘
```
In this example, Reaches is the number of conversions (the strings received after applying ARRAY JOIN), and Hits is the number of pageviews (strings before ARRAY JOIN). In this particular case, you can get the same result in an easier way:
2020-03-20 10:10:48 +00:00
``` sql
SELECT
sum(length(GoalsReached)) AS Reaches,
count() AS Hits
FROM test.hits
WHERE (CounterID = 160656) AND notEmpty(GoalsReached)
```
2020-03-20 10:10:48 +00:00
``` text
┌─Reaches─┬──Hits─┐
│ 95606 │ 31406 │
└─────────┴───────┘
```
This function can also be used in higher-order functions. For example, you can use it to get array indexes for elements that match a condition.
2020-03-20 10:10:48 +00:00
## arrayEnumerateUniq(arr, …) {#arrayenumerateuniqarr}
Returns an array the same size as the source array, indicating for each element what its position is among elements with the same value.
For example: arrayEnumerateUniq(\[10, 20, 10, 30\]) = \[1, 1, 2, 1\].
This function is useful when using ARRAY JOIN and aggregation of array elements.
Example:
2020-03-20 10:10:48 +00:00
``` 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
```
2020-03-20 10:10:48 +00:00
``` 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 │
└─────────┴─────────┴────────┘
```
In this example, each goal ID has a calculation of the number of conversions (each element in the Goals nested data structure is a goal that was reached, which we refer to as a conversion) and the number of sessions. Without ARRAY JOIN, we would have counted the number of sessions as sum(Sign). But in this particular case, the rows were multiplied by the nested Goals structure, so in order to count each session one time after this, we apply a condition to the value of the arrayEnumerateUniq(Goals.ID) function.
The arrayEnumerateUniq function can take multiple arrays of the same size as arguments. In this case, uniqueness is considered for tuples of elements in the same positions in all the arrays.
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]) AS res
```
2020-03-20 10:10:48 +00:00
``` text
┌─res───────────┐
│ [1,2,1,1,2,1] │
└───────────────┘
```
This is necessary when using ARRAY JOIN with a nested data structure and further aggregation across multiple elements in this structure.
2020-03-20 10:10:48 +00:00
## arrayPopBack {#arraypopback}
Removes the last item from the array.
2020-03-20 10:10:48 +00:00
``` sql
arrayPopBack(array)
```
**Arguments**
- `array` Array.
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayPopBack([1, 2, 3]) AS res;
```
2020-03-20 10:10:48 +00:00
``` text
┌─res───┐
│ [1,2] │
└───────┘
```
2020-03-20 10:10:48 +00:00
## arrayPopFront {#arraypopfront}
Removes the first item from the array.
2020-03-20 10:10:48 +00:00
``` sql
arrayPopFront(array)
```
**Arguments**
- `array` Array.
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayPopFront([1, 2, 3]) AS res;
```
2020-03-20 10:10:48 +00:00
``` text
┌─res───┐
│ [2,3] │
└───────┘
```
2020-03-20 10:10:48 +00:00
## arrayPushBack {#arraypushback}
Adds one item to the end of the array.
2020-03-20 10:10:48 +00:00
``` sql
arrayPushBack(array, single_value)
```
**Arguments**
- `array` Array.
- `single_value` A single value. Only numbers can be added to an array with numbers, and only strings can be added to an array of strings. When adding numbers, ClickHouse automatically sets the `single_value` type for the data type of the array. For more information about the types of data in ClickHouse, see “[Data types](../../sql-reference/data-types/index.md#data_types)”. Can be `NULL`. The function adds a `NULL` element to an array, and the type of array elements converts to `Nullable`.
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayPushBack(['a'], 'b') AS res;
```
2020-03-20 10:10:48 +00:00
``` text
┌─res───────┐
│ ['a','b'] │
└───────────┘
```
2020-03-20 10:10:48 +00:00
## arrayPushFront {#arraypushfront}
Adds one element to the beginning of the array.
2020-03-20 10:10:48 +00:00
``` sql
arrayPushFront(array, single_value)
```
**Arguments**
- `array` Array.
- `single_value` A single value. Only numbers can be added to an array with numbers, and only strings can be added to an array of strings. When adding numbers, ClickHouse automatically sets the `single_value` type for the data type of the array. For more information about the types of data in ClickHouse, see “[Data types](../../sql-reference/data-types/index.md#data_types)”. Can be `NULL`. The function adds a `NULL` element to an array, and the type of array elements converts to `Nullable`.
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayPushFront(['b'], 'a') AS res;
```
2020-03-20 10:10:48 +00:00
``` text
┌─res───────┐
│ ['a','b'] │
└───────────┘
```
2020-03-20 10:10:48 +00:00
## arrayResize {#arrayresize}
Changes the length of the array.
2020-03-20 10:10:48 +00:00
``` sql
arrayResize(array, size[, extender])
```
**Arguments:**
- `array` — Array.
- `size` — Required length of the array.
- If `size` is less than the original size of the array, the array is truncated from the right.
- If `size` is larger than the initial size of the array, the array is extended to the right with `extender` values or default values for the data type of the array items.
- `extender` — Value for extending an array. Can be `NULL`.
**Returned value:**
An array of length `size`.
**Examples of calls**
2020-03-20 10:10:48 +00:00
``` 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
```
2020-03-20 10:10:48 +00:00
``` text
┌─arrayResize([1], 3)─┐
│ [1,0,0] │
└─────────────────────┘
```
2020-03-20 10:10:48 +00:00
``` 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
```
2020-03-20 10:10:48 +00:00
``` text
┌─arrayResize([1], 3, NULL)─┐
│ [1,NULL,NULL] │
└───────────────────────────┘
```
2020-03-20 10:10:48 +00:00
## arraySlice {#arrayslice}
Returns a slice of the array.
2020-03-20 10:10:48 +00:00
``` sql
arraySlice(array, offset[, length])
```
**Arguments**
- `array` Array of data.
- `offset` Indent from the edge of the array. A positive value indicates an offset on the left, and a negative value is an indent on the right. Numbering of the array items begins with 1.
- `length` The length of the required slice. If you specify a negative value, the function returns an open slice `[offset, array_length - length)`. If you omit the value, the function returns the slice `[offset, the_end_of_array]`.
**Example**
2020-03-20 10:10:48 +00:00
``` sql
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
```
2020-03-20 10:10:48 +00:00
``` text
┌─res────────┐
│ [2,NULL,4] │
└────────────┘
```
Array elements set to `NULL` are handled as normal values.
## arraySort(\[func,\] arr, …) {#array_functions-sort}
2019-04-19 15:18:57 +00:00
2019-04-23 19:43:20 +00:00
Sorts the elements of the `arr` array in ascending order. If the `func` function is specified, sorting order is determined by the result of the `func` function applied to the elements of the array. If `func` accepts multiple arguments, the `arraySort` function is passed several arrays that the arguments of `func` will correspond to. Detailed examples are shown at the end of `arraySort` description.
2019-04-19 15:18:57 +00:00
2019-04-23 12:56:22 +00:00
Example of integer values sorting:
2019-04-19 15:18:57 +00:00
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 12:56:22 +00:00
SELECT arraySort([1, 3, 3, 0]);
2019-04-19 15:18:57 +00:00
```
2020-03-20 10:10:48 +00:00
``` 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
Example of string values sorting:
2019-04-19 15:55:23 +00:00
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 12:56:22 +00:00
SELECT arraySort(['hello', 'world', '!']);
2019-04-19 15:55:23 +00:00
```
2020-03-20 10:10:48 +00:00
``` text
2019-04-19 15:55:23 +00:00
┌─arraySort(['hello', 'world', '!'])─┐
│ ['!','hello','world'] │
└────────────────────────────────────┘
```
2019-04-23 12:56:22 +00:00
Consider the following sorting order for the `NULL`, `NaN` and `Inf` values:
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 12:56:22 +00:00
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
```
2020-03-20 10:10:48 +00:00
``` 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` values are first in the array.
- `NULL` values are last in the array.
- `NaN` values are right before `NULL`.
- `Inf` values are right before `NaN`.
2019-04-23 12:56:22 +00:00
Note that `arraySort` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument. In this case, sorting order is determined by the result of the lambda function applied to the elements of the array.
2019-04-23 19:54:32 +00:00
2020-03-20 10:10:48 +00:00
Lets consider the following example:
2019-04-23 12:56:22 +00:00
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 19:43:20 +00:00
SELECT arraySort((x) -> -x, [1, 2, 3]) as res;
```
2020-03-20 10:10:48 +00:00
``` text
2019-04-23 19:43:20 +00:00
┌─res─────┐
│ [3,2,1] │
└─────────┘
```
2020-03-20 10:10:48 +00:00
For each element of the source array, the lambda function returns the sorting key, that is, \[1 \> -1, 2 \> -2, 3 \> -3\]. Since the `arraySort` function sorts the keys in ascending order, the result is \[3, 2, 1\]. Thus, the `(x) > -x` lambda function sets the [descending order](#array_functions-reverse-sort) in a sorting.
2019-04-23 19:43:20 +00:00
2019-04-24 21:08:49 +00:00
The lambda function can accept multiple arguments. In this case, you need to pass the `arraySort` function several arrays of identical length that the arguments of lambda function will correspond to. The resulting array will consist of elements from the first input array; elements from the next input array(s) specify the sorting keys. For example:
2019-04-23 19:43:20 +00:00
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 19:43:20 +00:00
SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
2019-04-23 12:56:22 +00:00
```
2020-03-20 10:10:48 +00:00
``` text
2019-04-23 12:56:22 +00:00
┌─res────────────────┐
│ ['world', 'hello'] │
└────────────────────┘
```
2021-05-27 19:44:11 +00:00
Here, the elements that are passed in the second array (\[2, 1\]) define a sorting key for the corresponding element from the source array (\[hello, world\]), that is, \[hello \> 2, world \> 1\]. Since the lambda function does not use `x`, actual values of the source array do not affect the order in the result. So, hello will be the second element in the result, and world will be the first.
2019-04-23 12:56:22 +00:00
2019-04-24 21:08:49 +00:00
Other examples are shown below.
2019-04-23 12:56:22 +00:00
2020-03-20 10:10:48 +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-19 15:18:57 +00:00
```
2020-03-20 10:10:48 +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
└─────────┘
2019-04-19 15:18:57 +00:00
```
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 19:54:32 +00:00
SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res;
```
2020-03-20 10:10:48 +00:00
``` text
2019-04-23 19:54:32 +00:00
┌─res─────┐
│ [2,1,0] │
└─────────┘
```
2020-03-20 10:10:48 +00:00
!!! note "Note"
2019-04-23 19:43:20 +00:00
To improve sorting efficiency, the [Schwartzian transform](https://en.wikipedia.org/wiki/Schwartzian_transform) is used.
2019-04-19 15:55:23 +00:00
## arrayReverseSort(\[func,\] arr, …) {#array_functions-reverse-sort}
2019-04-19 15:55:23 +00:00
2019-04-23 19:43:20 +00:00
Sorts the elements of the `arr` array in descending order. If the `func` function is specified, `arr` is sorted according to the result of the `func` function applied to the elements of the array, and then the sorted array is reversed. If `func` accepts multiple arguments, the `arrayReverseSort` function is passed several arrays that the arguments of `func` will correspond to. Detailed examples are shown at the end of `arrayReverseSort` description.
2019-04-23 12:56:22 +00:00
Example of integer values sorting:
2019-04-19 15:18:57 +00:00
2020-03-20 10:10:48 +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
```
2020-03-20 10:10:48 +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
Example of string values sorting:
2019-04-19 16:04:45 +00:00
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 12:56:22 +00:00
SELECT arrayReverseSort(['hello', 'world', '!']);
2019-04-19 15:55:23 +00:00
```
2020-03-20 10:10:48 +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
Consider the following sorting order for the `NULL`, `NaN` and `Inf` values:
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 12:56:22 +00:00
SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
```
2020-03-20 10:10:48 +00:00
``` text
2019-04-23 12:56:22 +00:00
┌─res───────────────────────────────────┐
│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────┘
2019-04-19 15:18:57 +00:00
```
2019-04-23 12:56:22 +00:00
- `Inf` values are first in the array.
- `NULL` values are last in the array.
- `NaN` values are right before `NULL`.
- `-Inf` values are right before `NaN`.
2019-04-23 12:56:22 +00:00
Note that the `arrayReverseSort` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument. Example is shown below.
2019-04-23 19:43:20 +00:00
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 19:43:20 +00:00
SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
```
2020-03-20 10:10:48 +00:00
``` text
2019-04-23 19:43:20 +00:00
┌─res─────┐
│ [1,2,3] │
└─────────┘
```
The array is sorted in the following way:
2020-03-20 10:10:48 +00:00
1. At first, the source array (\[1, 2, 3\]) is sorted according to the result of the lambda function applied to the elements of the array. The result is an array \[3, 2, 1\].
2. Array that is obtained on the previous step, is reversed. So, the final result is \[1, 2, 3\].
2019-04-24 21:08:49 +00:00
The lambda function can accept multiple arguments. In this case, you need to pass the `arrayReverseSort` function several arrays of identical length that the arguments of lambda function will correspond to. The resulting array will consist of elements from the first input array; elements from the next input array(s) specify the sorting keys. For example:
2019-04-23 12:56:22 +00:00
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 19:43:20 +00:00
SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
2019-04-19 15:18:57 +00:00
```
2020-03-20 10:10:48 +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 19:43:20 +00:00
In this example, the array is sorted in the following way:
2019-04-23 12:56:22 +00:00
2020-03-20 10:10:48 +00:00
1. At first, the source array (\[hello, world\]) is sorted according to the result of the lambda function applied to the elements of the arrays. The elements that are passed in the second array (\[2, 1\]), define the sorting keys for corresponding elements from the source array. The result is an array \[world, hello\].
2. Array that was sorted on the previous step, is reversed. So, the final result is \[hello, world\].
Other examples are shown below.
2019-04-23 12:56:22 +00:00
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 19:43:20 +00:00
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
2019-04-23 12:56:22 +00:00
```
2020-03-20 10:10:48 +00:00
``` text
2019-04-23 12:56:22 +00:00
┌─res─────┐
2019-04-23 19:43:20 +00:00
│ [5,3,4] │
2019-04-23 12:56:22 +00:00
└─────────┘
```
2020-03-20 10:10:48 +00:00
``` sql
2019-04-23 19:54:32 +00:00
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
```
2020-03-20 10:10:48 +00:00
``` text
2019-04-23 19:54:32 +00:00
┌─res─────┐
│ [4,3,5] │
└─────────┘
```
2019-04-19 15:18:57 +00:00
2020-03-20 10:10:48 +00:00
## arrayUniq(arr, …) {#arrayuniqarr}
If one argument is passed, it counts the number of different elements in the array.
If multiple arguments are passed, it counts the number of different tuples of elements at corresponding positions in multiple arrays.
2020-03-20 10:10:48 +00:00
If you want to get a list of unique items in an array, you can use arrayReduce(groupUniqArray, arr).
## arrayJoin(arr) {#array-functions-join}
A special function. See the section [“ArrayJoin function”](../../sql-reference/functions/array-join.md#functions_arrayjoin).
## arrayDifference {#arraydifference}
2020-03-20 10:10:48 +00:00
Calculates the difference between adjacent array elements. Returns an array where the first element will be 0, the second is the difference between `a[1] - a[0]`, etc. The type of elements in the resulting array is determined by the type inference rules for subtraction (e.g. `UInt8` - `UInt8` = `Int16`).
2020-03-20 10:10:48 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
arrayDifference(array)
```
**Arguments**
- `array` [Array](https://clickhouse.tech/docs/en/data_types/array/).
**Returned values**
Returns an array of differences between adjacent elements.
Type: [UInt\*](https://clickhouse.tech/docs/en/data_types/int_uint/#uint-ranges), [Int\*](https://clickhouse.tech/docs/en/data_types/int_uint/#int-ranges), [Float\*](https://clickhouse.tech/docs/en/data_types/float/).
**Example**
Query:
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayDifference([1, 2, 3, 4]);
```
Result:
2020-03-20 10:10:48 +00:00
``` text
┌─arrayDifference([1, 2, 3, 4])─┐
│ [0,1,1,1] │
└───────────────────────────────┘
```
Example of the overflow due to result type Int64:
Query:
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayDifference([0, 10000000000000000000]);
```
Result:
2020-03-20 10:10:48 +00:00
``` text
┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616] │
└────────────────────────────────────────────┘
```
## arrayDistinct {#arraydistinct}
Takes an array, returns an array containing the distinct elements only.
2020-03-20 10:10:48 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
arrayDistinct(array)
```
**Arguments**
- `array` [Array](https://clickhouse.tech/docs/en/data_types/array/).
**Returned values**
2020-02-02 22:39:00 +00:00
Returns an array containing the distinct elements.
**Example**
Query:
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayDistinct([1, 2, 2, 3, 1]);
```
Result:
2020-03-20 10:10:48 +00:00
``` text
┌─arrayDistinct([1, 2, 2, 3, 1])─┐
│ [1,2,3] │
└────────────────────────────────┘
```
## arrayEnumerateDense(arr) {#array_functions-arrayenumeratedense}
2019-11-25 11:30:38 +00:00
Returns an array of the same size as the source array, indicating where each element first appears in the source array.
Example:
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayEnumerateDense([10, 20, 10, 30])
```
2020-03-20 10:10:48 +00:00
``` text
┌─arrayEnumerateDense([10, 20, 10, 30])─┐
│ [1,2,1,3] │
└───────────────────────────────────────┘
```
## arrayIntersect(arr) {#array-functions-arrayintersect}
Takes multiple arrays, returns an array with elements that are present in all source arrays. Elements order in the resulting array is the same as in the first array.
Example:
2020-03-20 10:10:48 +00:00
``` sql
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS no_intersect,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS intersect
```
2020-03-20 10:10:48 +00:00
``` text
┌─no_intersect─┬─intersect─┐
│ [] │ [1] │
└──────────────┴───────────┘
```
2020-03-11 02:56:36 +00:00
## arrayReduce {#arrayreduce}
Applies an aggregate function to array elements and returns its result. The name of the aggregation function is passed as a string in single quotes `'max'`, `'sum'`. When using parametric aggregate functions, the parameter is indicated after the function name in parentheses `'uniqUpTo(6)'`.
2020-03-11 02:56:36 +00:00
**Syntax**
``` sql
2020-03-11 02:56:36 +00:00
arrayReduce(agg_func, arr1, arr2, ..., arrN)
```
**Arguments**
2020-03-11 02:56:36 +00:00
- `agg_func` — The name of an aggregate function which should be a constant [string](../../sql-reference/data-types/string.md).
- `arr` — Any number of [array](../../sql-reference/data-types/array.md) type columns as the parameters of the aggregation function.
2020-03-11 02:56:36 +00:00
**Returned value**
**Example**
Query:
``` sql
SELECT arrayReduce('max', [1, 2, 3]);
```
Result:
``` text
┌─arrayReduce('max', [1, 2, 3])─┐
│ 3 │
└───────────────────────────────┘
```
If an aggregate function takes multiple arguments, then this function must be applied to multiple arrays of the same size.
Query:
``` sql
SELECT arrayReduce('maxIf', [3, 5], [1, 0]);
```
Result:
``` text
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│ 3 │
└──────────────────────────────────────┘
```
Example with a parametric aggregate function:
Query:
``` sql
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
```
Result:
``` text
┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│ 4 │
└─────────────────────────────────────────────────────────────┘
```
2020-03-11 02:56:36 +00:00
## arrayReduceInRanges {#arrayreduceinranges}
Applies an aggregate function to array elements in given ranges and returns an array containing the result corresponding to each range. The function will return the same result as multiple `arrayReduce(agg_func, arraySlice(arr1, index, length), ...)`.
**Syntax**
``` sql
2020-03-11 02:56:36 +00:00
arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN)
```
**Arguments**
2020-03-11 02:56:36 +00:00
- `agg_func` — The name of an aggregate function which should be a constant [string](../../sql-reference/data-types/string.md).
- `ranges` — The ranges to aggretate which should be an [array](../../sql-reference/data-types/array.md) of [tuples](../../sql-reference/data-types/tuple.md) which containing the index and the length of each range.
- `arr` — Any number of [Array](../../sql-reference/data-types/array.md) type columns as the parameters of the aggregation function.
2020-03-11 02:56:36 +00:00
**Returned value**
- Array containing results of the aggregate function over specified ranges.
Type: [Array](../../sql-reference/data-types/array.md).
2020-03-11 02:56:36 +00:00
**Example**
Query:
``` sql
2020-03-11 02:56:36 +00:00
SELECT arrayReduceInRanges(
'sum',
[(1, 5), (2, 3), (3, 4), (4, 4)],
[1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
```
Result:
``` text
2020-03-11 02:56:36 +00:00
┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘
```
## arrayReverse(arr) {#arrayreverse}
Returns an array of the same size as the original array containing the elements in reverse order.
Example:
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayReverse([1, 2, 3])
```
2020-03-20 10:10:48 +00:00
``` 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
Synonym for [“arrayReverse”](#arrayreverse)
## arrayFlatten {#arrayflatten}
2019-12-24 14:35:17 +00:00
Converts an array of arrays to a flat array.
Function:
- Applies to any depth of nested arrays.
- Does not change arrays that are already flat.
The flattened array contains all the elements from all source arrays.
2019-12-11 14:15:43 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
flatten(array_of_arrays)
```
Alias: `flatten`.
**Arguments**
- `array_of_arrays` — [Array](../../sql-reference/data-types/array.md) of arrays. For example, `[[1,2,3], [4,5]]`.
**Examples**
2020-03-20 10:10:48 +00:00
``` sql
SELECT flatten([[[1]], [[2], [3]]]);
```
2020-03-20 10:10:48 +00:00
``` text
┌─flatten(array(array([1]), array([2], [3])))─┐
│ [1,2,3] │
└─────────────────────────────────────────────┘
```
2019-11-26 12:46:18 +00:00
## arrayCompact {#arraycompact}
2019-10-22 02:23:07 +00:00
2019-11-26 12:46:18 +00:00
Removes consecutive duplicate elements from an array. The order of result values is determined by the order in the source array.
2019-10-22 02:23:07 +00:00
2019-11-25 11:30:38 +00:00
**Syntax**
2019-10-22 02:23:07 +00:00
2020-03-20 10:10:48 +00:00
``` sql
arrayCompact(arr)
2019-10-22 02:23:07 +00:00
```
**Arguments**
2019-11-25 11:30:38 +00:00
`arr` — The [array](../../sql-reference/data-types/array.md) to inspect.
2019-11-25 11:30:38 +00:00
**Returned value**
2019-11-26 12:46:18 +00:00
The array without duplicate.
Type: `Array`.
2019-11-25 11:30:38 +00:00
**Example**
Query:
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
2019-11-25 11:30:38 +00:00
```
Result:
2020-03-20 10:10:48 +00:00
``` text
2019-11-25 11:30:38 +00:00
┌─arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])─┐
│ [1,nan,nan,2,3] │
└────────────────────────────────────────────┘
2019-10-22 02:23:07 +00:00
```
2019-12-11 14:15:43 +00:00
## arrayZip {#arrayzip}
Combines multiple arrays into a single array. The resulting array contains the corresponding elements of the source arrays grouped into tuples in the listed order of arguments.
2019-12-11 14:15:43 +00:00
**Syntax**
2020-03-20 10:10:48 +00:00
``` sql
2019-12-11 14:15:43 +00:00
arrayZip(arr1, arr2, ..., arrN)
```
**Arguments**
2019-12-11 14:15:43 +00:00
- `arrN` — [Array](../../sql-reference/data-types/array.md).
The function can take any number of arrays of different types. All the input arrays must be of equal size.
2019-12-11 14:15:43 +00:00
**Returned value**
- Array with elements from the source arrays grouped into [tuples](../../sql-reference/data-types/tuple.md). Data types in the tuple are the same as types of the input arrays and in the same order as arrays are passed.
Type: [Array](../../sql-reference/data-types/array.md).
2019-12-11 14:15:43 +00:00
**Example**
Query:
2020-03-20 10:10:48 +00:00
``` sql
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
2019-12-11 14:15:43 +00:00
```
Result:
2020-03-20 10:10:48 +00:00
``` text
┌─arrayZip(['a', 'b', 'c'], [5, 2, 1])─┐
│ [('a',5),('b',2),('c',1)] │
└──────────────────────────────────────┘
2019-12-11 14:15:43 +00:00
```
2020-03-23 04:44:49 +00:00
2020-02-08 06:31:03 +00:00
## arrayAUC {#arrayauc}
2020-10-13 17:23:29 +00:00
Calculate AUC (Area Under the Curve, which is a concept in machine learning, see more details: https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve).
2020-01-17 13:52:02 +00:00
2020-02-08 06:31:03 +00:00
**Syntax**
``` sql
2020-02-08 06:31:03 +00:00
arrayAUC(arr_scores, arr_labels)
```
**Arguments**
- `arr_scores` — scores prediction model gives.
- `arr_labels` — labels of samples, usually 1 for positive sample and 0 for negtive sample.
2020-01-17 13:52:02 +00:00
2020-02-08 06:31:03 +00:00
**Returned value**
2020-03-23 04:44:49 +00:00
Returns AUC value with type Float64.
2020-01-17 13:52:02 +00:00
2020-02-08 06:31:03 +00:00
**Example**
2020-02-08 06:31:03 +00:00
Query:
``` sql
select arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
2020-02-08 06:31:03 +00:00
```
Result:
``` text
2020-02-08 06:31:03 +00:00
┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│ 0.75 │
└───────────────────────────────────────────────┘
```
## arrayMap(func, arr1, …) {#array-map}
Returns an array obtained from the original application of the `func` function to each element in the `arr` array.
Examples:
``` sql
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
```
``` text
┌─res─────┐
│ [3,4,5] │
└─────────┘
```
The following example shows how to create a tuple of elements from different arrays:
``` sql
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
```
``` text
┌─res─────────────────┐
│ [(1,4),(2,5),(3,6)] │
└─────────────────────┘
```
Note that the `arrayMap` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it cant be omitted.
## arrayFilter(func, arr1, …) {#array-filter}
Returns an array containing only the elements in `arr1` for which `func` returns something other than 0.
Examples:
``` 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] │
└─────┘
```
Note that the `arrayFilter` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it cant be omitted.
## arrayFill(func, arr1, …) {#array-fill}
Scan through `arr1` from the first element to the last element and replace `arr1[i]` by `arr1[i - 1]` if `func` returns 0. The first element of `arr1` will not be replaced.
Examples:
``` 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] │
└──────────────────────────────────┘
```
Note that the `arrayFill` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it cant be omitted.
## arrayReverseFill(func, arr1, …) {#array-reverse-fill}
Scan through `arr1` from the last element to the first element and replace `arr1[i]` by `arr1[i + 1]` if `func` returns 0. The last element of `arr1` will not be replaced.
Examples:
``` 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] │
└────────────────────────────────────┘
```
Note that the `arrayReverseFill` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it cant be omitted.
## arraySplit(func, arr1, …) {#array-split}
Split `arr1` into multiple arrays. When `func` returns something other than 0, the array will be split on the left hand side of the element. The array will not be split before the first element.
Examples:
``` 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]] │
└─────────────────┘
```
Note that the `arraySplit` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it cant be omitted.
## arrayReverseSplit(func, arr1, …) {#array-reverse-split}
Split `arr1` into multiple arrays. When `func` returns something other than 0, the array will be split on the right hand side of the element. The array will not be split after the last element.
Examples:
``` 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]] │
└───────────────────┘
```
Note that the `arrayReverseSplit` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it cant be omitted.
## arrayExists(\[func,\] arr1, …) {#arrayexistsfunc-arr1}
Returns 1 if there is at least one element in `arr` for which `func` returns something other than 0. Otherwise, it returns 0.
Note that the `arrayExists` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
## arrayAll(\[func,\] arr1, …) {#arrayallfunc-arr1}
Returns 1 if `func` returns something other than 0 for all the elements in `arr`. Otherwise, it returns 0.
Note that the `arrayAll` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
## arrayFirst(func, arr1, …) {#array-first}
Returns the first element in the `arr1` array for which `func` returns something other than 0.
Note that the `arrayFirst` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it cant be omitted.
## arrayFirstIndex(func, arr1, …) {#array-first-index}
Returns the index of the first element in the `arr1` array for which `func` returns something other than 0.
Note that the `arrayFirstIndex` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it cant be omitted.
2021-01-28 22:54:21 +00:00
## arrayMin {#array-min}
Returns the minimum of elements in the source array.
2021-01-28 22:54:21 +00:00
2021-01-29 02:08:22 +00:00
If the `func` function is specified, returns the mininum of elements converted by this function.
Note that the `arrayMin` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
2021-01-28 22:54:21 +00:00
**Syntax**
2021-01-07 12:57:39 +00:00
```sql
2021-01-29 02:41:03 +00:00
arrayMin([func,] arr)
2021-01-28 22:54:21 +00:00
```
**Arguments**
2021-01-28 22:54:21 +00:00
- `func` — Function. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — Array. [Array](../../sql-reference/data-types/array.md).
**Returned value**
- The minimum of function values (or the array minimum).
2021-01-28 22:54:21 +00:00
Type: if `func` is specified, matches `func` return value type, else matches the array elements type.
2021-01-28 22:54:21 +00:00
**Examples**
Query:
```sql
SELECT arrayMin([1, 2, 4]) AS res;
```
Result:
```text
2021-01-07 12:57:39 +00:00
┌─res─┐
│ 1 │
└─────┘
2021-01-28 22:54:21 +00:00
```
2021-01-07 12:57:39 +00:00
2021-01-28 22:54:21 +00:00
Query:
2021-01-07 12:57:39 +00:00
2021-01-29 07:19:01 +00:00
```sql
2021-01-28 22:54:21 +00:00
SELECT arrayMin(x -> (-x), [1, 2, 4]) AS res;
```
Result:
```text
2021-01-07 12:57:39 +00:00
┌─res─┐
│ -4 │
└─────┘
```
2021-01-28 22:54:21 +00:00
## arrayMax {#array-max}
Returns the maximum of elements in the source array.
2021-01-28 22:54:21 +00:00
If the `func` function is specified, returns the maximum of elements converted by this function.
Note that the `arrayMax` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
2021-01-28 22:54:21 +00:00
**Syntax**
```sql
arrayMax([func,] arr)
```
**Arguments**
2021-01-28 22:54:21 +00:00
- `func` — Function. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — Array. [Array](../../sql-reference/data-types/array.md).
**Returned value**
- The maximum of function values (or the array maximum).
2021-01-28 22:54:21 +00:00
Type: if `func` is specified, matches `func` return value type, else matches the array elements type.
2021-01-28 22:54:21 +00:00
**Examples**
Query:
2021-01-07 12:57:39 +00:00
```sql
2021-01-28 22:54:21 +00:00
SELECT arrayMax([1, 2, 4]) AS res;
```
2021-01-29 02:08:22 +00:00
2021-01-28 22:54:21 +00:00
Result:
```text
2021-01-07 12:57:39 +00:00
┌─res─┐
│ 4 │
└─────┘
2021-01-28 22:54:21 +00:00
```
2021-01-07 12:57:39 +00:00
2021-01-28 22:54:21 +00:00
Query:
2021-01-07 12:57:39 +00:00
2021-01-28 22:54:21 +00:00
```sql
SELECT arrayMax(x -> (-x), [1, 2, 4]) AS res;
```
Result:
```text
2021-01-07 12:57:39 +00:00
┌─res─┐
│ -1 │
└─────┘
```
2021-01-28 22:54:21 +00:00
## arraySum {#array-sum}
Returns the sum of elements in the source array.
2021-01-28 22:54:21 +00:00
If the `func` function is specified, returns the sum of elements converted by this function.
Note that the `arraySum` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
2021-01-28 22:54:21 +00:00
**Syntax**
2021-01-07 12:57:39 +00:00
```sql
2021-01-29 02:41:03 +00:00
arraySum([func,] arr)
2021-01-28 22:54:21 +00:00
```
**Arguments**
2021-01-28 22:54:21 +00:00
- `func` — Function. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — Array. [Array](../../sql-reference/data-types/array.md).
2021-01-28 22:54:21 +00:00
**Returned value**
- The sum of the function values (or the array sum).
2021-02-06 13:37:12 +00:00
Type: for decimal numbers in source array (or for converted values, if `func` is specified) — [Decimal128](../../sql-reference/data-types/decimal.md), for floating point numbers — [Float64](../../sql-reference/data-types/float.md), for numeric unsigned — [UInt64](../../sql-reference/data-types/int-uint.md), and for numeric signed — [Int64](../../sql-reference/data-types/int-uint.md).
2021-01-28 22:54:21 +00:00
**Examples**
Query:
```sql
2021-01-29 02:41:03 +00:00
SELECT arraySum([2, 3]) AS res;
2021-01-28 22:54:21 +00:00
```
Result:
```text
2021-01-07 12:57:39 +00:00
┌─res─┐
│ 5 │
└─────┘
2021-01-28 22:54:21 +00:00
```
2021-01-07 12:57:39 +00:00
2021-01-28 22:54:21 +00:00
Query:
```sql
SELECT arraySum(x -> x*x, [2, 3]) AS res;
```
2021-01-07 12:57:39 +00:00
2021-01-28 22:54:21 +00:00
Result:
```text
2021-01-07 12:57:39 +00:00
┌─res─┐
│ 13 │
└─────┘
```
2021-01-28 22:54:21 +00:00
## arrayAvg {#array-avg}
2021-01-07 12:57:39 +00:00
Returns the average of elements in the source array.
2021-01-28 22:54:21 +00:00
If the `func` function is specified, returns the average of elements converted by this function.
Note that the `arrayAvg` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
2021-01-28 22:54:21 +00:00
**Syntax**
```sql
arrayAvg([func,] arr)
```
**Arguments**
2021-01-28 22:54:21 +00:00
- `func` — Function. [Expression](../../sql-reference/data-types/special-data-types/expression.md).
- `arr` — Array. [Array](../../sql-reference/data-types/array.md).
2021-01-28 22:54:21 +00:00
**Returned value**
2021-01-29 02:08:22 +00:00
- The average of function values (or the array average).
2021-01-28 22:54:21 +00:00
Type: [Float64](../../sql-reference/data-types/float.md).
**Examples**
Query:
```sql
SELECT arrayAvg([1, 2, 4]) AS res;
```
Result:
```text
┌────────────────res─┐
│ 2.3333333333333335 │
└────────────────────┘
```
Query:
```sql
SELECT arrayAvg(x -> (x * x), [2, 4]) AS res;
```
Result:
```text
┌─res─┐
│ 10 │
└─────┘
```
## arrayCumSum(\[func,\] arr1, …) {#arraycumsumfunc-arr1}
Returns an array of partial sums of elements in the source array (a running sum). If the `func` function is specified, then the values of the array elements are converted by this function before summing.
Example:
``` sql
SELECT arrayCumSum([1, 1, 1, 1]) AS res
```
``` text
┌─res──────────┐
│ [1, 2, 3, 4] │
└──────────────┘
```
Note that the `arrayCumSum` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
## arrayCumSumNonNegative(arr) {#arraycumsumnonnegativearr}
Same as `arrayCumSum`, returns an array of partial sums of elements in the source array (a running sum). Different `arrayCumSum`, when then returned value contains a value less than zero, the value is replace with zero and the subsequent calculation is performed with zero parameters. For example:
``` sql
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
```
``` text
┌─res───────┐
│ [1,2,0,1] │
└───────────┘
2020-02-08 06:31:03 +00:00
```
Note that the `arraySumNonNegative` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
2019-12-11 14:15:43 +00:00
2021-05-09 23:25:54 +00:00
## arrayProduct {#arrayproduct}
Multiplies elements of an [array](../../sql-reference/data-types/array.md).
2021-05-09 23:25:54 +00:00
**Syntax**
``` sql
arrayProduct(arr)
```
**Arguments**
- `arr` — [Array](../../sql-reference/data-types/array.md) of numeric values.
2021-05-09 23:25:54 +00:00
**Returned value**
- A product of array's elements.
2021-05-09 23:25:54 +00:00
Type: [Float64](../../sql-reference/data-types/float.md).
**Examples**
Query:
``` sql
SELECT arrayProduct([1,2,3,4,5,6]) as res;
```
Result:
``` text
┌─res───┐
│ 720 │
└───────┘
```
Query:
``` sql
2021-05-11 14:56:57 +00:00
SELECT arrayProduct([toDecimal64(1,8), toDecimal64(2,8), toDecimal64(3,8)]) as res, toTypeName(res);
2021-05-09 23:25:54 +00:00
```
Return value type is always [Float64](../../sql-reference/data-types/float.md). Result:
``` text
2021-05-11 14:56:57 +00:00
┌─res─┬─toTypeName(arrayProduct(array(toDecimal64(1, 8), toDecimal64(2, 8), toDecimal64(3, 8))))─┐
│ 6 │ Float64 │
└─────┴──────────────────────────────────────────────────────────────────────────────────────────┘
```