> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> 배열 함수에 대한 문서
# 배열 함수
{/*AUTOGENERATED_START*/}
## array
도입 버전: v1.1.0
함수 인수로 배열을 생성합니다.
인수는 상수여야 하며, 서로 공통 상위 타입(common supertype)을 가져야 합니다.
그렇지 않으면 생성할 배열의 타입을 결정할 수 없으므로, 최소 1개의 인수를 전달해야 합니다.
즉, 이 함수로는 빈 배열을 생성할 수 없습니다. 빈 배열을 생성하려면 `emptyArray*` 함수를 사용하십시오.
동일한 기능에는 `[ ]` 연산자를 사용하십시오.
**구문**
```sql theme={null}
array(x1 [, x2, ..., xN])
```
**인수**
* `x1` — 임의의 타입 T를 갖는 상수 값입니다. 이 인수만 제공되면 배열 타입은 T가 됩니다. - `[, x2, ..., xN]` — `x1`과 공통 상위 타입을 갖는 추가 N개의 상수 값
**반환 값**
전달된 인수들 가운데 가장 작은 공통 타입이 'T'인 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**올바른 사용**
```sql title=Query theme={null}
SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)
```
```response title=Response theme={null}
┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32) │
└─────────┴───────────────┘
```
**잘못된 사용법**
```sql title=Query theme={null}
SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)
```
```response title=Response theme={null}
Received exception from server (version 25.4.3):
Code: 386. DB::Exception: Received from localhost:9000. DB::Exception:
There is no supertype for types Int32, DateTime, Int8 ...
```
## arrayAUCPR
도입 버전: v20.4.0
정밀도-재현율(PR) 곡선 아래 면적을 계산합니다.
정밀도-재현율 곡선은 모든 임계값에 대해 y축에 정밀도를, x축에 재현율을 표시하여 만듭니다.
결과값은 0에서 1 사이이며, 값이 높을수록 모델 성능이 더 우수함을 의미합니다.
PR AUC는 특히 불균형한 데이터셋에서 유용하며, 이런 경우 ROC AUC보다 성능을 더 명확하게 비교할 수 있게 해줍니다.
자세한 내용은 [여기](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve), [여기](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1), [여기](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve)를 참조하십시오.
**구문**
```sql theme={null}
arrayAUCPR(scores, labels[, partial_offsets])
```
**별칭**: `arrayPRAUC`
**인수**
* `cores` — 예측 모델이 출력한 점수입니다. [`Array((U)Int*)`](/ko/reference/data-types/array) 또는 [`Array(Float*)`](/ko/reference/data-types/array)
* `labels` — 샘플의 레이블이며, 일반적으로 양성 샘플은 1, 음성 샘플은 0입니다. [`Array((U)Int*)`](/ko/reference/data-types/array) 또는 [`Array(Enum)`](/ko/reference/data-types/array)
* `partial_offsets` —
* 선택 사항입니다. 전체 AUC 대신 PR 곡선 아래의 부분 면적(PR 공간의 수직 밴드에 해당)을 계산하기 위한, 음수가 아닌 정수 3개로 이루어진 [`Array(T)`](/ko/reference/data-types/array)입니다. 이 옵션은 PR AUC를 분산 계산할 때 유용합니다. 배열에는 다음 요소가 포함되어야 합니다 \[`higher_partitions_tp`, `higher_partitions_fp`, `total_positives`].
* `higher_partitions_tp`: 더 높은 점수 구간의 파티션에 있는 양성 레이블 수입니다.
* `higher_partitions_fp`: 더 높은 점수 구간의 파티션에 있는 음성 레이블 수입니다.
* `total_positives`: 전체 데이터셋의 총 양성 샘플 수입니다.
`arr_partial_offsets`를 사용하는 경우 `arr_scores`와 `arr_labels`에는 전체 데이터셋이 아니라 점수의 특정 인터벌에 해당하는 파티션만 포함되어야 합니다.
데이터셋은 연속된 파티션으로 나뉘어야 하며, 각 파티션에는 점수가 특정 범위에 속하는 데이터 하위 집합이 포함되어야 합니다.
예를 들면 다음과 같습니다.
* 한 파티션에는 \[0, 0.5) 범위의 모든 점수가 포함될 수 있습니다.
* 다른 파티션에는 \[0.5, 1.0] 범위의 점수가 포함될 수 있습니다.
**반환 값**
정밀도-재현율(PR) 곡선 아래 면적을 반환합니다. [`Float64`](/ko/reference/data-types/float)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│ 0.8333333333333333 │
└─────────────────────────────────────────────────┘
```
## arrayAll
도입 버전: v1.1.0
모든 요소에 대해 람다 `func(x [, y1, y2, ... yN])`의 반환값이 true이면 `1`을 반환합니다. 그렇지 않으면 `0`을 반환합니다.
**구문**
```sql theme={null}
arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 대해 동작하는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `cond1_arr, ...` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
모든 요소에서 람다 함수가 true를 반환하면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**모든 요소가 일치하는 경우**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])
```
```response title=Response theme={null}
1
```
**일치하지 않는 요소가 있습니다**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])
```
```response title=Response theme={null}
0
```
## arrayAutocorrelation
도입 버전: v26.4.0
배열의 자기상관을 계산합니다.
`max_lag`가 지정되면 `[0, max_lag)` 범위의 지연값에 대해서만 상관관계를 계산합니다.
`max_lag`가 지정되지 않으면 가능한 모든 지연값에 대해 계산합니다.
**구문**
```sql theme={null}
arrayAutocorrelation(arr, [max_lag])
```
**인수**
* `arr` — 숫자 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `max_lag` — 선택 사항입니다. 계산할 최대 시차 수입니다. 음이 아닌 정수여야 합니다. [`Integer`](/ko/reference/data-types/int-uint)
**반환 값**
`Float64` 배열을 반환합니다. 분산이 0이면 NaN을 반환합니다. [`Array(Float64)`](/ko/reference/data-types/array)
**예시**
**선형**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);
```
```response title=Response theme={null}
[1, 0.4, -0.1, -0.4, -0.4]
```
**대칭**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([10, 20, 10]);
```
```response title=Response theme={null}
[1, -0.6666666666666669, 0.16666666666666674]
```
**상수**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([5, 5, 5]);
```
```response title=Response theme={null}
[nan, nan, nan]
```
**제한됨**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);
```
```response title=Response theme={null}
[1, 0.4]
```
## arrayAvg
도입 버전: v21.1.0
소스 배열의 요소 평균을 반환합니다.
람다 함수 `func`가 지정되면 람다 함수 결과 요소의 평균을 반환합니다.
**구문**
```sql theme={null}
arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 선택 사항입니다. 소스 배열(`x`)과 조건 배열(`y`)의 요소에 대해 동작하는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열 요소의 평균을 반환합니다. 람다 결과가 제공되면 그 결과 요소의 평균을 반환합니다. [`Float64`](/ko/reference/data-types/float)
**예시**
**기본 예시**
```sql title=Query theme={null}
SELECT arrayAvg([1, 2, 3, 4]);
```
```response title=Response theme={null}
2.5
```
**람다 함수와 함께 사용하기**
```sql title=Query theme={null}
SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;
```
```response title=Response theme={null}
6.5
```
## arrayCompact
도입 버전: v20.1.0
`null` 값을 포함해 배열에서 연속으로 중복되는 요소를 제거합니다. 결과 배열의 값 순서는 소스 배열의 순서를 따릅니다.
**구문**
```sql theme={null}
arrayCompact(arr)
```
**인수**
* `arr` — 중복 값을 제거할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
중복 값이 제거된 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
```
```response title=Response theme={null}
[1,nan,2,3]
```
## arrayConcat
도입 버전: v1.1.0
인수로 전달된 배열들을 결합합니다.
**구문**
```sql theme={null}
arrayConcat(arr1 [, arr2, ... , arrN])
```
**인수**
* `arr1 [, arr2, ... , arrN]` — 연결할 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
지정된 배열 인수들을 하나로 연결한 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
```
```response title=Response theme={null}
[1, 2, 3, 4, 5, 6]
```
## arrayCount
도입 버전: v1.1.0
`func(arr1[i], ..., arrN[i])`가 true를 반환하는 요소의 수를 반환합니다.
`func`를 지정하지 않으면 배열에서 0이 아닌 요소의 수를 반환합니다.
`arrayCount`는 [고차 함수](/ko/reference/functions/regular-functions/overview#higher-order-functions)입니다.
**구문**
```sql theme={null}
arrayCount([func, ] arr1, ...)
```
**인수**
* `func` — 선택 사항입니다. 배열의 각 요소에 적용할 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1, ..., arrN` — N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
`func`가 true를 반환하는 요소 수를 반환합니다. 그렇지 않으면 배열에서 0이 아닌 요소 수를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)
```
```response title=Response theme={null}
5
```
## arrayCumSum
도입 버전: v1.1.0
소스 배열 요소의 부분합(누적합)으로 이루어진 배열을 반환합니다. 람다 함수가 지정된 경우, 각 위치의 배열 요소에 람다를 적용한 값을 합산하여 계산합니다.
**구문**
```sql theme={null}
arrayCumSum([func,] arr1[, arr2, ... , arrN])
```
**인수**
* `func` — 선택 사항입니다. 각 위치의 배열 요소에 적용할 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — 숫자 값으로 이루어진 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[arr2, ..., arrN]` — 선택 사항입니다. 크기가 같은 추가 배열이며, 지정한 경우 람다 함수의 인수로 전달됩니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열 요소의 누적 합으로 이루어진 배열을 반환합니다. 결과 타입은 입력 배열의 숫자 타입과 같습니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**기본 사용법**
```sql title=Query theme={null}
SELECT arrayCumSum([1, 1, 1, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 3, 4]
```
**람다 사용**
```sql title=Query theme={null}
SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res
```
```response title=Response theme={null}
[2, 6, 12]
```
## arrayCumSumNonNegative
도입 버전: v18.12.0
소스 배열의 요소에 대한 부분 합(누적 합) 배열을 반환하며, 누적 합이 음수가 되면 해당 값을 0으로 대체합니다. 람다 함수가 지정된 경우에는 각 위치의 배열 요소에 람다를 적용한 결과를 합산합니다.
**구문**
```sql theme={null}
arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])
```
**인수**
* `func` — 선택 사항입니다. 각 위치의 배열 요소에 적용할 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — 숫자 값으로 이루어진 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[arr2, ..., arrN]` — 선택 사항입니다. 크기가 같은 추가 배열이며, 지정한 경우 람다 함수에 인수로 전달됩니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열 요소의 부분합으로 이루어진 배열을 반환합니다. 이때 누적합이 음수가 되면 0으로 대체됩니다. 결과 타입은 입력 배열의 숫자 타입과 일치합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**기본 사용법**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 0, 1]
```
**람다 사용 시**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res
```
```response title=Response theme={null}
[2, 0, 6]
```
## arrayDifference
도입 버전: v1.1.0
인접한 배열 요소 간의 차이값으로 이루어진 배열을 계산합니다.
결과 배열의 첫 번째 요소는 0이고, 두 번째 요소는 `arr[1] - arr[0]`, 세 번째 요소는 `arr[2] - arr[1]`이며, 이후에도 같은 방식으로 이어집니다.
결과 배열 요소의 유형은 뺄셈에 대한 유형 추론 규칙에 따라 결정됩니다(예: `UInt8` - `UInt8` = `Int16`).
**구문**
```sql theme={null}
arrayDifference(arr)
```
**인수**
* `arr` — 인접한 요소 간 차이를 계산할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
배열에서 인접한 요소 간 차이로 이루어진 배열을 반환합니다. [`UInt*`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayDifference([1, 2, 3, 4]);
```
```response title=Response theme={null}
[0,1,1,1]
```
**Int64 결과 타입으로 인한 오버플로우 예시**
```sql title=Query theme={null}
SELECT arrayDifference([0, 10000000000000000000]);
```
```response title=Response theme={null}
┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616] │
└────────────────────────────────────────────┘
```
## arrayDistinct
도입 버전: v1.1.0
배열에서 중복을 제거한 요소만 포함된 배열을 반환합니다.
**구문**
```sql theme={null}
arrayDistinct(arr)
```
**인수**
* `arr` — 고유한 요소를 추출할 대상 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
고유한 요소가 포함된 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayDistinct([1, 2, 2, 3, 1]);
```
```response title=Response theme={null}
[1,2,3]
```
## arrayDotProduct
지원 버전: v23.5.0
두 배열의 내적을 반환합니다.
두 벡터의 크기는 반드시 같아야 합니다. 배열과 튜플에는 서로 다른 타입의 요소가 함께 포함될 수도 있습니다.
**구문**
```sql theme={null}
arrayDotProduct(v1, v2)
```
**인수**
* `v1` — 첫 번째 벡터입니다. [`Array((U)Int* | Float* | Decimal)`](/ko/reference/data-types/array) 또는 [`Tuple((U)Int* | Float* | Decimal)`](/ko/reference/data-types/tuple)
* `v2` — 두 번째 벡터입니다. [`Array((U)Int* | Float* | Decimal)`](/ko/reference/data-types/array) 또는 [`Tuple((U)Int* | Float* | Decimal)`](/ko/reference/data-types/tuple)
**반환 값**
두 벡터의 내적입니다.
반환 타입은 인수의 타입에 따라 결정됩니다. 배열 또는 Tuple에 서로 다른 타입의 요소가 섞여 있으면 결과 타입은 공통 상위 타입이 됩니다.
[`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
**예시**
**배열 예시**
```sql title=Query theme={null}
SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);
```
```response title=Response theme={null}
32 UInt16
```
**Tuple 예시**
```sql title=Query theme={null}
SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);
```
```response title=Response theme={null}
32 Float64
```
## arrayElement
도입 버전: v1.1.0
임의의 정수형이 될 수 있는 인덱스 `n`을 사용해 주어진 배열에서 해당 요소를 가져옵니다.
인덱스가 배열 범위를 벗어나면 기본값(숫자는 0, 문자열은 빈 문자열 등)을 반환합니다.
단, 비상수 배열 인수와 상수 인덱스 0인 경우는 예외입니다. 이 경우 `Array indices are 1-based` 오류가 발생합니다.
ClickHouse의 배열은 1부터 시작하는 인덱스를 사용합니다.
음수 인덱스도 지원합니다. 이 경우 끝에서부터 번호를 매긴 해당 요소를 선택합니다. 예를 들어 `arr[-1]`은 배열의 마지막 항목입니다.
연산자 `[n]`도 동일한 기능을 제공합니다.
**구문**
```sql theme={null}
arrayElement(arr, n)
```
**인수**
* `arr` — 검색할 배열입니다. [`Array(T)`](/ko/reference/data-types/array). - `n` — 가져올 요소의 위치입니다. [`(U)Int*`](/ko/reference/data-types/int-uint).
**반환 값**
제공된 배열 인수에서 결합된 단일 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**음수 인덱스 사용**
```sql title=Query theme={null}
SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**\[n] 표기법 사용하기**
```sql title=Query theme={null}
SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**배열 범위를 벗어난 인덱스**
```sql title=Query theme={null}
SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
0
```
## arrayElementOrNull
도입 버전: v1.1.0
주어진 배열에서 인덱스 `n`에 해당하는 요소를 반환합니다. 여기서 `n`은 임의의 정수 유형이 될 수 있습니다.
인덱스가 배열 범위를 벗어나면 기본값 대신 `NULL`을 반환합니다.
ClickHouse의 배열은 인덱스가 1부터 시작합니다.
음수 인덱스도 지원합니다. 이 경우 끝에서부터 센 해당 요소를 선택합니다. 예를 들어 `arr[-1]`은 배열의 마지막 요소입니다.
**구문**
```sql theme={null}
arrayElementOrNull(arrays)
```
**인수**
* `arrays` — 임의 개수의 배열 인수입니다. [`Array`](/ko/reference/data-types/array)
**반환 값**
주어진 배열 인수들을 결합한 단일 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**음수 인덱싱**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**배열 범위를 벗어난 인덱스**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
NULL
```
## arrayEnumerate
지원 시작 버전: v1.1.0
배열 `[1, 2, 3, ..., length (arr)]`을 반환합니다.
이 함수는 일반적으로 [`ARRAY JOIN`](/ko/reference/statements/select/array-join) 절과 함께 사용됩니다. `ARRAY JOIN`을 적용한 뒤
각 배열에 대해 무언가를 한 번만 계산할 수 있습니다.
이 함수는 고차 함수에서도 사용할 수 있습니다. 예를 들어, 조건과 일치하는 요소의 배열 인덱스를 구하는 데 사용할 수 있습니다.
**구문**
```sql theme={null}
arrayEnumerate(arr)
```
**인수**
* `arr` — 번호를 매길 배열입니다. [`Array`](/ko/reference/data-types/array)
**반환 값**
배열 `[1, 2, 3, ..., length(arr)]`을 반환합니다. [`Array(UInt32)`](/ko/reference/data-types/array)
**예시**
**ARRAY JOIN을 사용한 기본 예시**
```sql title=Query theme={null}
CREATE TABLE test
(
`id` UInt8,
`tag` Array(String),
`version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);
SELECT
id,
tag,
version,
seq
FROM test
ARRAY JOIN
tag,
version,
arrayEnumerate(tag) AS seq
```
```response title=Response theme={null}
┌─id─┬─tag────────────┬─version─────┬─seq─┐
│ 1 │ release-stable │ 2.4.0 │ 1 │
│ 1 │ dev │ 2.6.0-alpha │ 2 │
│ 1 │ security │ 2.4.0-sec1 │ 3 │
└────┴────────────────┴─────────────┴─────┘
```
## arrayEnumerateDense
도입 버전: v18.12.0
소스 배열과 동일한 크기의 배열을 반환하며, 각 요소가 소스 배열에서 처음 등장하는 위치를 나타냅니다.
**구문**
```sql theme={null}
arrayEnumerateDense(arr)
```
**인수**
* `arr` — 번호를 매길 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
각 요소가 소스 배열에 처음 나타나는 위치를 나타내는, `arr`와 동일한 크기의 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayEnumerateDense([10, 20, 10, 30])
```
```response title=Response theme={null}
[1,2,1,3]
```
## arrayEnumerateDenseRanked
도입 버전: v20.1.0
소스 배열과 동일한 크기의 배열을 반환하며, 소스 배열에서 각 요소가 처음 나타나는 위치를 나타냅니다. 또한 배열 내부를 어디까지 확인할지 깊이를 지정하여 다차원 배열을 열거할 수 있습니다.
**구문**
```sql theme={null}
arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)
```
**인수**
* `clear_depth` — 지정된 수준에서 요소별로 별도로 순번을 매깁니다. `max_arr_depth`보다 작거나 같아야 합니다. [`UInt*`](/ko/reference/data-types/int-uint)
* `arr` — 순번을 매길 N차원 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `max_array_depth` — 유효한 최대 깊이입니다. `arr`의 깊이보다 작거나 같아야 합니다. [`UInt*`](/ko/reference/data-types/int-uint)
**반환 값**
소스 배열에서 각 요소가 처음 나타나는 위치를 나타내는 배열을 반환합니다. [`Array`](/ko/reference/data-types/array)
**예시**
**기본 사용법**
```sql title=Query theme={null}
-- clear_depth=1, max_array_depth=1로 설정하면 arrayEnumerateDense와 동일한 결과를 반환합니다.
SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);
```
```response title=Response theme={null}
[1,2,1,3]
```
**다차원 배열 사용**
```sql title=Query theme={null}
-- 이 예시에서 arrayEnumerateDenseRanked는 다차원 배열의 각 요소가 동일한 값을 가진 요소들 중에서
-- 몇 번째로 등장하는지를 나타내는 배열을 반환합니다.
-- 전달된 배열의 첫 번째 행 [10, 10, 30, 20]에 대한 결과의 첫 번째 행은 [1, 1, 2, 3]입니다.
-- 이는 10이 1번째와 2번째 위치에서 처음 등장한 숫자이고, 30이 3번째 위치에서 두 번째로 등장한 숫자이며,
-- 20이 4번째 위치에서 세 번째로 등장한 숫자임을 나타냅니다.
-- 두 번째 행 [40, 50, 10, 30]에 대한 결과의 두 번째 행은 [4,5,1,2]입니다.
-- 이는 40과 50이 해당 행의 1번째와 2번째 위치에서 각각 네 번째와 다섯 번째로 등장한 숫자이고,
-- 10(처음 등장한 숫자)이 3번째 위치에, 30(두 번째로 등장한 숫자)이 마지막 위치에 있음을 나타냅니다.
SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);
```
```response title=Response theme={null}
[[1,1,2,3],[4,5,1,2]]
```
**clear\_depth를 늘린 예시**
```sql title=Query theme={null}
-- clear_depth=2로 변경하면 각 행에 대해 열거가 새로 시작됩니다.
SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);
```
```response title=Response theme={null}
[[1, 1, 2, 3], [1, 2, 3, 4]]
```
## arrayEnumerateUniq
도입 버전: v1.1.0
소스 배열과 동일한 크기의 배열을 반환하며, 각 요소가 같은 값을 가진 요소들 가운데 몇 번째 위치인지를 나타냅니다.
이 함수는 `ARRAY JOIN` 및 배열 요소 집계에 사용할 때 유용합니다.
이 함수는 동일한 크기의 여러 배열을 인수로 받을 수 있습니다. 이 경우 고유성은 모든 배열의 동일한 위치에 있는 요소들로 이루어진 튜플을 기준으로 판단됩니다.
**구문**
```sql theme={null}
arrayEnumerateUniq(arr1[, arr2, ... , arrN])
```
**인수**
* `arr1` — 처리할 첫 번째 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `arr2, ...` — 선택 사항입니다. 튜플의 고유성을 판별하기 위한 동일한 크기의 추가 배열입니다. [`Array(UInt32)`](/ko/reference/data-types/array)
**반환 값**
각 요소에 대해, 같은 값 또는 같은 튜플을 갖는 요소들 사이에서의 위치를 나타내는 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**기본 사용법**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([10, 20, 10, 30]);
```
```response title=Response theme={null}
[1, 1, 2, 1]
```
**여러 개의 배열**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);
```
```response title=Response theme={null}
[1,2,1,1,2,1]
```
**ARRAY JOIN 집계**
```sql title=Query theme={null}
-- 각 목표 ID에 대해 전환 수(Goals 중첩 데이터 구조의 각 요소는 달성된 목표이며, 이를 전환이라고 합니다)와
-- 세션 수를 계산합니다. ARRAY JOIN 없이는 세션 수를 sum(Sign)으로 집계했을 것입니다. 그러나 이 경우
-- 행이 중첩된 Goals 구조로 인해 곱해지므로, 각 세션을 한 번씩만 집계하기 위해
-- arrayEnumerateUniq(Goals.ID) 함수의 반환값에 조건을 적용합니다.
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
```
```response title=Response theme={null}
┌──GoalID─┬─Reaches─┬─Visits─┐
│ 53225 │ 3214 │ 1097 │
│ 2825062 │ 3188 │ 1097 │
│ 56600 │ 2803 │ 488 │
│ 1989037 │ 2401 │ 365 │
│ 2830064 │ 2396 │ 910 │
│ 1113562 │ 2372 │ 373 │
│ 3270895 │ 2262 │ 812 │
│ 1084657 │ 2262 │ 345 │
│ 56599 │ 2260 │ 799 │
│ 3271094 │ 2256 │ 812 │
└─────────┴─────────┴────────┘
```
## arrayEnumerateUniqRanked
도입 버전: v20.1.0
소스 배열과 동일한 차원의 배열(또는 다차원 배열)을 반환하며,
각 요소가 같은 값을 가진 요소들 사이에서 몇 번째 위치에 있는지를 나타냅니다.
배열 내부를 어느 깊이까지 확인할지 지정할 수 있으므로, 다차원 배열도 열거할 수 있습니다.
**구문**
```sql theme={null}
arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)
```
**인수**
* `clear_depth` — 지정된 수준에서 요소에 각각 별도로 순번을 매깁니다. `max_arr_depth` 이하의 양의 정수입니다. [`UInt*`](/ko/reference/data-types/int-uint)
* `arr` — 순번을 매길 N차원 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `max_array_depth` — 유효한 최대 깊이입니다. `arr`의 깊이 이하인 양의 정수입니다. [`UInt*`](/ko/reference/data-types/int-uint)
**반환 값**
`arr`와 크기가 같은 N차원 배열을 반환합니다. 각 요소에는 동일한 값을 가진 다른 요소들에 대한 해당 요소의 위치가 표시됩니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**예시 1**
```sql title=Query theme={null}
-- clear_depth=1이고 max_array_depth=1인 경우, arrayEnumerateUniqRanked의 결과는
-- 동일한 배열에 대해 arrayEnumerateUniq가 반환하는 결과와 같습니다.
SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);
```
```response title=Response theme={null}
[1, 1, 2]
```
**예시 2**
```sql title=Query theme={null}
-- clear_depth=1, max_array_depth=1인 경우, arrayEnumerateUniqRanked의 결과는
-- 동일한 배열에 대해 arrayEnumerateUniq가 반환하는 결과와 동일합니다.
SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);", "[[1, 1, 1], [2, 3, 2], [2]]
```
```response title=Response theme={null}
[1, 1, 2]
```
**예시 3**
```sql title=Query theme={null}
-- 이 예시에서 arrayEnumerateUniqRanked는 다차원 배열의 각 요소가
-- 동일한 값을 가진 요소들 중 몇 번째로 등장하는지를 나타내는 배열을 반환합니다.
-- 전달된 배열의 첫 번째 행 [1, 2, 3]에 대한 결과는 [1, 1, 1]로,
-- 1, 2, 3이 각각 처음 등장함을 나타냅니다.
-- 두 번째 행 [2, 2, 1]에 대한 결과는 [2, 3, 3]으로,
-- 2가 두 번째와 세 번째로 등장하고, 1이 두 번째로 등장함을 나타냅니다.
-- 마찬가지로, 세 번째 행 [3]에 대한 결과는 [2]로,
-- 3이 두 번째로 등장함을 나타냅니다.
SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);
```
```response title=Response theme={null}
[[1, 1, 1], [2, 3, 2], [2]]
```
**예시 4**
```sql title=Query theme={null}
-- clear_depth=2로 변경하면 각 행마다 요소가 별도로 열거됩니다.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);
```
```response title=Response theme={null}
[[1, 1, 1], [1, 2, 1], [1]]
```
## arrayExcept
도입 버전: v25.9.0
원래 순서를 유지하면서 `except`에 없는 `source`의 요소를 담은 배열을 반환합니다.
이 함수는 두 배열 간의 차집합 연산을 수행합니다. `source`의 각 요소에 대해 해당 요소가 `except`에 있는지(정확히 비교하여) 확인합니다. 없으면 해당 요소가 결과에 포함됩니다.
이 연산은 다음과 같은 특성을 유지합니다.
1. `source`의 요소 순서가 유지됩니다
2. `except`에 없는 경우 `source`의 중복 요소도 유지됩니다
3. NULL은 별도의 값으로 처리됩니다
**구문**
```sql theme={null}
arrayExcept(source, except)
```
**인수**
* `source` — 필터링할 요소가 들어 있는 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `except` — 결과에서 제외할 요소가 들어 있는 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
입력 배열과 같은 타입이며, `except`에 없는 `source`의 요소를 포함한 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**기본**
```sql title=Query theme={null}
SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])
```
```response title=Response theme={null}
[1, 2, 2, 4]
```
**with\_nulls1**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [2])
```
```response title=Response theme={null}
[1, NULL, NULL]
```
**with\_nulls2**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])
```
```response title=Response theme={null}
[1]
```
**문자열**
```sql title=Query theme={null}
SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])
```
```response title=Response theme={null}
['apple', 'cherry']
```
## arrayExists
도입 버전: v1.1.0
소스 배열에서 `func(x[, y1, y2, ... yN])`이 true를 반환하는 요소가 하나 이상 있으면 `1`을 반환합니다. 그렇지 않으면 `0`을 반환합니다.
**구문**
```sql theme={null}
arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 대해 동작하는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
람다 함수가 하나 이상의 요소에 대해 true를 반환하면 `1`을 반환하고, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])
```
```response title=Response theme={null}
0
```
## arrayFill
도입 버전: v20.1.0
`arrayFill` 함수는 첫 번째 요소부터 마지막 요소까지 소스 배열을 순차적으로 처리하며,
각 위치에서 소스 배열과 조건 배열의 요소를 사용해 람다 조건을 평가합니다. 위치 i에서
람다 함수의 평가 결과가 false이면, 해당 요소는 배열의 현재 상태에서 위치 i-1의 요소로
대체됩니다. 첫 번째 요소는 조건과 관계없이 항상 유지됩니다.
**구문**
```sql theme={null}
arrayFill(func(x [, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x [, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소를 처리하는 람다 함수 `func(x [, y1, y2, ... yN]) → F(x [, y1, y2, ... yN])`입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
배열 [`Array(T)`](/ko/reference/data-types/array)을 반환합니다.
**예시**
**단일 배열을 사용하는 예시**
```sql title=Query theme={null}
SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 1, 2, 2]
```
**두 개의 배열 예시**
```sql title=Query theme={null}
SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res
```
```response title=Response theme={null}
[5, 5, 6, 6]
```
## arrayFilter
도입 버전: v1.1.0
람다 함수가 true를 반환하는 소스 배열의 요소만 포함된 배열을 반환합니다.
**구문**
```sql theme={null}
arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 적용되는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열의 부분 집합을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**예시 1**
```sql title=Query theme={null}
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
```
```response title=Response theme={null}
['abc World']
```
**예시 2**
```sql title=Query theme={null}
SELECT
arrayFilter(
(i, x) -> x LIKE '%World%',
arrayEnumerate(arr),
['Hello', 'abc World'] AS arr)
AS res
```
```response title=Response theme={null}
[2]
```
## arrayFirst
도입 버전: v1.1.0
소스 배열에서 `func(x[, y1, y2, ... yN])`가 true를 반환하는 첫 번째 요소를 반환합니다. 해당 요소가 없으면 기본값을 반환합니다.
**구문**
```sql theme={null}
arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 대해 동작하는 람다 함수입니다. [람다 함수](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array).
**반환 값**
`λ`가 참이 되는 소스 배열의 첫 번째 요소를 반환하며, 그런 요소가 없으면 `T`의 기본값을 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**일치 항목 없음**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
0 UInt8
```
## arrayFirstIndex
도입 버전: v1.1.0
소스 배열에서 `func(x[, y1, y2, ... yN])`가 true를 반환하는 첫 번째 요소의 인덱스를 반환합니다. 해당 요소가 없으면 '0'을 반환합니다.
**구문**
```sql theme={null}
arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 적용되는 람다 함수입니다. [람다 함수](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array).
**반환 값**
`func`가 참이 되는 소스 배열의 첫 번째 요소 인덱스를 반환하고, 해당 요소가 없으면 `0`을 반환합니다 [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
2
```
**일치 없음**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])
```
```response title=Response theme={null}
0
```
## arrayFirstOrNull
도입 버전: v1.1.0
`func(x[, y1, y2, ... yN])`이 true를 반환하는 소스 배열의 첫 번째 요소를 반환합니다. 해당 요소가 없으면 `NULL`을 반환합니다.
**구문**
```sql theme={null}
arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 적용되는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
`func`가 참인 소스 배열의 첫 번째 요소를 반환하며, 그런 요소가 없으면 `NULL`을 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**일치하는 항목이 없습니다**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
NULL Nullable(UInt8)
```
## arrayFlatten
도입 버전: v20.1.0
배열의 배열을 1차원 배열로 변환합니다.
함수:
* 중첩 배열의 깊이에 상관없이 적용됩니다.
* 이미 1차원인 배열은 변경하지 않습니다.
평탄화된 배열에는 모든 소스 배열의 요소가 모두 포함됩니다.
**구문**
```sql theme={null}
arrayFlatten(arr)
```
**별칭**: `flatten`
**인수**
* `arr` — 다차원 배열입니다. [`Array(Array(T))`](/ko/reference/data-types/array)
**반환 값**
다차원 배열을 1차원으로 펼친 배열 [`Array(T)`](/ko/reference/data-types/array)을 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayFlatten([[[1]], [[2], [3]]]);
```
```response title=Response theme={null}
[1, 2, 3]
```
## arrayFold
도입 버전: v23.10.0
같은 크기의 하나 이상의 배열에 람다 함수를 적용하고 결과를 누산기에 누적합니다.
**구문**
```sql theme={null}
arrayFold(λ(acc, x1 [, x2, x3, ... xN]), arr1 [, arr2, arr3, ... arrN], acc)
```
**인수**
* `λ(x, x1 [, x2, x3, ... xN])` — `λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN])` 형태의 람다 함수입니다. 여기서 `F`는 `acc`와 `x`의 배열 값에 적용되는 연산이며, 계산된 `acc` 결과는 다음 단계에서 다시 사용됩니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1 [, arr2, arr3, ... arrN]` — 연산을 수행할 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `acc` — 람다 함수의 반환 타입과 동일한 타입의 누산기 값입니다.
**반환 값**
최종 `acc` 값을 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;
```
```response title=Response theme={null}
23
```
**피보나치 수열**
```sql title=Query theme={null}
SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);
```
```response title=Response theme={null}
┌─fibonacci─┐
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 3 │
│ 5 │
│ 8 │
│ 13 │
│ 21 │
│ 34 │
└───────────┘
```
**여러 배열 사용 예시**
```sql title=Query theme={null}
SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;
```
```response title=Response theme={null}
300
```
## arrayIntersect
지원 버전: v1.1.0
여러 배열을 받아 모든 소스 배열에 공통으로 존재하는 요소로 이루어진 배열을 반환합니다. 결과에는 고유한 값만 포함됩니다.
**구문**
```sql theme={null}
arrayIntersect(arr, arr1, ..., arrN)
```
**인수**
* `arrN` — 새 배열을 구성할 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array).
**반환 값**
모든 N개 배열에 공통으로 존재하는 고유 요소로 이루어진 배열을 반환합니다 [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
```
```response title=Response theme={null}
┌─empty_intersection─┬─non_empty_intersection─┐
│ [] │ [1] │
└────────────────────┴────────────────────────┘
```
## arrayJaccardIndex
도입 버전: v23.7.0
두 배열의 [자카드 지수](https://en.wikipedia.org/wiki/Jaccard_index)를 반환합니다.
**구문**
```sql theme={null}
arrayJaccardIndex(arr_x, arr_y)
```
**인수**
* `arr_x` — 첫 번째 배열. [`Array(T)`](/ko/reference/data-types/array)
* `arr_y` — 두 번째 배열. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
`arr_x`와 `arr_y`의 Jaccard 인덱스를 반환합니다. [`Float64`](/ko/reference/data-types/float)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res
```
```response title=Response theme={null}
0.3333333333333333
```
## arrayJoin
도입 버전: v1.1.0
`arrayJoin` 함수는 배열이 포함된 행을 받아 이를 펼쳐, 배열의 각 요소에 대해 하나씩 여러 개의 행을 생성합니다.
이는 ClickHouse의 일반 함수가 동일한 행 내에서 입력 값을 출력 값에 매핑하는 방식이나,
집계 함수가 여러 행의 그룹을 받아 이를 단일 요약 행으로 "압축"하거나 "줄이는" 방식
(`GROUP BY`와 함께 사용할 경우에는 요약 행 내의 단일 값으로 줄임)과는 대조적입니다.
이 함수가 적용된 컬럼의 값을 제외하면 다른 컬럼의 값은 모두 그대로 복사되며,
해당 값은 대응하는 배열 값으로 대체됩니다.
**구문**
```sql theme={null}
arrayJoin(arr)
```
**별칭**: `unnest`
**인수**
* `arr` — 펼칠 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
`arr`를 펼쳐 얻은 행 집합을 반환합니다.
**예시**
**기본 사용법**
```sql title=Query theme={null}
SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src
```
```response title=Response theme={null}
┌─dst─┬─\'Hello\'─┬─src─────┐
│ 1 │ Hello │ [1,2,3] │
│ 2 │ Hello │ [1,2,3] │
│ 3 │ Hello │ [1,2,3] │
└─────┴───────────┴─────────┘
```
**arrayJoin은 쿼리의 모든 절에 영향을 미칩니다**
```sql title=Query theme={null}
-- arrayJoin 함수는 WHERE 절을 포함한 쿼리의 모든 절에 영향을 미칩니다. 서브쿼리가 1개의 행을 반환했음에도 결과가 2임에 주목하십시오.
SELECT sum(1) AS impressions
FROM
(
SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];
```
```response title=Response theme={null}
┌─impressions─┐
│ 2 │
└─────────────┘
```
**여러 arrayJoin 함수 사용하기**
```sql title=Query theme={null}
- 하나의 쿼리에서 여러 arrayJoin 함수를 사용할 수 있습니다. 이 경우 변환이 여러 번 수행되며 행이 곱셈 방식으로 늘어납니다.
SELECT
sum(1) AS impressions,
arrayJoin(cities) AS city,
arrayJoin(browsers) AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 2 │ Istanbul │ Chrome │
│ 1 │ Istanbul │ Firefox │
│ 2 │ Berlin │ Chrome │
│ 1 │ Berlin │ Firefox │
│ 2 │ Bobruisk │ Chrome │
│ 1 │ Bobruisk │ Firefox │
└─────────────┴──────────┴─────────┘
```
**최적화로 인한 예상치 못한 결과**
```sql title=Query theme={null}
-- 동일한 표현식으로 여러 arrayJoin을 사용하면 최적화로 인해 예상치 못한 결과가 발생할 수 있습니다.
-- 이러한 경우, 조인 결과에 영향을 주지 않는 추가 연산으로 반복되는 배열 표현식을 수정하는 것을 권장합니다.
- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))
SELECT
arrayJoin(dice) as first_throw,
/* arrayJoin(dice) as second_throw */ -- 기술적으로는 올바르지만 결과 집합을 소멸시킵니다
arrayJoin(arrayConcat(dice, [])) as second_throw -- 재평가를 강제하기 위해 의도적으로 표현식을 변경함
FROM (
SELECT [1, 2, 3, 4, 5, 6] as dice
);
```
```response title=Response theme={null}
┌─first_throw─┬─second_throw─┐
│ 1 │ 1 │
│ 1 │ 2 │
│ 1 │ 3 │
│ 1 │ 4 │
│ 1 │ 5 │
│ 1 │ 6 │
│ 2 │ 1 │
│ 2 │ 2 │
│ 2 │ 3 │
│ 2 │ 4 │
│ 2 │ 5 │
│ 2 │ 6 │
│ 3 │ 1 │
│ 3 │ 2 │
│ 3 │ 3 │
│ 3 │ 4 │
│ 3 │ 5 │
│ 3 │ 6 │
│ 4 │ 1 │
│ 4 │ 2 │
│ 4 │ 3 │
│ 4 │ 4 │
│ 4 │ 5 │
│ 4 │ 6 │
│ 5 │ 1 │
│ 5 │ 2 │
│ 5 │ 3 │
│ 5 │ 4 │
│ 5 │ 5 │
│ 5 │ 6 │
│ 6 │ 1 │
│ 6 │ 2 │
│ 6 │ 3 │
│ 6 │ 4 │
│ 6 │ 5 │
│ 6 │ 6 │
└─────────────┴──────────────┘
```
**ARRAY JOIN 구문 사용하기**
```sql title=Query theme={null}
-- 아래 `SELECT` 쿼리에서 더 다양한 활용이 가능한 ARRAY JOIN 구문을 참고하십시오.
-- ARRAY JOIN을 사용하면 요소 수가 동일한 여러 배열을 한 번에 변환할 수 있습니다.
SELECT
sum(1) AS impressions,
city,
browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
cities AS city,
browsers AS browser
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
```
**튜플 사용하기**
```sql title=Query theme={null}
-- 튜플을 사용할 수도 있습니다
SELECT
sum(1) AS impressions,
(arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
t.2 AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
```
## arrayLast
도입 버전: v1.1.0
람다 `func(x [, y1, y2, ... yN])`가 true를 반환하는 소스 배열의 마지막 요소를 반환합니다. 해당 요소가 없으면 기본값을 반환합니다.
**구문**
```sql theme={null}
arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 대해 작동하는 람다 함수입니다. [람다 함수](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array). - `[, cond1, ... , condN]` — 선택 사항입니다. 람다 함수에 추가 인수를 전달하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array).
**반환 값**
`func`가 true인 소스 배열의 마지막 요소를 반환합니다. 해당하는 요소가 없으면 `T`의 기본값을 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**일치하는 항목 없음**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
0 UInt8
```
## arrayLastIndex
도입된 버전: v1.1.0
`func(x[, y1, y2, ... yN])`가 true를 반환하는 소스 배열의 마지막 요소 인덱스를 반환합니다. 해당하는 요소가 없으면 '0'을 반환합니다.
**구문**
```sql theme={null}
arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 대해 동작하는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
`func`가 true를 반환하는 소스 배열의 마지막 요소 인덱스를 반환하며, 해당 요소가 없으면 `0`을 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);
```
```response title=Response theme={null}
3
```
**일치하는 항목 없음**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);
```
```response title=Response theme={null}
0
```
## arrayLastOrNull
도입 버전: v1.1.0
람다 `func(x [, y1, y2, ... yN])`가 true를 반환하는 소스 배열의 마지막 요소를 반환합니다. 해당하는 요소가 없으면 `NULL`을 반환합니다.
**구문**
```sql theme={null}
arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x [, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 적용되는 람다 함수입니다. [람다 함수](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array).
**반환 값**
`λ`가 참이 아닌 소스 배열의 마지막 요소를 반환합니다. 해당하는 요소가 없으면 `NULL`을 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**일치 항목 없음**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
NULL Nullable(UInt8)
```
## arrayLevenshteinDistance
도입된 버전: v25.4.0
두 배열의 Levenshtein 거리를 계산합니다.
**구문**
```sql theme={null}
arrayLevenshteinDistance(from, to)
```
**인수**
* `from` — 첫 번째 배열입니다. [`Array(T)`](/ko/reference/data-types/array). - `to` — 두 번째 배열입니다. [`Array(T)`](/ko/reference/data-types/array).
**반환 값**
첫 번째 배열과 두 번째 배열 간의 Levenshtein 거리입니다. [`Float64`](/ko/reference/data-types/float)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])
```
```response title=Response theme={null}
1
```
## arrayLevenshteinDistanceWeighted
도입 버전: v25.4.0
각 요소에 대한 사용자 지정 가중치를 적용해 두 배열의 Levenshtein 거리를 계산합니다.
배열의 요소 수와 가중치의 수는 일치해야 합니다.
**구문**
```sql theme={null}
arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)
```
**인수**
* `from` — 첫 번째 배열. [`Array(T)`](/ko/reference/data-types/array). - `to` — 두 번째 배열. [`Array(T)`](/ko/reference/data-types/array). - `from_weights` — 첫 번째 배열에 대한 가중치. [`Array((U)Int*|Float*)`](/ko/reference/data-types/array)
* `to_weights` — 두 번째 배열에 대한 가중치. [`Array((U)Int*|Float*)`](/ko/reference/data-types/array)
**반환 값**
각 요소에 대해 사용자 지정 가중치를 적용한 첫 번째 배열과 두 번째 배열 간의 Levenshtein 거리 [`Float64`](/ko/reference/data-types/float)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])
```
```response title=Response theme={null}
14
```
## arrayMap
도입 버전: v1.1.0
원래 배열의 각 요소에 람다 함수를 적용해 얻은 배열을 반환합니다.
**구문**
```sql theme={null}
arrayMap(func, arr)
```
**인수**
* `func` — 소스 배열(`x`)과 조건 배열(`y`)의 요소를 처리하는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — 처리할 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
람다 함수의 결과로 이루어진 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
```
```response title=Response theme={null}
[3, 4, 5]
```
**서로 다른 배열의 요소로 튜플 생성하기**
```sql title=Query theme={null}
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
```
```response title=Response theme={null}
[(1, 4),(2, 5),(3, 6)]
```
## arrayMax
도입 버전: v21.1.0
소스 배열의 최댓값 요소를 반환합니다.
람다 함수 `func`가 지정된 경우, 람다 함수의 결과 중 최댓값 요소를 반환합니다.
**구문**
```sql theme={null}
arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 선택 사항입니다. 소스 배열(`x`)과 조건 배열(`y`)의 요소에 대해 동작하는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열의 최댓값 요소를 반환합니다. 람다 함수가 제공된 경우에는 람다 함수 결과의 최댓값 요소를 반환합니다.
**예시**
**기본 예시**
```sql title=Query theme={null}
SELECT arrayMax([5, 3, 2, 7]);
```
```response title=Response theme={null}
7
```
**람다 함수와 함께 사용**
```sql title=Query theme={null}
SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
12
```
## arrayMin
도입 버전: v21.1.0
소스 배열의 최솟값 요소를 반환합니다.
람다 함수 `func`를 지정하면 람다 결과에서 최솟값 요소를 반환합니다.
**구문**
```sql theme={null}
arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 선택 사항입니다. 소스 배열(`x`)과 조건 배열(`y`)의 요소에 적용되는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `cond1_arr, ...` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열의 최솟값 요소를 반환합니다. 람다 함수가 제공된 경우에는 람다 함수 결과의 최솟값 요소를 반환합니다.
**예시**
**기본 예시**
```sql title=Query theme={null}
SELECT arrayMin([5, 3, 2, 7]);
```
```response title=Response theme={null}
2
```
**람다 함수 사용**
```sql title=Query theme={null}
SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
4
```
## arrayNormalizedGini
도입 버전: v25.1.0
정규화된 Gini 계수를 계산합니다.
**구문**
```sql theme={null}
arrayNormalizedGini(predicted, label)
```
**인수**
* `predicted` — 예측값입니다. [`Array(T)`](/ko/reference/data-types/array)
* `label` — 실제값입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
예측값의 Gini 계수, 정규화된 값의 Gini 계수, 정규화된 Gini 계수(= 앞의 두 Gini 계수의 비율)를 포함하는 튜플입니다. [`Tuple(Float64, Float64, Float64)`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);
```
```response title=Response theme={null}
(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)
```
## arrayPartialReverseSort
도입 버전: v23.2.0
이 함수는 `arrayReverseSort`와 동일하지만, 부분 정렬을 수행할 수 있도록 추가 `limit` 인수를 제공합니다.
정렬된 요소만 유지하려면 `arrayResize`를 사용하십시오.
**구문**
```sql theme={null}
arrayPartialReverseSort([f,] arr [, arr1, ... ,arrN], limit)
```
**인수**
* `f(arr[, arr1, ... ,arrN])` — 배열 `x`의 요소에 적용할 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — 정렬할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `arr1, ... ,arrN` — `f`가 여러 인수를 받는 경우 사용할 추가 배열 N개입니다. [`Array(T)`](/ko/reference/data-types/array)
* `limit` — 정렬이 수행되는 범위의 끝을 나타내는 인덱스 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
원본 배열과 크기가 같은 배열을 반환합니다. 이 배열에서 `[1..limit]` 범위의 요소는
내림차순으로 정렬되며, 나머지 요소 `(limit..N]`의 순서는 지정되지 않습니다.
**예시**
**simple\_int**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])
```
```response title=Response theme={null}
['lasso','gladly','expenses','embolism']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[9, 5]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[0, 1, 2]
```
## arrayPartialShuffle
도입 버전: v23.2.0
원본 배열과 동일한 크기의 배열을 반환합니다. 이 배열에서 `[1..limit]` 범위의 요소는 원본 배열에서 무작위로 선택된 부분집합입니다.
나머지 `(limit..n]`에는 `[1..limit]` 범위에 포함되지 않은 요소가 정의되지 않은 순서로 들어갑니다.
`limit` 값은 `[1..n]` 범위에 있어야 합니다. 이 범위를 벗어난 값은 전체 `arrayShuffle`을 수행하는 것과 동일합니다.
이 함수는 상수를 구체화하지 않습니다.
`limit` 값은 `[1..N]` 범위에 있어야 합니다. 이 범위를 벗어난 값은 전체 [`arrayShuffle`](#arrayShuffle)을 수행하는 것과 동일합니다.
**구문**
```sql theme={null}
arrayPartialShuffle(arr [, limit[, seed]])
```
**인수**
* `arr` — 섞을 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `seed` — 선택 사항입니다. 난수 생성에 사용할 시드 값입니다. 지정하지 않으면 무작위 값이 사용됩니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
* `limit` — 선택 사항입니다. 요소 교환 횟수를 제한하는 값이며, 범위는 `[1..N]`입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
요소가 부분적으로 섞인 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**no\_limit1**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 0)
```
```response title=Response theme={null}
[2, 4, 3, 1]
```
**no\_limit2**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4])
```
```response title=Response theme={null}
[4, 1, 3, 2]
```
**random\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2)
```
```response title=Response theme={null}
[3, 4, 1, 2]
```
**explicit\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)
```
```response title=Response theme={null}
[3, 2, 1, 4]
```
**구체화하다**
```sql title=Query theme={null}
SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)
```
```response title=Response theme={null}
┌─arrayPartial⋯4]), 2, 42)─┬─arrayPartial⋯ 3], 2, 42)─┐
│ [3,2,1,4] │ [3,2,1] │
│ [3,2,1,4] │ [3,2,1] │
│ [4,3,2,1] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [3,4,1,2] │ [3,2,1] │
│ [1,2,3,4] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [3,1,2,4] │ [3,2,1] │
│ [1,3,2,4] │ [3,2,1] │
└──────────────────────────┴──────────────────────────┘
```
## arrayPartialSort
도입 버전: v23.2.0
이 함수는 `arraySort`와 동일하지만, `limit` 인수가 추가되어 부분 정렬을 수행할 수 있습니다.
정렬된 요소만 유지하려면 `arrayResize`를 사용하세요.
**구문**
```sql theme={null}
arrayPartialSort([f,] arr [, arr1, ... ,arrN], limit)
```
**인수**
* `f(arr[, arr1, ... ,arrN])` — 배열 요소에 적용할 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — 정렬할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `arr1, ... ,arrN` — `f`가 여러 인수를 받을 때 사용하는 추가 배열 N개입니다. [`Array(T)`](/ko/reference/data-types/array)
* `limit` — 정렬이 수행되는 범위를 나타내는 인덱스 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
원본 배열과 크기가 같은 배열을 반환합니다. 이 배열에서는 `[1..limit]` 범위의 요소가
오름차순으로 정렬됩니다. 나머지 요소 `(limit..N]`의 순서는 지정되지 않습니다.
**예시**
**simple\_int**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])
```
```response title=Response theme={null}
['embolism', 'expenses', 'gladly', 'lasso']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[1, 3]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[2, 1, 0]
```
## arrayPopBack
도입 버전: v1.1.0
배열의 마지막 요소를 제거합니다.
**구문**
```sql theme={null}
arrayPopBack(arr)
```
**인수**
* `arr` — 마지막 요소를 제거할 대상 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
`arr`와 동일하지만 마지막 요소가 제거된 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayPopBack([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[1, 2]
```
## arrayPopFront
도입 버전: v1.1.0
배열에서 첫 번째 요소를 제거합니다.
**구문**
```sql theme={null}
arrayPopFront(arr)
```
**인수**
* `arr` — 첫 번째 요소를 제거할 대상 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
`arr`와 동일하지만 첫 번째 요소가 제거된 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayPopFront([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[2, 3]
```
## arrayProduct
도입 버전: v21.1.0
소스 배열 요소들의 곱을 반환합니다.
람다 함수 `func`가 지정된 경우, 람다 함수 결과 요소들의 곱을 반환합니다.
**구문**
```sql theme={null}
arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 선택 사항입니다. 소스 배열(`x`)과 조건 배열(`y`)의 요소에 적용되는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열 요소의 곱을 반환합니다. 람다 함수가 제공되면 람다 함수 결과 요소의 곱을 반환합니다. [`Float64`](/ko/reference/data-types/float)
**예시**
**기본 예시**
```sql title=Query theme={null}
SELECT arrayProduct([1, 2, 3, 4]);
```
```response title=Response theme={null}
24
```
**람다 함수와 함께 사용하기**
```sql title=Query theme={null}
SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;
```
```response title=Response theme={null}
16
```
## arrayPushBack
도입 버전: v1.1.0
배열의 끝에 항목 하나를 추가합니다.
**구문**
```sql theme={null}
arrayPushBack(arr, x)
```
**인수**
* `arr` — 끝에 값 `x`를 추가할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `x` —
* 배열 끝에 추가할 단일 값입니다. [`Array(T)`](/ko/reference/data-types/array).
- 숫자 배열에는 숫자만 추가할 수 있고, 문자열 배열에는 문자열만 추가할 수 있습니다.
- 숫자를 추가할 때 ClickHouse는 배열의 데이터 타입에 맞춰 `x`의 타입을 자동으로 설정합니다.
- `NULL`일 수 있습니다. 이 함수는 배열에 `NULL` 요소를 추가하며, 배열 요소의 타입은 `Nullable`로 변환됩니다.
ClickHouse의 데이터 타입에 대한 자세한 내용은 [데이터 타입](/ko/reference/data-types)를 참조하십시오.
**반환 값**
`arr`와 동일하지만 배열 끝에 값 `x`가 추가된 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayPushBack(['a'], 'b') AS res;
```
```response title=Response theme={null}
['a','b']
```
## arrayPushFront
도입 버전: v1.1.0
배열의 맨 앞에 요소를 하나 추가합니다.
**구문**
```sql theme={null}
arrayPushFront(arr, x)
```
**인수**
* `arr` — 끝에 값 `x`를 추가할 대상 배열입니다. [`Array(T)`](/ko/reference/data-types/array). - `x` —
* 배열의 시작 부분에 추가할 단일 값입니다. [`Array(T)`](/ko/reference/data-types/array).
- 숫자 배열에는 숫자만 추가할 수 있고, 문자열 배열에는 문자열만 추가할 수 있습니다.
- 숫자를 추가할 때 ClickHouse는 배열의 데이터 타입에 맞게 `x`의 타입을 자동으로 설정합니다.
- `NULL`일 수 있습니다. 이 함수는 배열에 `NULL` 요소를 추가하며, 배열 요소의 타입은 `Nullable`로 변환됩니다.
ClickHouse의 데이터 타입에 대한 자세한 내용은 [데이터 타입](/ko/reference/data-types)을 참조하십시오.
**반환 값**
`arr`와 동일하지만 배열의 시작 부분에 값 `x`가 추가된 배열을 반환합니다 [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayPushFront(['b'], 'a') AS res;
```
```response title=Response theme={null}
['a','b']
```
## arrayROCAUC
도입 버전: v20.4.0
ROC(수신자 조작 특성) 곡선 아래 면적을 계산합니다.
ROC 곡선은 모든 임계값에 대해 y축에 진양성률(TPR), x축에 위양성률(FPR)을 표시하여 그립니다.
결과값은 0에서 1 사이이며, 값이 높을수록 model 성능이 더 우수함을 의미합니다.
ROC AUC(간단히 AUC라고도 함)는 기계 학습의 개념입니다.
자세한 내용은 [여기](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve), [여기](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1), [여기](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve)를 참조하십시오.
**구문**
```sql theme={null}
arrayROCAUC(scores, labels[, scale[, partial_offsets]])
```
**별칭**: `arrayAUC`
**인수**
* `scores` — 예측 모델이 산출한 점수입니다. [`Array((U)Int*)`](/ko/reference/data-types/array) 또는 [`Array(Float*)`](/ko/reference/data-types/array)
* `labels` — 샘플의 레이블로, 일반적으로 양성 샘플은 1, 음성 샘플은 0입니다. [`Array((U)Int*)`](/ko/reference/data-types/array) 또는 [`Enum`](/ko/reference/data-types/enum)
* `scale` — 선택 사항입니다. 정규화된 면적을 반환할지 여부를 결정합니다. false이면 대신 TP(참양성) x FP(거짓양성) 곡선 아래 면적을 반환합니다. 기본값: true. [`Bool`](/ko/reference/data-types/boolean)
* `partial_offsets` —
* 전체 AUC 대신 ROC 곡선의 부분 면적(ROC 공간의 수직 밴드에 해당)을 계산하기 위한 4개의 음이 아닌 정수로 이루어진 배열입니다. 이 옵션은 ROC AUC를 분산 계산할 때 유용합니다. 배열에는 다음 요소가 포함되어야 합니다: \[`higher_partitions_tp`, `higher_partitions_fp`, `total_positives`, `total_negatives`]. 음이 아닌 [정수](/ko/reference/data-types/int-uint)의 [배열](/ko/reference/data-types/array)입니다. 선택 사항입니다.
* `higher_partitions_tp`: 더 높은 점수 파티션에 있는 양성 레이블 수입니다.
* `higher_partitions_fp`: 더 높은 점수 파티션에 있는 음성 레이블 수입니다.
* `total_positives`: 전체 데이터셋의 총 양성 샘플 수입니다.
* `total_negatives`: 전체 데이터셋의 총 음성 샘플 수입니다.
`arr_partial_offsets`를 사용하는 경우 `arr_scores`와 `arr_labels`는 전체 데이터셋 중 점수 구간 하나에 해당하는 파티션만 포함해야 합니다.
데이터셋은 연속된 파티션으로 나누어야 하며, 각 파티션에는 점수가 특정 범위에 속하는 데이터의 부분 집합이 포함되어야 합니다.
예를 들면 다음과 같습니다:
* 한 파티션에는 \[0, 0.5) 범위의 모든 점수가 포함될 수 있습니다.
* 다른 파티션에는 \[0.5, 1.0] 범위의 점수가 포함될 수 있습니다.
**반환 값**
ROC(receiver operating characteristic) 곡선 아래 면적을 반환합니다. [`Float64`](/ko/reference/data-types/float)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
0.75
```
## arrayRandomSample
도입 버전: v23.10.0
입력 배열에서 무작위로 선택한 `samples`개의 요소로 이루어진 부분 집합을 반환합니다. `samples`가 입력 배열의 크기를 초과하면 표본 크기는 배열 크기로 제한됩니다. 즉, 배열의 모든 요소가 반환되지만 요소의 순서는 보장되지 않습니다. 이 함수는 평면 배열과 중첩 배열을 모두 처리할 수 있습니다.
**구문**
```sql theme={null}
arrayRandomSample(arr, samples)
```
**인수**
* `arr` — 요소를 샘플링할 입력 배열 또는 다차원 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `samples` — 무작위 샘플에 포함할 요소의 개수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
입력 배열의 요소를 무작위로 샘플링한 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;
```
```response title=Response theme={null}
['cherry','apple']
```
**다차원 배열 사용하기**
```sql title=Query theme={null}
SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;
```
```response title=Response theme={null}
[[3,4],[5,6]]
```
## arrayReduce
도입 버전: v1.1.0
배열 요소에 집계 함수를 적용하고 그 결과를 반환합니다.
집계 함수 이름은 `'max'`, `'sum'`처럼 작은따옴표로 묶인 문자열로 전달합니다.
매개변수화된 집계 함수를 사용할 때는 함수 이름 뒤의 괄호 안에 매개변수를 지정합니다. `'uniqUpTo(6)'`
**구문**
```sql theme={null}
arrayReduce(agg_f, arr1[, arr2, ... , arrN])
```
**인수**
* `agg_f` — 상수여야 하는 집계 함수 이름입니다. [`String`](/ko/reference/data-types/string)
* `arr1[, arr2, ... , arrN]` — `agg_f`의 인수에 대응하는 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
집계 함수 결과를 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayReduce('max', [1, 2, 3]);
```
```response title=Response theme={null}
┌─arrayReduce('max', [1, 2, 3])─┐
│ 3 │
└───────────────────────────────┘
```
**여러 인수를 받는 집계 함수 예시**
```sql title=Query theme={null}
--집계 함수가 여러 인수를 받는 경우, 동일한 크기의 여러 배열에 적용해야 합니다.
SELECT arrayReduce('maxIf', [3, 5], [1, 0]);
```
```response title=Response theme={null}
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│ 3 │
└──────────────────────────────────────┘
```
**매개변수형 집계 함수를 사용하는 예시**
```sql title=Query theme={null}
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
```
```response title=Response theme={null}
┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│ 4 │
└─────────────────────────────────────────────────────────────┘
```
## arrayReduceInRanges
도입 버전: v20.4.0
지정된 범위에 있는 배열 요소에 집계 함수를 적용하고, 각 범위의 결과를 담은 배열을 반환합니다.
이 함수는 여러 번 `arrayReduce(agg_func, arraySlice(arr1, index, length), ...)`를 호출한 것과 동일한 결과를 반환합니다.
**구문**
```sql theme={null}
arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])
```
**인수**
* `agg_f` — 사용할 집계 함수의 이름입니다. [`String`](/ko/reference/data-types/string)
* `ranges` — 집계를 수행할 범위입니다. 집계를 시작할 인덱스 `i`와 집계를 수행할 범위 `r`로 이루어진 `(i, r)` 튜플의 배열입니다. [`Array(T)`](/ko/reference/data-types/array) 또는 [`Tuple(T)`](/ko/reference/data-types/tuple)
* `arr1[, arr2, ... ,arrN]` — 집계 함수의 인수로 사용할 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
지정된 범위에서 집계 함수를 적용한 결과를 담은 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayReduceInRanges(
'sum',
[(1, 5), (2, 3), (3, 4), (4, 4)],
[1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
```
```response title=Response theme={null}
┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘
```
## arrayRemove
도입 버전: v25.11.0
배열에서 지정된 값과 같은 모든 요소를 제거합니다.
NULL은 같은 값으로 간주됩니다.
**구문**
```sql theme={null}
arrayRemove(arr, elem)
```
**별칭**: `array_remove`
**인수**
* `arr` — Array(T) - `elem` — T
**반환 값**
소스 배열 [`Array(T)`](/ko/reference/data-types/array)의 부분 집합을 반환합니다.
**예시**
**예시 1**
```sql title=Query theme={null}
SELECT arrayRemove([1, 2, 2, 3], 2)
```
```response title=Response theme={null}
[1, 3]
```
**예시 2**
```sql title=Query theme={null}
SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)
```
```response title=Response theme={null}
['a', 'b']
```
## arrayResize
도입 버전: v1.1.0
배열의 길이를 변경합니다.
**구문**
```sql theme={null}
arrayResize(arr, size[, extender])
```
**인수**
* `arr` — 크기를 조정할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `size` —
-배열의 새로운 길이입니다.
`size`가 배열의 원래 크기보다 작으면 배열은 오른쪽부터 잘립니다.
`size`가 배열의 원래 크기보다 크면 배열은 오른쪽으로 확장되며, 이때 `extender` 값 또는 배열 항목의 데이터 타입에 대한 기본값이 사용됩니다.
* `extender` — 배열을 확장할 때 사용할 값입니다. `NULL`일 수 있습니다.
**반환 값**
길이가 `size`인 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**예시 1**
```sql title=Query theme={null}
SELECT arrayResize([1], 3);
```
```response title=Response theme={null}
[1,0,0]
```
**예시 2**
```sql title=Query theme={null}
SELECT arrayResize([1], 3, NULL);
```
```response title=Response theme={null}
[1,NULL,NULL]
```
## arrayReverse
도입 버전: v1.1.0
주어진 배열 요소의 순서를 반대로 바꿉니다.
함수 `reverse(arr)`는 동일한 기능을 수행하지만, 배열뿐 아니라 다른 데이터 타입에도
적용할 수 있습니다.
**구문**
```sql theme={null}
arrayReverse(arr)
```
**인수**
* `arr` — 역순으로 뒤집을 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
원래 배열과 크기가 같고 요소가 역순으로 정렬된 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayReverse([1, 2, 3])
```
```response title=Response theme={null}
[3,2,1]
```
## arrayReverseFill
도입 버전: v20.1.0
`arrayReverseFill` 함수는 마지막 요소부터 첫 번째 요소까지 소스 배열을 순차적으로 처리하며, 각 위치에서 소스 배열과 조건 배열의 요소를 사용해 람다 조건을 평가합니다. 위치 i에서 조건이 false로 평가되면, 함수는 해당 요소를 배열의 현재 상태에서 i+1 위치의 요소로 대체합니다. 마지막 요소는 조건과 관계없이 항상 유지됩니다.
**구문**
```sql theme={null}
arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소를 처리하는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열의 각 요소가 람다 함수의 결과값으로 대체된 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**하나의 배열을 사용하는 예시**
```sql title=Query theme={null}
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 2, 2, NULL]
```
**두 개의 배열을 사용한 예시**
```sql title=Query theme={null}
SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;
```
```response title=Response theme={null}
[5, 6, 6, 2]
```
## arrayReverseSort
도입 버전: v1.1.0
배열의 요소를 내림차순으로 정렬합니다.
함수 `f`를 지정하면, 배열 요소에 적용한 함수의 결과를 기준으로 주어진 배열을 정렬한 다음
정렬된 배열을 역순으로 뒤집습니다.
`f`가 여러 인수를 받는 경우, `arrayReverseSort` 함수에는 여러 개의 배열이 전달되며
각 배열은 `func`의 인수에 대응합니다.
정렬할 배열에 `-Inf`, `NULL`, `NaN` 또는 `Inf`가 포함된 경우 다음 순서로 정렬됩니다:
1. `-Inf`
2. `Inf`
3. `NaN`
4. `NULL`
`arrayReverseSort`는 [고차 함수](/ko/reference/functions/regular-functions/overview#higher-order-functions)입니다.
**구문**
```sql theme={null}
arrayReverseSort([f,] arr [, arr1, ... ,arrN)
```
**인수**
* `f(y1[, y2 ... yN])` — 배열 `x`의 요소에 적용할 람다 함수입니다. - `arr` — 정렬할 배열입니다. [`Array(T)`](/ko/reference/data-types/array) - `arr1, ..., yN` — 선택 사항입니다. `f`가 여러 인수를 받는 경우 사용하는 추가 배열 N개입니다.
**반환 값**
람다 함수가 제공되지 않으면 배열 `x`를 내림차순으로 정렬해 반환합니다. 그렇지 않으면
제공된 람다 함수의 로직에 따라 정렬한 뒤 역순으로 뒤집은 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array).
**예시**
**예시 1**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
```
```response title=Response theme={null}
[5,3,4]
```
**예시 2**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
```
```response title=Response theme={null}
[4,3,5]
```
## arrayReverseSplit
도입 버전: v20.1.0
소스 배열을 여러 배열로 분할합니다. `func(x[, y1, ..., yN])`가 0이 아닌 값을 반환하면 해당 요소의 오른쪽을 기준으로 배열이 분할됩니다. 마지막 요소 뒤에서는 배열이 분할되지 않습니다.
**구문**
```sql theme={null}
arrayReverseSplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 적용되는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
배열의 배열을 반환합니다. [`Array(Array(T))`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[1], [2, 3, 4], [5]]
```
## arrayRotateLeft
도입 버전: v23.8.0
배열을 지정된 개수의 요소만큼 왼쪽으로 순환 이동합니다. `n`이 음수이면 회전량의 절댓값만큼 오른쪽으로 순환 이동하는 것으로 처리됩니다.
**구문**
```sql theme={null}
arrayRotateLeft(arr, n)
```
**인수**
* `arr` — 요소를 회전시킬 배열입니다.[`Array(T)`](/ko/reference/data-types/array). - `n` — 회전할 요소의 개수입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint).
**반환 값**
지정된 개수만큼 요소를 왼쪽으로 회전한 배열입니다 [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,1,2]
```
**n이 음수인 경우**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[5,6,1,2,3,4]
```
## arrayRotateRight
도입 버전: v23.8.0
배열을 지정된 수의 요소만큼 오른쪽으로 순환 이동합니다. `n`의 음수 값은 회전 크기의 절댓값만큼 왼쪽으로 순환 이동하는 것으로 처리됩니다.
**구문**
```sql theme={null}
arrayRotateRight(arr, n)
```
**인수**
* `arr` — 요소를 회전할 대상 배열입니다.[`Array(T)`](/ko/reference/data-types/array). - `n` — 회전할 요소 개수입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint).
**반환 값**
지정된 개수만큼 요소를 오른쪽으로 회전한 배열입니다 [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[5,6,1,2,3,4]
```
**n이 음수인 경우**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[3,4,5,6,1,2]
```
## arrayShiftLeft
도입 버전: v23.8.0
배열을 지정한 요소 수만큼 왼쪽으로 이동합니다.
새 요소는 제공된 인수나 배열 요소 타입의 기본값으로 채워집니다.
요소 수가 음수이면 배열은 오른쪽으로 이동합니다.
**구문**
```sql theme={null}
arrayShiftLeft(arr, n[, default])
```
**인수**
* `arr` — 요소를 이동할 대상 배열입니다.[`Array(T)`](/ko/reference/data-types/array). - `n` — 이동할 요소 수입니다.[`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint). - `default` — 선택 사항입니다. 새 요소에 사용할 기본값입니다.
**반환 값**
지정한 개수만큼 왼쪽으로 이동된 배열입니다 [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,0,0]
```
**n이 음수인 경우**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[0,0,1,2,3,4]
```
**기본값 사용하기**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;
```
```response title=Response theme={null}
[3,4,5,6,42,42]
```
## arrayShiftRight
도입 버전: v23.8.0
지정한 수의 요소만큼 배열을 오른쪽으로 이동합니다.
새로 생기는 요소는 제공된 인수 또는 배열 요소 타입의 기본값으로 채워집니다.
요소 수가 음수이면 배열은 왼쪽으로 이동합니다.
**구문**
```sql theme={null}
arrayShiftRight(arr, n[, default])
```
**인수**
* `arr` — 요소를 이동할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `n` — 이동할 요소의 개수입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint)
* `default` — 선택 사항입니다. 새 요소에 사용할 기본값입니다.
**반환 값**
지정된 개수만큼 요소를 오른쪽으로 이동한 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;
```
```response title=Response theme={null}
[0, 0, 1, 2, 3, 4]
```
**n이 음수인 경우**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;
```
```response title=Response theme={null}
[3, 4, 5, 6, 0, 0]
```
**기본값 사용하기**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;
```
```response title=Response theme={null}
[42, 42, 1, 2, 3, 4]
```
## arrayShingles
도입 버전: v24.1.0
입력 배열에서 지정된 길이의 연속된 하위 배열, 즉 shingle의 배열(문자열의 ngram과 유사함)을 생성합니다.
**구문**
```sql theme={null}
arrayShingles(arr, l)
```
**인수**
* `arr` — shingle 배열을 생성할 대상 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `l` — 각 shingle의 길이입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
생성된 shingle 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayShingles([1, 2, 3, 4], 3) as res;
```
```response title=Response theme={null}
[[1, 2, 3], [2, 3, 4]]
```
## arrayShuffle
도입 버전: v23.2.0
원본 배열과 동일한 크기의 배열을 반환하며, 요소는 무작위로 섞인 순서로 포함됩니다.
요소는 가능한 모든 순열이 동일한 확률로 나타나도록 재배열됩니다.
이 함수는 상수를 구체화하지 않습니다.
**구문**
```sql theme={null}
arrayShuffle(arr [, seed])
```
**인수**
* `arr` — 섞을 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `seed (optional)` — 선택 사항입니다. 난수 생성에 사용할 시드입니다. 지정하지 않으면 임의의 시드가 사용됩니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
요소가 섞인 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**시드 없이 사용하는 예시(결과가 일정하지 않음)**
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4]);
```
```response title=Response theme={null}
[1,4,2,3]
```
**seed 없이 사용하는 예시(일관된 결과)**
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4], 41);
```
```response title=Response theme={null}
[3,2,1,4]
```
## arraySimilarity
도입 버전: v25.4.0
가중치가 적용된 Levenshtein 거리를 기준으로 `0`부터 `1`까지 두 배열의 유사도를 계산합니다.
**구문**
```sql theme={null}
arraySimilarity(from, to, from_weights, to_weights)
```
**인수**
* `from` — 첫 번째 배열 [`Array(T)`](/ko/reference/data-types/array)
* `to` — 두 번째 배열 [`Array(T)`](/ko/reference/data-types/array)
* `from_weights` — 첫 번째 배열의 가중치입니다. [`Array((U)Int*|Float*)`](/ko/reference/data-types/array)
* `to_weights` — 두 번째 배열의 가중치입니다. [`Array((U)Int*|Float*)`](/ko/reference/data-types/array)
**반환 값**
가중치가 적용된 Levenshtein distance를 기준으로 계산한 두 배열의 `0`과 `1` 사이 유사도를 반환합니다. [`Float64`](/ko/reference/data-types/float)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);
```
```response title=Response theme={null}
0.2222222222222222
```
## arraySlice
도입 버전: v1.1.0
`NULL` 요소를 포함한 배열의 슬라이스를 반환합니다.
**구문**
```sql theme={null}
arraySlice(arr, offset [, length])
```
**인수**
* `arr` — 슬라이스할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `offset` — 배열의 끝에서부터의 오프셋입니다. 양수 값은 왼쪽부터의 오프셋을, 음수 값은 오른쪽부터의 들여쓰기를 나타냅니다. 배열 항목의 번호는 `1`부터 시작합니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
* `length` — 필요한 슬라이스의 길이입니다. 음수 값을 지정하면 함수는 끝이 열린 슬라이스 `[offset, array_length - length]`를 반환합니다. 값을 생략하면 함수는 슬라이스 `[offset, the_end_of_array]`를 반환합니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
지정된 `offset`부터 `length`개의 요소를 포함하는 배열 슬라이스를 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
```
```response title=Response theme={null}
[2, NULL, 4]
```
## arraySort
도입된 버전: v1.1.0
주어진 배열의 요소를 오름차순으로 정렬합니다.
람다 함수 `f`를 지정하면 정렬 순서는
배열의 각 요소에 람다 함수를 적용한 결과에 따라 결정됩니다.
람다 함수가 여러 인수를 받는 경우 `arraySort` 함수에 여러 개의
배열이 전달되며, 이 배열들은 `f`의 인수에 각각 대응합니다.
정렬할 배열에 `-Inf`, `NULL`, `NaN`, `Inf`가 포함된 경우 다음 순서로 정렬됩니다:
1. `-Inf`
2. `Inf`
3. `NaN`
4. `NULL`
`arraySort`는 [고차 함수](/ko/reference/functions/regular-functions/overview#higher-order-functions)입니다.
**구문**
```sql theme={null}
arraySort([f,] arr [, arr1, ... ,arrN])
```
**인수**
* `f(y1[, y2 ... yN])` — 배열 `x`의 요소에 적용할 람다 함수입니다. - `arr` — 정렬할 배열입니다. [`Array(T)`](/ko/reference/data-types/array) - `arr1, ..., yN` — 선택 사항입니다. `f`가 여러 인수를 받는 경우 사용할 추가 배열 N개입니다.
**반환 값**
람다 함수가 제공되지 않으면 배열 `arr`를 오름차순으로 정렬해 반환하고, 그렇지 않으면
제공된 람다 함수의 로직에 따라 정렬된 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array).
**예시**
**예시 1**
```sql title=Query theme={null}
SELECT arraySort([1, 3, 3, 0]);
```
```response title=Response theme={null}
[0,1,3,3]
```
**예시 2**
```sql title=Query theme={null}
SELECT arraySort(['hello', 'world', '!']);
```
```response title=Response theme={null}
['!','hello','world']
```
**예시 3**
```sql title=Query theme={null}
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
```
```response title=Response theme={null}
[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]
```
## arraySplit
도입 버전: v20.1.0
소스 배열을 여러 개의 배열로 분할합니다. `func(x [, y1, ..., yN])`가 0이 아닌 값을 반환하면 해당 요소의 왼쪽을 기준으로 배열이 분할됩니다. 첫 번째 요소 앞에서는 배열이 분할되지 않습니다.
**구문**
```sql theme={null}
arraySplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 소스 배열(`x`)과 조건 배열(`y`)의 요소에 적용되는 람다 함수입니다.[람다 함수](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — 분할할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array).
**반환 값**
배열의 배열 [`Array(Array(T))`](/ko/reference/data-types/array)을 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[1, 2, 3], [4, 5]]
```
## arraySum
v21.1.0에서 도입됨
소스 배열 요소의 합계를 반환합니다.
람다 함수 `func`가 지정된 경우, 람다 함수 결과 요소의 합계를 반환합니다.
**구문**
```sql theme={null}
arraySum([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**인수**
* `func(x[, y1, ..., yN])` — 선택 사항입니다. 소스 배열(`x`)과 조건 배열(`y`)의 요소에 대해 작동하는 람다 함수입니다. [`람다 함수`](/ko/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — 처리할 소스 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `, cond1_arr, ... , condN_arr]` — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열 요소의 합을 반환합니다. 람다 함수가 제공된 경우에는 람다 함수 결과 요소의 합을 반환합니다.
**예시**
**기본 예시**
```sql title=Query theme={null}
SELECT arraySum([1, 2, 3, 4]);
```
```response title=Response theme={null}
10
```
**람다 함수와 함께 사용**
```sql title=Query theme={null}
SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);
```
```response title=Response theme={null}
8
```
## arraySymmetricDifference
도입 버전: v25.4.0
여러 배열을 받아, 모든 소스 배열에 공통으로 존재하지 않는 요소들로 이루어진 배열을 반환합니다. 결과에는 고유한 값만 포함됩니다.
*2개를 초과하는 집합*의 대칭차는 [수학적으로](https://en.wikipedia.org/wiki/Symmetric_difference#n-ary_symmetric_difference) 정의되며,
입력 집합 중 홀수 개의 집합에 포함되는 모든 요소의 집합을 의미합니다.
반면 `arraySymmetricDifference` 함수는 단순히 모든 입력 집합에 공통으로 포함되지 않는 요소들의 집합을 반환합니다.
**구문**
```sql theme={null}
arraySymmetricDifference(arr1, arr2, ... , arrN)
```
**인수**
* `arrN` — 새 배열을 만드는 데 사용되는 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array).
**반환 값**
모든 소스 배열에 공통으로 존재하지 않는 고유 요소로 이루어진 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;
```
```response title=Response theme={null}
┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ [] │ [3,2] │
└────────────────────────────┴────────────────────────────────┘
```
## arrayTranspose
추가된 버전: v26.4.0
2차원 배열을 전치합니다.
모든 내부 배열의 길이는 동일해야 합니다.
**구문**
```sql theme={null}
arrayTranspose(arr)
```
**인수**
* `arr` — 전치할 2차원 배열입니다. 모든 내부 배열의 길이는 동일해야 합니다. [`Array(Array(T))`](/ko/reference/data-types/array)
**반환 값**
결과의 원소 `[i][j]`가 입력의 원소 `[j][i]`와 같은 전치된 2차원 배열입니다. [`Array(Array(T))`](/ko/reference/data-types/array)
**예시**
**정사각 행렬**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2], [3, 4]])
```
```response title=Response theme={null}
[[1, 3], [2, 4]]
```
**비정방 행렬**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])
```
```response title=Response theme={null}
[[1, 4], [2, 5], [3, 6]]
```
**String 타입 요소**
```sql title=Query theme={null}
SELECT arrayTranspose([['a', 'b'], ['c', 'd']])
```
```response title=Response theme={null}
[['a', 'c'], ['b', 'd']]
```
## arrayUnion
도입 버전: v24.10.0
여러 배열을 받아 소스 배열 중 하나 이상에 있는 모든 요소를 포함하는 배열을 반환합니다. 결과에는 고유한 값만 포함됩니다.
**구문**
```sql theme={null}
arrayUnion(arr1, arr2, ..., arrN)
```
**인수**
* `arrN` — 새 배열을 구성하는 데 사용할 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열들에서 중복을 제거한 요소로 이루어진 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT
arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example
```
```response title=Response theme={null}
┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1] │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘
```
## arrayUniq
도입 버전: v1.1.0
단일 인수가 전달되면 배열에서 서로 다른 요소의 수를 계산합니다.
여러 인수가 전달되면 여러 배열의 같은 위치에 있는 요소들로 구성된 서로 다른 **튜플**의 수를 계산합니다.
예를 들어 `SELECT arrayUniq([1,2], [3,4], [5,6])`는 다음과 같은 튜플을 만듭니다:
* 위치 1: (1,3,5)
* 위치 2: (2,4,6)
그런 다음 고유한 튜플의 수를 계산합니다. 이 경우는 `2`입니다.
전달되는 모든 배열의 길이는 같아야 합니다.
배열에서 고유한 항목 목록을 얻으려면 `arrayReduce('groupUniqArray', arr)`를 사용할 수 있습니다.
**구문**
```sql theme={null}
arrayUniq(arr1[, arr2, ..., arrN])
```
**인수**
* `arr1` — 고유 요소의 개수를 계산할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `[, arr2, ..., arrN]` — 선택 사항입니다. 여러 배열의 같은 위치에 있는 요소들로 이루어진 고유 튜플의 개수를 계산할 때 사용하는 추가 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
단일 인수의 경우 고유 요소의 개수를 반환합니다. 여러 인수의 경우 배열들의 같은 위치에 있는 요소들로 이루어진 고유 튜플의 개수를 반환합니다.
[`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**단일 인수**
```sql title=Query theme={null}
SELECT arrayUniq([1, 1, 2, 2])
```
```response title=Response theme={null}
2
```
**다중 인수**
```sql title=Query theme={null}
SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])
```
```response title=Response theme={null}
3
```
## arrayWithConstant
도입 버전: v20.1.0
상수 `x`로 채운 길이 `length`의 배열을 생성합니다.
**구문**
```sql theme={null}
arrayWithConstant(N, x)
```
**인수**
* `length` — 배열의 요소 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
* `x` — 배열의 `N`개 요소에 들어갈 값으로, 타입은 임의입니다.
**반환 값**
값이 `x`인 `N`개 요소로 이루어진 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayWithConstant(3, 1)
```
```response title=Response theme={null}
[1, 1, 1]
```
## arrayZip
도입 버전: v20.1.0
여러 배열을 하나의 배열로 결합합니다. 결과 배열에는 소스 배열의 대응하는 요소들이 인수에 나열된 순서대로 튜플로 묶여 포함됩니다.
**구문**
```sql theme={null}
arrayZip(arr1, arr2, ... , arrN)
```
**인수**
* `arr1, arr2, ... , arrN` — 하나의 배열로 결합할 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열의 요소를 튜플로 묶은 배열을 반환합니다. 튜플의 데이터 타입은 입력 배열의 타입과 동일하며, 배열이 전달된 순서도 유지됩니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
```
```response title=Response theme={null}
[('a', 5), ('b', 2), ('c', 1)]
```
## arrayZipUnaligned
도입 버전: v20.1.0
여러 배열을 하나의 배열로 결합하며, 길이가 서로 다른 배열도 허용합니다. 결과 배열에는 소스 배열의 각 대응 요소가 인수에 나열된 순서대로 튜플로 묶여 포함됩니다.
**구문**
```sql theme={null}
arrayZipUnaligned(arr1, arr2, ..., arrN)
```
**인수**
* `arr1, arr2, ..., arrN` — 하나의 배열로 결합할 N개의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
소스 배열의 요소들을 튜플로 묶은 배열을 반환합니다. 튜플의 데이터 타입은 입력 배열의 타입과 동일하며, 배열이 전달된 순서와 같습니다. [`Array(T)`](/ko/reference/data-types/array) 또는 [`Tuple(T1, T2, ...)`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT arrayZipUnaligned(['a'], [1, 2, 3]);
```
```response title=Response theme={null}
[('a', 1),(NULL, 2),(NULL, 3)]
```
## countEqual
도입 버전: v1.1.0
배열에서 `x`와 같은 값의 요소 수를 반환합니다. `arrayCount(elem -> elem = x, arr)`와 동일합니다.
`NULL` 요소는 서로 구분되는 별도의 값으로 처리됩니다.
**구문**
```sql theme={null}
countEqual(arr, x)
```
**인수**
* `arr` — 검색할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `x` — 배열에서 개수를 셀 값입니다. 모든 타입이 가능합니다.
**반환 값**
배열에서 `x`와 같은 요소 수를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT countEqual([1, 2, NULL, NULL], NULL)
```
```response title=Response theme={null}
2
```
## empty
지원 시작 버전: v1.1.0
입력 배열이 비어 있는지 확인합니다.
배열에 요소가 하나도 없으면 빈 것으로 간주됩니다.
[`optimize_functions_to_subcolumns` 설정](/ko/reference/settings/session-settings#optimize_functions_to_subcolumns)을 활성화하면 최적화할 수 있습니다. `optimize_functions_to_subcolumns = 1`이면 함수는 전체 배열 컬럼을 읽고 처리하는 대신 [size0](/ko/reference/data-types/array#array-size) 서브컬럼만 읽습니다. 쿼리 `SELECT empty(arr) FROM TABLE;`는 `SELECT arr.size0 = 0 FROM TABLE;`로 변환됩니다.
이 함수는 String 또는 UUID 타입에도 사용할 수 있습니다.
**구문**
```sql theme={null}
empty(arr)
```
**인수**
* `arr` — 입력 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
배열이 비어 있으면 `1`, 비어 있지 않으면 `0`을 반환합니다 [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT empty([]);
```
```response title=Response theme={null}
1
```
## emptyArrayDate
도입 버전: v1.1.0
비어 있는 Date 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayDate()
```
**인수**
* 없음.
**반환 값**
빈 Date 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayDate
```
```response title=Response theme={null}
[]
```
## emptyArrayDateTime
v1.1.0에서 도입됨
빈 DateTime 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayDateTime()
```
**인수**
* 없습니다.
**반환 값**
빈 DateTime 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayDateTime
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat32
도입된 버전: v1.1.0
비어 있는 Float32 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayFloat32()
```
**인수**
* 없음.
**반환 값**
빈 Float32 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayFloat32
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat64
v1.1.0에 도입됨
빈 Float64 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayFloat64()
```
**인수**
* 없습니다.
**반환 값**
비어 있는 Float64 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayFloat64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt16
도입 버전: v1.1.0
빈 Int16 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayInt16()
```
**인수**
* 없음
**반환 값**
비어 있는 Int16 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayInt32
도입 버전: v1.1.0
빈 Int32 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayInt32()
```
**인수**
* 없음.
**반환 값**
비어 있는 Int32 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayInt64
도입 버전: v1.1.0
빈 Int64 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayInt64()
```
**인수**
* 없습니다.
**반환 값**
비어 있는 Int64 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt8
도입 버전: v1.1.0
빈 Int8 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayInt8()
```
**인수**
* 없음.
**반환 값**
빈 Int8 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayInt8
```
```response title=Response theme={null}
[]
```
## emptyArrayString
v1.1.0에 도입됨
빈 String 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayString()
```
**인수**
* 없음.
**반환 값**
비어 있는 `String` 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayString
```
```response title=Response theme={null}
[]
```
## emptyArrayToSingle
다음 버전에서 도입됨: v1.1.0
빈 배열을 받아 기본값과 동일한 단일 요소 배열을 반환합니다.
**구문**
```sql theme={null}
emptyArrayToSingle(arr)
```
**인수**
* `arr` — 비어 있는 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
배열의 기본 타입 기본값 1개를 포함하는 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**기본 예시**
```sql title=Query theme={null}
CREATE TABLE test (
a Array(Int32),
b Array(String),
c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();
INSERT INTO test VALUES ([], [], []);
SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;
```
```response title=Response theme={null}
┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0] │ [''] │ ['1970-01-01 01:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘
```
## emptyArrayUInt16
v1.1.0에서 도입됨
빈 UInt16 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayUInt16()
```
**인수**
* 없습니다.
**반환 값**
비어 있는 UInt16 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayUInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt32
도입 버전: v1.1.0
빈 UInt32 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayUInt32()
```
**인수**
* 없습니다.
**반환 값**
비어 있는 UInt32 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayUInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt64
도입 버전: v1.1.0
비어 있는 UInt64 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayUInt64()
```
**인수**
* 없습니다.
**반환 값**
비어 있는 UInt64 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayUInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt8
도입 버전: v1.1.0
빈 UInt8 배열을 반환합니다
**구문**
```sql theme={null}
emptyArrayUInt8()
```
**인수**
* 없습니다.
**반환 값**
빈 UInt8 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT emptyArrayUInt8
```
```response title=Response theme={null}
[]
```
## has
도입 버전: v1.1.0
배열에 지정된 요소가 있는지, 맵에 지정된 키가 있는지, 또는 JSON 객체에 지정된 경로가 있는지를 반환합니다.
JSON에서는 점 표기법(예: 'a.b.c')을 사용해 중첩 경로를 지원합니다.
첫 번째 인수가 상수 배열이고 두 번째 인수가 컬럼 또는 표현식인 경우, `has(constant_array, column)`은 `column IN (constant_array)`와 같이 동작하며 최적화를 위해 기본 키(primary key) 및 데이터 스키핑 인덱스(data-skipping indexes)를 사용할 수 있습니다. 예를 들어 `has([1, 10, 100], id)`는 `id`가 `PRIMARY KEY`의 일부이면 기본 키 인덱스를 활용할 수 있습니다.
이 최적화는 컬럼이 단조 함수(monotonic function)로 감싸진 경우에도 적용됩니다(예: `has([...], toDate(ts))`).
**구문**
```sql theme={null}
has(haystack, needle)
```
**인수**
* `haystack` — 소스 배열, 맵 또는 JSON입니다. [`Array`](/ko/reference/data-types/array) 또는 [`Map`](/ko/reference/data-types/map) 또는 [`JSON`](/ko/reference/data-types/newjson)
* `needle` — 검색할 값입니다(배열의 요소, 맵의 키 또는 JSON의 경로 문자열).
**반환 값**
`haystack`에 지정한 `needle`이 포함되어 있으면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**배열 기본 사용법**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 2)
```
```response title=Response theme={null}
1
```
**배열을 찾을 수 없습니다**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 4)
```
```response title=Response theme={null}
0
```
**맵 기본 사용법**
```sql title=Query theme={null}
SELECT has(map('a', 1, 'b', 2), 'b')
```
```response title=Response theme={null}
1
```
**JSON 경로**
```sql title=Query theme={null}
SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')
```
```response title=Response theme={null}
1
```
## hasAll
도입 버전: v1.1.0
한 배열이 다른 배열의 부분집합인지 확인합니다.
* 빈 배열은 모든 배열의 부분집합입니다.
* `NULL`은 값으로 처리됩니다.
* 두 배열의 값 순서는 중요하지 않습니다.
**구문**
```sql theme={null}
hasAll(set, subset)
```
**인수**
* `set` — 요소 집합을 담고 있는 임의 타입의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `subset` — `set`와 공통 상위 타입을 가지며, `set`의 부분집합인지 검사할 요소를 담고 있는 임의 타입의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
* `set`에 `subset`의 모든 요소가 포함되어 있으면 `1`입니다.
* 그렇지 않으면 `0`입니다.
`set`과 `subset`의 요소가 공통 상위 타입을 갖지 않으면 `NO_COMMON_TYPE` 예외가 발생합니다.
**예시**
**빈 배열**
```sql title=Query theme={null}
SELECT hasAll([], [])
```
```response title=Response theme={null}
1
```
**NULL 값이 포함된 배열**
```sql title=Query theme={null}
SELECT hasAll([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**서로 다른 자료형의 값을 포함하는 배열**
```sql title=Query theme={null}
SELECT hasAll([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
1
```
**String 값이 포함된 배열**
```sql title=Query theme={null}
SELECT hasAll(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**공통 타입이 없는 배열**
```sql title=Query theme={null}
SELECT hasAll([1], ['a'])
```
```response title=Response theme={null}
NO_COMMON_TYPE 예외가 발생합니다
```
**중첩 배열**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])
```
```response title=Response theme={null}
0
```
## hasAny
도입 버전: v1.1.0
두 배열에 공통 요소가 있는지 확인합니다.
* `Null`은 값으로 처리됩니다.
* 두 배열의 값 순서는 중요하지 않습니다.
**구문**
```sql theme={null}
hasAny(arr_x, arr_y)
```
**인수**
* `arr_x` — 요소 집합을 가진 임의 타입의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `arr_y` — 배열 `arr_x`와 공통 상위 타입을 갖는 임의 타입의 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
* `1` — `arr_x`와 `arr_y`에 공통 요소가 하나 이상 있는 경우입니다.
* `0` — 그 밖의 경우입니다.
두 배열의 요소 중 하나라도 공통 상위 타입을 갖지 않으면 `NO_COMMON_TYPE` 예외가 발생합니다.
**예시**
**한 배열이 비어 있는 경우**
```sql title=Query theme={null}
SELECT hasAny([1], [])
```
```response title=Response theme={null}
0
```
**NULL 값이 포함된 배열**
```sql title=Query theme={null}
SELECT hasAny([Null], [Null, 1])
```
```response title=Response theme={null}
1
```
**서로 다른 타입의 값을 포함하는 배열**
```sql title=Query theme={null}
SELECT hasAny([-128, 1., 512], [1])
```
```response title=Response theme={null}
1
```
**공통 유형이 없는 배열**
```sql title=Query theme={null}
SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])
```
```response title=Response theme={null}
`NO_COMMON_TYPE` 예외가 발생합니다
```
**중첩 배열**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])
```
```response title=Response theme={null}
1
```
## hasSubstr
도입 버전: v20.6.0
array2의 모든 요소가 array1에 정확히 같은 순서로 나타나는지 확인합니다.
따라서 array1 = prefix + array2 + suffix인 경우에만 함수는 `1`을 반환합니다.
즉, 이 함수는 `hasAll` 함수처럼 array2의 모든 요소가 array1에 포함되어 있는지 확인합니다.
추가로, array1과 array2에서 요소가 동일한 순서로 나타나는지도 확인합니다.
* array2가 비어 있으면 함수는 `1`을 반환합니다.
* `NULL`은 값으로 처리됩니다. 즉, `hasSubstr([1, 2, NULL, 3, 4], [2,3])`는 `0`을 반환합니다. 반면 `hasSubstr([1, 2, NULL, 3, 4], [2,NULL,3])`는 `1`을 반환합니다.
* 두 배열의 값 순서는 중요합니다.
두 배열의 요소 중 공통 상위 타입이 없는 요소가 하나라도 있으면 `NO_COMMON_TYPE` 예외를 발생시킵니다.
**구문**
```sql theme={null}
hasSubstr(arr1, arr2)
```
**인수**
* `arr1` — 원소 집합으로 이루어진 임의 타입의 배열. [`Array(T)`](/ko/reference/data-types/array)
* `arr2` — 원소 집합으로 이루어진 임의 타입의 배열. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
배열 `arr1`에 배열 `arr2`가 포함되어 있으면 `1`을 반환합니다. 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**두 배열이 모두 비어 있는 경우**
```sql title=Query theme={null}
SELECT hasSubstr([], [])
```
```response title=Response theme={null}
1
```
**NULL 값을 포함한 배열**
```sql title=Query theme={null}
SELECT hasSubstr([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**서로 다른 유형의 값을 포함하는 배열**
```sql title=Query theme={null}
SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
0
```
**문자열이 포함된 배열**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**유효한 순서를 가진 배열**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])
```
```response title=Response theme={null}
1
```
**정렬 순서가 잘못된 배열**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])
```
```response title=Response theme={null}
0
```
**중첩 배열**
```sql title=Query theme={null}
SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])
```
```response title=Response theme={null}
1
```
**공통 타입이 없는 배열**
```sql title=Query theme={null}
SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])
```
```response title=Response theme={null}
`NO_COMMON_TYPE` 예외가 발생합니다
```
## indexOf
도입 버전: v1.1.0
배열에 값 'x'를 가진 첫 번째 요소가 있으면 그 요소의 인덱스(1부터 시작)를 반환합니다.
배열에 찾는 값이 없으면 함수는 `0`을 반환합니다.
`NULL`로 설정된 요소도 일반 값처럼 처리됩니다.
**구문**
```sql theme={null}
indexOf(arr, x)
```
**인수**
* `arr` — `x`를 찾을 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `x` — `arr`에서 인덱스를 반환할 첫 번째 일치 요소의 값입니다. [`UInt64`](/ko/reference/data-types/int-uint)
**반환 값**
존재하면 `arr`에서 첫 번째 `x`의 인덱스(1부터 시작)를 반환합니다. 그렇지 않으면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**기본 예시**
```sql title=Query theme={null}
SELECT indexOf([5, 4, 1, 3], 3)
```
```response title=Response theme={null}
4
```
**NULL을 포함하는 배열**
```sql title=Query theme={null}
SELECT indexOf([1, 3, NULL, NULL], NULL)
```
```response title=Response theme={null}
3
```
## indexOfAssumeSorted
도입 버전: v24.12.0
배열에 값이 'x'인 요소가 있으면 첫 번째 요소의 인덱스(`1`부터 시작)를 반환합니다.
배열에 찾는 값이 없으면 함수는 `0`을 반환합니다.
`indexOf` 함수와 달리, 이 함수는 배열이
오름차순으로 정렬되어 있다고 가정합니다. 배열이 정렬되어 있지 않으면 결과는 정의되지 않습니다.
**구문**
```sql theme={null}
indexOfAssumeSorted(arr, x)
```
**인수**
* `arr` — 검색할 정렬된 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `x` — 정렬된 `arr`에서 처음 일치하는 요소의 값으로, 해당 요소의 인덱스를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**반환 값**
`arr`에 `x`가 있으면 첫 번째 `x`의 인덱스(1부터 시작)를 반환합니다. 없으면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**기본 예시**
```sql title=Query theme={null}
SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)
```
```response title=Response theme={null}
5
```
## kql\_array\_sort\_asc
도입 버전: v23.10.0
하나 이상의 배열을 오름차순으로 정렬합니다. 첫 번째 배열을 정렬하고, 이후 배열은 첫 번째 배열의 정렬된 순서에 맞춰 재배열됩니다. NULL 값은 끝에 배치됩니다. 이 함수는 KQL(Kusto Query Language) 호환 함수입니다.
**구문**
```sql theme={null}
kql_array_sort_asc(array1[, array2, ..., nulls_last])
```
**인수**
* `array1` — 정렬할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `array2` — 선택 사항입니다. `array1`의 정렬 순서에 맞춰 재정렬할 추가 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `nulls_last` — 선택 사항입니다. null 값을 마지막에 배치할지 여부를 나타내는 불리언 값입니다. 기본값은 true입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
오름차순으로 정렬된 배열의 튜플을 반환합니다. [`Tuple(Array, ...)`](/ko/reference/data-types/tuple)
**예시**
**기본 사용법**
```sql title=Query theme={null}
SELECT kql_array_sort_asc([3, 1, 2])
```
```response title=Response theme={null}
([1, 2, 3])
```
## kql\_array\_sort\_desc
도입 버전: v23.10.0
하나 이상의 배열을 내림차순으로 정렬합니다. 첫 번째 배열이 정렬되고, 그 뒤의 배열은 첫 번째 배열의 정렬된 순서에 맞춰 다시 정렬됩니다. NULL 값은 맨 끝에 배치됩니다. 이 함수는 KQL(Kusto Query Language) 호환 함수입니다.
**구문**
```sql theme={null}
kql_array_sort_desc(array1[, array2, ..., nulls_last])
```
**인수**
* `array1` — 정렬할 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `array2` — `array1`의 정렬 순서에 맞춰 다시 정렬할 선택적 추가 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
* `nulls_last` — null 값이 마지막에 오도록 할지 여부를 나타내는 선택적 불리언 값입니다. 기본값은 true입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
내림차순으로 정렬된 배열 튜플을 반환합니다. [`Tuple(Array, ...)`](/ko/reference/data-types/tuple)
**예시**
**기본 사용법**
```sql title=Query theme={null}
SELECT kql_array_sort_desc([3, 1, 2])
```
```response title=Response theme={null}
([3, 2, 1])
```
## length
도입 버전: v1.1.0
문자열 또는 배열의 길이를 계산합니다.
* String 또는 FixedString 인수의 경우 문자열의 바이트 수를 계산합니다.
* Array 인수의 경우 배열의 요소 수를 계산합니다.
* FixedString 인수에 적용하면 이 함수는 상수 표현식입니다.
문자열의 바이트 수는
유니코드 "코드 포인트"의 개수와 같지 않으며, 유니코드 "grapheme clusters"
(일반적으로 "문자"라고 부르는 것)의 개수와도 같지 않고, 화면에 표시되는 문자열 너비와도 같지 않다는 점에 유의하십시오.
문자열에 ASCII NULL 바이트가 포함되어 있어도 문제없으며, 이 역시 계산에 포함됩니다.
**구문**
```sql theme={null}
length(x)
```
**별칭**: `OCTET_LENGTH`
**인수**
* `x` — 바이트 수(String/FixedString) 또는 요소 수(Array)를 계산할 값입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring) 또는 [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
String/FixedString `x`의 바이트 수 또는 배열 `x`의 요소 수를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**String 예시**
```sql title=Query theme={null}
SELECT length('Hello, world!')
```
```response title=Response theme={null}
13
```
**배열 예시**
```sql title=Query theme={null}
SELECT length(['Hello', 'world'])
```
```response title=Response theme={null}
2
```
**constexpr 예시**
```sql title=Query theme={null}
WITH 'hello' || toString(number) AS str
SELECT str,
isConstant(length(str)) AS str_length_is_constant,
isConstant(length(str::FixedString(6))) AS fixed_str_length_is_constant
FROM numbers(3)
```
```response title=Response theme={null}
┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │ 0 │ 1 │
│ hello1 │ 0 │ 1 │
│ hello2 │ 0 │ 1 │
└────────┴────────────────────────┴──────────────────────────────┘
```
**유니코드 예시**
```sql title=Query theme={null}
SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)
```
```response title=Response theme={null}
┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │ 8 │ 4 │ ёлка │ 10 │ 5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘
```
**ascii\_vs\_utf8 예시**
```sql title=Query theme={null}
SELECT 'ábc' AS str, length(str), lengthUTF8(str)
```
```response title=Response theme={null}
┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │ 4 │ 3 │
└─────┴──────────────┴─────────────────┘
```
## notEmpty
도입 버전: v1.1.0
입력 배열이 비어 있지 않은지 확인합니다.
배열에 요소가 하나 이상 있으면 비어 있지 않은 것으로 간주합니다.
[`optimize_functions_to_subcolumns`](/ko/reference/settings/session-settings#optimize_functions_to_subcolumns) 설정을 활성화하면 최적화할 수 있습니다. `optimize_functions_to_subcolumns = 1`이면 이 함수는 전체 배열 컬럼을 읽고 처리하는 대신 [size0](/ko/reference/data-types/array#array-size) 서브컬럼만 읽습니다. 쿼리 `SELECT notEmpty(arr) FROM table`는 `SELECT arr.size0 != 0 FROM TABLE`로 변환됩니다.
이 함수는 String 및 UUID에도 사용할 수 있습니다.
**구문**
```sql theme={null}
notEmpty(arr)
```
**인수**
* `arr` — 입력 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
배열이 비어 있지 않으면 `1`을, 비어 있으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT notEmpty([1,2]);
```
```response title=Response theme={null}
1
```
## range
도입 버전: v1.1.0
`start`부터 `end - 1`까지 `step` 간격으로 숫자 배열을 반환합니다.
지원되는 타입은 다음과 같습니다.
* `UInt8/16/32/64`
* `Int8/16/32/64]`
* 모든 인수 `start`, `end`, `step`은 위에 나열된 지원 타입 중 하나여야 합니다. 반환되는 배열의 요소 타입은 인수들의 공통 상위 타입이 됩니다.
* 함수가 설정 [`function_range_max_elements_in_block`](/ko/reference/settings/session-settings#function_range_max_elements_in_block)에서 지정한 요소 수를 초과하는 전체 길이의 배열을 반환하면 예외가 발생합니다.
* 인수 중 하나라도 Nullable(nothing) 타입이면 `NULL`을 반환합니다. 인수 중 하나라도 `NULL` 값(Nullable(T) 타입)이면 예외가 발생합니다.
**구문**
```sql theme={null}
range([start, ] end [, step])
```
**인수**
* `start` — 선택 사항입니다. 배열의 첫 번째 요소입니다. `step`을 사용하는 경우 필수입니다. 기본값: `0`. - `end` — 필수입니다. 배열이 이 값 직전까지 생성됩니다. - `step` — 선택 사항입니다. 배열의 각 요소 사이의 증가 간격을 지정합니다. 기본값: `1`.
**반환 값**
`start`부터 `end - 1`까지 `step` 간격의 숫자 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);
```
```response title=Response theme={null}
┌─range(5)────┬─range(1, 5)─┬─range(1, 5, 2)─┬─range(-1, 5, 2)─┐
│ [0,1,2,3,4] │ [1,2,3,4] │ [1,3] │ [-1,1,3] │
└─────────────┴─────────────┴────────────────┴─────────────────┘
```
## replicate
v1.1.0에 도입됨
단일 값으로 이루어진 배열을 생성합니다.
**구문**
```sql theme={null}
replicate(x, arr)
```
**인수**
* `x` — 결과 배열을 채울 값입니다. [`Any`](/ko/reference/data-types)
* `arr` — 배열입니다. [`Array(T)`](/ko/reference/data-types/array)
**반환 값**
값 `x`로 채운, `arr`와 길이가 같은 배열을 반환합니다. [`Array(T)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT replicate(1, ['a', 'b', 'c']);
```
```response title=Response theme={null}
┌─replicate(1, ['a', 'b', 'c'])───┐
│ [1, 1, 1] │
└─────────────────────────────────┘
```
## reverse
도입 버전: v1.1.0
입력 배열의 요소 순서나 입력 문자열의 문자 순서를 반대로 바꿉니다.
**구문**
```sql theme={null}
reverse(arr | str)
```
**인수**
* `arr | str` — 소스 배열 또는 문자열입니다. [`Array(T)`](/ko/reference/data-types/array) 또는 [`String`](/ko/reference/data-types/string)
**반환 값**
요소 또는 문자의 순서가 역순으로 된 배열 또는 문자열을 반환합니다.
**예시**
**배열 역순**
```sql title=Query theme={null}
SELECT reverse([1, 2, 3, 4]);
```
```response title=Response theme={null}
[4, 3, 2, 1]
```
**문자열 뒤집기**
```sql title=Query theme={null}
SELECT reverse('abcd');
```
```response title=Response theme={null}
'dcba'
```
## 거리 함수
지원되는 모든 함수에 대한 설명은 [거리 함수 문서](/ko/reference/functions/regular-functions/distance-functions)에서 확인할 수 있습니다.