배열 함수

도입 버전: v1.1.0

함수 인수로 배열을 생성합니다.

인수는 상수여야 하며, 서로 공통 상위 타입(common supertype)을 가져야 합니다. 그렇지 않으면 생성할 배열의 타입을 결정할 수 없으므로, 최소 1개의 인수를 전달해야 합니다. 즉, 이 함수로는 빈 배열을 생성할 수 없습니다. 빈 배열을 생성하려면 emptyArray* 함수를 사용하십시오.

동일한 기능에는 [ ] 연산자를 사용하십시오.

구문

array(x1 [, x2, ..., xN])

인수

• x1 — 임의의 타입 T를 갖는 상수 값입니다. 이 인수만 제공되면 배열 타입은 T가 됩니다. - [, x2, ..., xN] — x1과 공통 상위 타입을 갖는 추가 N개의 상수 값

반환 값

전달된 인수들 가운데 가장 작은 공통 타입이 'T'인 배열을 반환합니다. Array(T)

예시

올바른 사용

SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)

┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32)  │
└─────────┴───────────────┘

잘못된 사용법

SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)

┌─a───────────────────────────┬─toTypeName(a)─────────────────────────┐
│ [5,'1998-06-16 00:00:00',5] │ Array(Variant(DateTime, Int32, Int8)) │
└─────────────────────────────┴───────────────────────────────────────┘

도입 버전: v20.4.0

정밀도-재현율(PR) 곡선 아래 면적을 계산합니다. 정밀도-재현율 곡선은 모든 임계값에 대해 y축에 정밀도를, x축에 재현율을 표시하여 만듭니다. 결과값은 0에서 1 사이이며, 값이 높을수록 모델 성능이 더 우수함을 의미합니다. PR AUC는 특히 불균형한 데이터셋에서 유용하며, 이런 경우 ROC AUC보다 성능을 더 명확하게 비교할 수 있게 해줍니다. 자세한 내용은 여기, 여기, 여기를 참조하십시오.

구문

arrayAUCPR(scores, labels[, partial_offsets])

별칭: arrayPRAUC

인수

• cores — 예측 모델이 출력한 점수입니다. Array((U)Int*) 또는 Array(Float*)
• labels — 샘플의 레이블이며, 일반적으로 양성 샘플은 1, 음성 샘플은 0입니다. Array((U)Int*) 또는 Array(Enum)
• partial_offsets —
• 선택 사항입니다. 전체 AUC 대신 PR 곡선 아래의 부분 면적(PR 공간의 수직 밴드에 해당)을 계산하기 위한, 음수가 아닌 정수 3개로 이루어진 Array(T)입니다. 이 옵션은 PR AUC를 분산 계산할 때 유용합니다. 배열에는 다음 요소가 포함되어야 합니다 [higher_partitions_tp, higher_partitions_fp, total_positives].
  • higher_partitions_tp: 더 높은 점수 구간의 파티션에 있는 양성 레이블 수입니다.
  • higher_partitions_fp: 더 높은 점수 구간의 파티션에 있는 음성 레이블 수입니다.
  • total_positives: 전체 데이터셋의 총 양성 샘플 수입니다.

반환 값

정밀도-재현율(PR) 곡선 아래 면적을 반환합니다. Float64

예시

사용 예시

SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                              0.8333333333333333 │
└─────────────────────────────────────────────────┘

도입 버전: v1.1.0

모든 요소에 대해 람다 func(x [, y1, y2, ... yN])의 반환값이 true이면 1을 반환합니다. 그렇지 않으면 0을 반환합니다.

구문

arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 대해 동작하는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• cond1_arr, ... — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

모든 요소에서 람다 함수가 true를 반환하면 1을, 그렇지 않으면 0을 반환합니다. UInt8

예시

모든 요소가 일치하는 경우

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])

1

일치하지 않는 요소가 있습니다

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])

0

도입 버전: v26.4.0

배열의 자기상관을 계산합니다. max_lag가 지정되면 [0, max_lag) 범위의 지연값에 대해서만 상관관계를 계산합니다. max_lag가 지정되지 않으면 가능한 모든 지연값에 대해 계산합니다.

구문

arrayAutocorrelation(arr, [max_lag])

인수

• arr — 숫자 배열입니다. Array(T)
• max_lag — 선택 사항입니다. 계산할 최대 시차 수입니다. 음이 아닌 정수여야 합니다. Integer

반환 값

Float64 배열을 반환합니다. 분산이 0이면 NaN을 반환합니다. Array(Float64)

예시

선형

SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);

[1,0.4,-0.1,-0.4,-0.4]

대칭

SELECT arrayAutocorrelation([10, 20, 10]);

[1,-0.6666666666666669,0.16666666666666674]

상수

SELECT arrayAutocorrelation([5, 5, 5]);

[nan,nan,nan]

제한됨

SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);

[1,0.4]

도입 버전: v21.1.0

소스 배열의 요소 평균을 반환합니다.

람다 함수 func가 지정되면 람다 함수 결과 요소의 평균을 반환합니다.

구문

arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 선택 사항입니다. 소스 배열(x)과 조건 배열(y)의 요소에 대해 동작하는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

소스 배열 요소의 평균을 반환합니다. 람다 결과가 제공되면 그 결과 요소의 평균을 반환합니다. Float64

예시

기본 예시

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

2.5

람다 함수와 함께 사용하기

SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;

6.5

도입 버전: v26.6.0

입력 배열에서 가장 작은 K개의 요소를 오름차순으로 정렬한 배열을 반환합니다. 람다 함수 f가 지정되면 각 요소에 f를 적용한 결과를 기준으로 요소를 비교합니다. f가 여러 인수를 받는 경우 추가 배열이 arrayBottomK에 전달되며, 해당 배열의 요소는 f의 인수에 대응합니다.

NULL 값은 건너뛰므로 결과에 포함되지 않습니다. 결과 크기는 최대 K이며, 입력 배열에 NULL이 아닌 요소가 K개보다 적으면 더 작을 수 있습니다. 결과의 요소 타입은 입력 요소 타입에 대응하는 널 비허용 타입입니다.

arrayBottomK는 고차 함수입니다.

관련 항목:

• 대신 가장 큰 K개의 요소를 반환하는 arrayTopK
• 위치 [1..K]에 동일한 K개 요소를 배치하지만 나머지 요소도 지정되지 않은 순서로 유지하며 NULL도 건너뛰지 않는 arrayPartialSort

구문

arrayBottomK([f,] K, arr [, arr1, ... ,arrN])

인수

• f(arr[, arr1, ... ,arrN]) — 선택 사항입니다. 각 요소의 정렬 키를 계산하는 람다 함수입니다. 람다 함수
• K — 반환할 가장 작은 요소의 개수입니다. (U)Int8/16/32/64
• arr — 배열입니다. Array(T)
• arr1, ... ,arrN — f가 여러 인수를 받는 경우 사용하는 추가 배열 N개입니다. Array(T)

반환 값

값이 가장 작은(또는 람다 함수 결과가 가장 작은) arr의 요소를 최대 K개까지 오름차순으로 정렬해 반환합니다. NULL 값은 제외됩니다. 반환되는 배열의 요소 타입은 입력 타입이 Nullable(T)인 경우에도 T입니다.

예시

simple_int

SELECT arrayBottomK(3, [1, 5, 2, 7, 3])

[1,2,3]

skip_nulls

SELECT arrayBottomK(3, [1, NULL, 5, 2, NULL, 7])

[1,2,5]

fewer_than_k

SELECT arrayBottomK(5, [1, NULL, 2])

[1,2]

lambda_simple

SELECT arrayBottomK((x) -> -x, 2, [5, 9, 1, 3])

[9,5]

lambda_multi

SELECT arrayBottomK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

['b','c']

도입 버전: v20.1.0

null 값을 포함해 배열에서 연속으로 중복되는 요소를 제거합니다. 결과 배열의 값 순서는 소스 배열의 순서를 따릅니다.

구문

arrayCompact(arr)

인수

• arr — 중복 값을 제거할 배열입니다. Array(T)

반환 값

중복 값이 제거된 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);

[1,nan,2,3]

도입 버전: v1.1.0

인수로 전달된 배열들을 결합합니다.

구문

arrayConcat(arr1 [, arr2, ... , arrN])

인수

• arr1 [, arr2, ... , arrN] — 연결할 N개의 배열입니다. Array(T)

반환 값

지정된 배열 인수들을 하나로 연결한 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res

[1,2,3,4,5,6]

도입 버전: v1.1.0

func(arr1[i], ..., arrN[i])가 true를 반환하는 요소의 수를 반환합니다. func를 지정하지 않으면 배열에서 0이 아닌 요소의 수를 반환합니다.

arrayCount는 고차 함수입니다.

구문

arrayCount([func, ] arr1, ...)

인수

• func — 선택 사항입니다. 배열의 각 요소에 적용할 함수입니다. 람다 함수
• arr1, ..., arrN — N개의 배열입니다. Array(T)

반환 값

func가 true를 반환하는 요소 수를 반환합니다. 그렇지 않으면 배열에서 0이 아닌 요소 수를 반환합니다. UInt32

예시

사용 예시

SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)

5

도입 버전: v1.1.0

소스 배열 요소의 부분합(누적합)으로 이루어진 배열을 반환합니다. 람다 함수가 지정된 경우, 각 위치의 배열 요소에 람다를 적용한 값을 합산하여 계산합니다.

구문

arrayCumSum([func,] arr1[, arr2, ... , arrN])

인수

• func — 선택 사항입니다. 각 위치의 배열 요소에 적용할 람다 함수입니다. 람다 함수
• arr1 — 숫자 값으로 이루어진 소스 배열입니다. Array(T)
• [arr2, ..., arrN] — 선택 사항입니다. 크기가 같은 추가 배열이며, 지정한 경우 람다 함수의 인수로 전달됩니다. Array(T)

반환 값

소스 배열 요소의 누적 합으로 이루어진 배열을 반환합니다. 결과 타입은 입력 배열의 숫자 타입과 같습니다. Array(T)

예시

기본 사용법

SELECT arrayCumSum([1, 1, 1, 1]) AS res

[1,2,3,4]

람다 사용

SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res

[2,6,12]

도입 버전: v18.12.0

소스 배열의 요소에 대한 부분 합(누적 합) 배열을 반환하며, 누적 합이 음수가 되면 해당 값을 0으로 대체합니다. 람다 함수가 지정된 경우에는 각 위치의 배열 요소에 람다를 적용한 결과를 합산합니다.

구문

arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])

인수

• func — 선택 사항입니다. 각 위치의 배열 요소에 적용할 람다 함수입니다. 람다 함수
• arr1 — 숫자 값으로 이루어진 소스 배열입니다. Array(T)
• [arr2, ..., arrN] — 선택 사항입니다. 크기가 같은 추가 배열이며, 지정한 경우 람다 함수에 인수로 전달됩니다. Array(T)

반환 값

소스 배열 요소의 부분합으로 이루어진 배열을 반환합니다. 이때 누적합이 음수가 되면 0으로 대체됩니다. 결과 타입은 입력 배열의 숫자 타입과 일치합니다. Array(T)

예시

기본 사용법

SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res

[1,2,0,1]

람다 사용 시

SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res

[2,0,6]

도입 버전: v1.1.0

인접한 배열 요소 간의 차이값으로 이루어진 배열을 계산합니다. 결과 배열의 첫 번째 요소는 0이고, 두 번째 요소는 arr[1] - arr[0], 세 번째 요소는 arr[2] - arr[1]이며, 이후에도 같은 방식으로 이어집니다. 결과 배열 요소의 유형은 뺄셈에 대한 유형 추론 규칙에 따라 결정됩니다(예: UInt8 - UInt8 = Int16).

구문

arrayDifference(arr)

인수

• arr — 인접한 요소 간 차이를 계산할 배열입니다. Array(T)

반환 값

배열에서 인접한 요소 간 차이로 이루어진 배열을 반환합니다. UInt*

예시

사용 예시

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

[0,1,1,1]

Int64 결과 타입으로 인한 오버플로우 예시

SELECT arrayDifference([0, 10000000000000000000]);

┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616]                   │
└────────────────────────────────────────────┘

도입 버전: v1.1.0

배열에서 중복을 제거한 요소만 포함된 배열을 반환합니다.

구문

arrayDistinct(arr)

인수

• arr — 고유한 요소를 추출할 대상 배열입니다. Array(T)

반환 값

고유한 요소가 포함된 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT arrayDistinct([1, 2, 2, 3, 1]);

[1,2,3]

도입 버전: v23.5.0

두 배열의 내적을 반환합니다.

구문

arrayDotProduct(v1, v2)

인수

• v1 — 첫 번째 벡터입니다. Array((U)Int* | Float* | BFloat16 | Decimal) 또는 Tuple((U)Int* | Float* | Decimal)
• v2 — 두 번째 벡터입니다. Array((U)Int* | Float* | BFloat16 | Decimal) 또는 Tuple((U)Int* | Float* | Decimal)

반환 값

두 벡터의 내적입니다.

(U)Int* 또는 Float* 또는 Decimal

예시

배열 예시

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

32	UInt16

Tuple 예시

SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);

32	Float64

도입 버전: v1.1.0

임의의 정수형이 될 수 있는 인덱스 n을 사용해 주어진 배열에서 해당 원소를 가져옵니다. 인덱스가 배열 범위를 벗어나면 기본값(숫자는 0, 문자열은 빈 문자열 등)을 반환합니다. 단, 비상수 배열 인수와 상수 인덱스 0인 경우는 예외입니다. 이 경우 Array indices are 1-based 오류가 발생합니다.

n이 정수 배열이면 지정된 위치에 있는 원소로 구성된 배열을 반환합니다(수집 연산). 이는 arrayMap(i -> arr[i], n)와 동일하지만, 별도의 더 효율적인 구현을 사용합니다. 범위를 벗어난 위치는 스칼라 인덱스와 마찬가지로 기본값을 반환합니다. 인덱스 원소는 널 허용일 수 있습니다. 타입을 Nullable로 감쌀 수 있으면 NULL 인덱스는 NULL을 반환하고(결과 타입도 널 허용이 됩니다), Nullable 내부에 포함될 수 없는 타입(Array, Map 등)의 경우 NULL 인덱스는 대신 기본값을 반환합니다. 이는 스칼라 NULL 인덱스와 동일한 동작입니다.

음수 인덱스도 지원합니다. 이 경우 끝에서부터 번호를 매긴 해당 원소를 선택합니다. 예를 들어 arr[-1]은 배열의 마지막 항목입니다.

연산자 [n]도 동일한 기능을 제공합니다.

첫 번째 인수는 QBit일 수도 있습니다. 해당 원소를 포함하는 스트라이드 그룹의 비트 평면만 읽어 QBit 원소 타입의 전체 정밀도로 n번째 벡터 원소를 재구성합니다.

구문

arrayElement(arr, n)

인수

• arr — 검색할 배열입니다. Array(T) 또는 QBit. - n — 가져올 원소의 위치 또는 위치 배열입니다. 위치는 널 허용일 수 있습니다. (U)Int* 또는 Array((U)Int*).

반환 값

n이 스칼라이면 타입 T의 원소를 반환합니다. n이 배열이면 인덱스 원소가 널 허용이고 T를 Nullable로 감쌀 수 있는 경우 Array(Nullable(T))를 반환하고, 그렇지 않으면 Array(T)를 반환합니다. Any 또는 Array(T) 또는 Array(Nullable(T))

예시

사용 예시

SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

2

음수 인덱싱

SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

3

[n] 표기법 사용하기

SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)

2

배열 범위를 벗어난 인덱스

SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

0

인덱스 배열

SELECT [10, 20, 30, 40][[2, 4, 1]]

[20,40,10]

도입 버전: v1.1.0

주어진 배열에서 인덱스 n에 해당하는 원소를 반환합니다. 여기서 n은 임의의 정수 유형이 될 수 있습니다. 인덱스가 배열 범위를 벗어나면 결과 타입이 널 허용일 수 있는 경우 기본값 대신 NULL을 반환합니다. 이미 널 허용이 아니고 Nullable 내부에 넣을 수 없는 타입(Array, Map 등)의 경우에는 타입의 기본값을 반환합니다.

n이 정수 배열이면 지정된 위치에 있는 원소들의 배열을 반환합니다. 이는 arrayMap(i -> arrayElementOrNull(arr, i), n)과 동일하지만, 별도의 더 효율적인 구현을 사용합니다. 범위를 벗어난 위치와 NULL 인덱스는 스칼라 인덱스와 동일한 규칙에 따라 결과 배열에서 NULL 값을 생성합니다.

음수 인덱스도 지원합니다. 이 경우 끝에서부터 센 해당 원소를 선택합니다. 예를 들어 arr[-1]은 배열의 마지막 원소입니다.

구문

arrayElementOrNull(arr, n)

인수

• arr — 검색할 배열입니다. Array(T). - n — 가져올 원소의 위치 또는 위치 배열입니다. 위치는 널 허용일 수 있습니다. (U)Int* 또는 Array((U)Int*).

반환 값

n이 스칼라인 경우, T를 Nullable로 래핑할 수 있으면 Nullable(T)를 반환하고, 그렇지 않으면 T를 반환합니다. n이 배열인 경우, T를 Nullable로 래핑할 수 있으면 Array(Nullable(T))를 반환하고, 그렇지 않으면 Array(T)를 반환합니다. Any 또는 Nullable(T) 또는 Array(T) 또는 Array(Nullable(T))

예시

사용 예시

SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

2

음수 인덱싱

SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

3

배열 범위를 벗어난 인덱스

SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

\N

인덱스 배열

SELECT arrayElementOrNull([10, 20, 30], [1, 5, 2])

[10,NULL,20]

지원 시작 버전: v1.1.0

배열 [1, 2, 3, ..., length (arr)]을 반환합니다.

이 함수는 일반적으로 ARRAY JOIN 절과 함께 사용됩니다. ARRAY JOIN을 적용한 뒤 각 배열에 대해 무언가를 한 번만 계산할 수 있습니다. 이 함수는 고차 함수에서도 사용할 수 있습니다. 예를 들어, 조건과 일치하는 요소의 배열 인덱스를 구하는 데 사용할 수 있습니다.

구문

arrayEnumerate(arr)

인수

• arr — 번호를 매길 배열입니다. Array

반환 값

배열 [1, 2, 3, ..., length(arr)]을 반환합니다. Array(UInt32)

예시

ARRAY JOIN을 사용한 기본 예시

CREATE TABLE test
(
    `id` UInt8,
    `tag` Array(String),
    `version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);

SELECT
    id,
    tag,
    version,
    seq
FROM test
ARRAY JOIN
    tag,
    version,
    arrayEnumerate(tag) AS seq

┌─id─┬─tag────────────┬─version─────┬─seq─┐
│  1 │ release-stable │ 2.4.0       │   1 │
│  1 │ dev            │ 2.6.0-alpha │   2 │
│  1 │ security       │ 2.4.0-sec1  │   3 │
└────┴────────────────┴─────────────┴─────┘

도입 버전: v18.12.0

소스 배열과 동일한 크기의 배열을 반환하며, 각 요소가 소스 배열에서 처음 등장하는 위치를 나타냅니다.

구문

arrayEnumerateDense(arr)

인수

• arr — 번호를 매길 배열입니다. Array(T)

반환 값

각 요소가 소스 배열에 처음 나타나는 위치를 나타내는, arr와 동일한 크기의 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT arrayEnumerateDense([10, 20, 10, 30])

[1,2,1,3]

도입 버전: v20.1.0

소스 배열과 동일한 크기의 배열을 반환하며, 소스 배열에서 각 원소가 처음 나타나는 위치를 나타냅니다. 또한 배열 내부를 어디까지 확인할지 깊이를 지정하여 다차원 배열에 번호를 매길 수 있습니다.

구문

arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)

인수

• clear_depth — 지정된 수준에서 원소별로 별도로 번호를 매깁니다. max_arr_depth보다 작거나 같아야 합니다. UInt*
• arr — 번호를 매길 N차원 배열입니다. Array(T)
• max_array_depth — 유효한 최대 깊이입니다. arr의 깊이보다 작거나 같아야 합니다. UInt*

반환 값

소스 배열에서 각 원소가 처음 나타나는 위치를 나타내는 배열을 반환합니다. Array

예시

기본 사용법

-- With clear_depth=1 and max_array_depth=1, the result is identical to what arrayEnumerateDense would give.

SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);

[1,2,1,3]

다차원 배열 사용

-- In this example, arrayEnumerateDenseRanked is used to obtain an array indicating, for each element of the
-- multidimensional array, what its position is among elements of the same value.
-- For the first row of the passed array, [10, 10, 30, 20], the corresponding first row of the result is [1, 1, 2, 3],
-- indicating that 10 is the first number encountered in position 1 and 2, 30 the second number encountered in position 3
-- and 20 is the third number encountered in position 4.
-- For the second row, [40, 50, 10, 30], the corresponding second row of the result is [4,5,1,2], indicating that 40
-- and 50 are the fourth and fifth numbers encountered in position 1 and 2 of that row, that another 10
-- (the first encountered number) is in position 3 and 30 (the second number encountered) is in the last position.

SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);

[[1,1,2,3],[4,5,1,2]]

clear_depth를 늘린 예시

-- Changing clear_depth=2 results in the enumeration occurring separately for each row anew.

SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);

[[1,1,2,3],[1,2,3,4]]

도입 버전: v1.1.0

소스 배열과 동일한 크기의 배열을 반환하며, 각 원소가 같은 값을 가진 원소들 가운데 몇 번째 위치인지를 나타냅니다.

이 함수는 ARRAY JOIN 및 배열 원소 집계에 사용할 때 유용합니다.

이 함수는 동일한 크기의 여러 배열을 인수로 받을 수 있습니다. 이 경우 고유성은 모든 배열의 동일한 위치에 있는 원소들로 이루어진 튜플을 기준으로 판단됩니다.

구문

arrayEnumerateUniq(arr1[, arr2, ... , arrN])

인수

• arr1 — 처리할 첫 번째 배열입니다. Array(T)
• arr2, ... — 선택 사항입니다. 튜플의 고유성을 판별하기 위한 동일한 크기의 추가 배열입니다. Array(UInt32)

반환 값

각 원소에 대해, 같은 값 또는 같은 튜플을 갖는 원소들 사이에서의 위치를 나타내는 배열을 반환합니다. Array(T)

예시

기본 사용법

SELECT arrayEnumerateUniq([10, 20, 10, 30]);

[1,1,2,1]

여러 개의 배열

SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);

[1,2,1,1,2,1]

ARRAY JOIN 집계

-- Each goal ID has a calculation of the number of conversions (each element in the Goals nested data structure is a goal that was reached, which we refer to as a conversion)
-- and the number of sessions. Without ARRAY JOIN, we would have counted the number of sessions as sum(Sign). But in this particular case,
-- the rows were multiplied by the nested Goals structure, so in order to count each session one time after this, we apply a condition to the
-- value of the arrayEnumerateUniq(Goals.ID) function.

CREATE TABLE visits (CounterID UInt32, Sign Int8, Goals Nested(ID UInt32)) ENGINE = Memory;

INSERT INTO visits VALUES
    (160656, 1, [53225, 53225, 56600]),
    (160656, 1, [53225, 2825062]),
    (160656, 1, [56600, 56600, 2825062]),
    (160657, 1, [53225]);

SELECT
    Goals.ID AS GoalID,
    sum(Sign) AS Reaches,
    sumIf(Sign, num = 1) AS Visits
FROM visits
ARRAY JOIN
    Goals,
    arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC, GoalID
LIMIT 10

┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │       3 │      2 │
│   56600 │       3 │      2 │
│ 2825062 │       2 │      2 │
└─────────┴─────────┴────────┘

도입 버전: v20.1.0

소스 배열과 동일한 차원의 배열(또는 다차원 배열)을 반환하며, 각 원소가 같은 값을 가진 원소들 사이에서 몇 번째 위치에 있는지를 나타냅니다. 배열 내부를 어느 깊이까지 확인할지 지정할 수 있으므로, 다차원 배열에도 번호를 매길 수 있습니다.

구문

arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)

인수

• clear_depth — 지정된 수준에서 원소에 각각 별도로 번호를 매깁니다. max_arr_depth 이하의 양의 정수입니다. UInt*
• arr — 번호를 매길 N차원 배열입니다. Array(T)
• max_array_depth — 유효한 최대 깊이입니다. arr의 깊이 이하인 양의 정수입니다. UInt*

반환 값

arr와 크기가 같은 N차원 배열을 반환합니다. 각 원소에는 동일한 값을 가진 다른 원소들에 대한 해당 원소의 위치가 표시됩니다. Array(T)

예시

예시 1

-- With clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniq would give for the same array.

SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);

[1,1,2]

예시 2

-- with clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniqwould give for the same array.

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);

[[1,1,1],[2,3,2],[2]]

예시 3

-- In this example, arrayEnumerateUniqRanked is used to obtain an array indicating,
-- for each element of the multidimensional array, what its position is among elements
-- of the same value. For the first row of the passed array, [1, 2, 3], the corresponding
-- result is [1, 1, 1], indicating that this is the first time 1, 2 and 3 are encountered.
-- For the second row of the provided array, [2, 2, 1], the corresponding result is [2, 3, 3],
-- indicating that 2 is encountered for a second and third time, and 1 is encountered
-- for the second time. Likewise, for the third row of the provided array [3] the
-- corresponding result is [2] indicating that 3 is encountered for the second time.

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);

[[1,1,1],[2,3,2],[2]]

예시 4

-- Changing clear_depth=2, results in elements being enumerated separately for each row.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

[[1,1,1],[1,2,1],[1]]

도입 버전: v25.9.0

원래 순서를 유지하면서 except에 없는 source의 원소를 담은 배열을 반환합니다.

이 함수는 두 배열 간의 차집합 연산을 수행합니다. source의 각 원소에 대해 해당 원소가 except에 있는지(정확히 비교하여) 확인합니다. 없으면 해당 원소가 결과에 포함됩니다.

이 연산은 다음과 같은 특성을 유지합니다.

1. source의 원소 순서가 유지됩니다
2. except에 없는 경우 source의 중복 원소도 유지됩니다
3. NULL은 별도의 값으로 처리됩니다

구문

arrayExcept(source, except)

인수

• source — 필터링할 원소가 들어 있는 소스 배열입니다. Array(T)
• except — 결과에서 제외할 원소가 들어 있는 배열입니다. Array(T)

반환 값

입력 배열과 같은 타입이며, except에 없는 source의 원소를 포함한 배열을 반환합니다. Array(T)

예시

기본

SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])

[1,2,2,4]

with_nulls1

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

[1,NULL,NULL]

with_nulls2

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

[1]

문자열

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

['apple','cherry']

도입 버전: v1.1.0

소스 배열에서 func(x[, y1, y2, ... yN])이 true를 반환하는 요소가 하나 이상 있으면 1을 반환합니다. 그렇지 않으면 0을 반환합니다.

구문

arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 대해 동작하는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

람다 함수가 하나 이상의 요소에 대해 true를 반환하면 1을 반환하고, 그렇지 않으면 0을 반환합니다. UInt8

예시

사용 예시

SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])

0

도입 버전: v20.1.0

arrayFill 함수는 첫 번째 원소부터 마지막 원소까지 소스 배열을 순차적으로 처리하며, 각 위치에서 소스 배열과 조건 배열의 원소를 사용해 람다 조건을 평가합니다. 위치 i에서 람다 함수의 평가 결과가 false이면, 해당 원소는 배열의 현재 상태에서 위치 i-1의 원소로 대체됩니다. 첫 번째 원소는 조건과 관계없이 항상 유지됩니다.

구문

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])입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. 람다 함수
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

배열 Array(T)을 반환합니다.

예시

단일 배열을 사용하는 예시

SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res

[1,1,2,2]

두 개의 배열 예시

SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res

[5,5,6,6]

도입 버전: v1.1.0

람다 함수가 true를 반환하는 소스 배열의 요소만 포함된 배열을 반환합니다.

구문

arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 적용되는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

소스 배열의 부분 집합을 반환합니다. Array(T)

예시

예시 1

SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res

['abc World']

예시 2

SELECT
    arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr)
    AS res

[2]

도입 버전: v1.1.0

소스 배열에서 func(x[, y1, y2, ... yN])가 true를 반환하는 첫 번째 원소를 반환합니다. 해당 원소가 없으면 기본값을 반환합니다.

구문

arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 원소에 대해 동작하는 람다 함수입니다. 람다 함수. - source_arr — 처리할 소스 배열입니다. Array(T). - [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T).

반환 값

λ가 참이 되는 소스 배열의 첫 번째 원소를 반환하며, 그런 원소가 없으면 T의 기본값을 반환합니다.

예시

사용 예시

SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

b

일치 항목 없음

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

0	UInt8

도입 버전: v1.1.0

소스 배열에서 func(x[, y1, y2, ... yN])가 true를 반환하는 첫 번째 요소의 인덱스를 반환합니다. 해당 요소가 없으면 '0'을 반환합니다.

구문

arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 적용되는 람다 함수입니다. 람다 함수. - source_arr — 처리할 소스 배열입니다. Array(T). - [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T).

반환 값

func가 참이 되는 소스 배열의 첫 번째 요소 인덱스를 반환하고, 해당 요소가 없으면 0을 반환합니다 UInt32

예시

사용 예시

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

2

일치 없음

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])

0

도입 버전: v1.1.0

func(x[, y1, y2, ... yN])이 true를 반환하는 소스 배열의 첫 번째 요소를 반환합니다. 해당 요소가 없으면 NULL을 반환합니다.

구문

arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 적용되는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

func가 참인 소스 배열의 첫 번째 요소를 반환하며, 그런 요소가 없으면 NULL을 반환합니다.

예시

사용 예시

SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

b

일치하는 항목이 없습니다

SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

\N	Nullable(UInt8)

도입 버전: v20.1.0

배열의 배열을 1차원 배열로 변환합니다.

함수:

• 중첩 배열의 깊이에 상관없이 적용됩니다.
• 이미 1차원인 배열은 변경하지 않습니다.

평탄화된 배열에는 모든 소스 배열의 요소가 모두 포함됩니다.

구문

arrayFlatten(arr)

별칭: flatten

인수

• arr — 다차원 배열입니다. Array(Array(T))

반환 값

다차원 배열을 1차원으로 펼친 배열 Array(T)을 반환합니다.

예시

사용 예시

SELECT arrayFlatten([[[1]], [[2], [3]]]);

[1,2,3]

도입 버전: v23.10.0

같은 크기의 하나 이상의 배열에 람다 함수를 적용하고 결과를 누산기에 누적합니다.

구문

arrayFold(λ

인수

• λ(x, x1 [, x2, x3, ... xN]) — λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN]) 형태의 람다 함수입니다. 여기서 F는 acc와 x의 배열 값에 적용되는 연산이며, 계산된 acc 결과는 다음 단계에서 다시 사용됩니다. 람다 함수
• arr1 [, arr2, arr3, ... arrN] — 연산을 수행할 N개의 배열입니다. Array(T)
• acc — 람다 함수의 반환 타입과 동일한 타입의 누산기 값입니다.

반환 값

최종 acc 값을 반환합니다.

예시

사용 예시

SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;

23

피보나치 수열

SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);

┌─fibonacci─┐
│         0 │
│         1 │
│         1 │
│         2 │
│         3 │
│         5 │
│         8 │
│        13 │
│        21 │
│        34 │
└───────────┘

여러 배열 사용 예시

SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;

300

지원 버전: v1.1.0

여러 배열을 받아 모든 소스 배열에 공통으로 존재하는 요소로 이루어진 배열을 반환합니다. 결과에는 고유한 값만 포함됩니다.

구문

arrayIntersect(arr, arr1, ..., arrN)

인수

• arrN — 새 배열을 구성할 N개의 배열입니다. Array(T).

반환 값

모든 N개 배열에 공통으로 존재하는 고유 요소로 이루어진 배열을 반환합니다 Array(T)

예시

사용 예시

SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection

┌─empty_intersection─┬─non_empty_intersection─┐
│ []                 │ [1]                    │
└────────────────────┴────────────────────────┘

도입 버전: v23.7.0

두 배열의 자카드 지수를 반환합니다.

구문

arrayJaccardIndex(arr_x, arr_y)

인수

• arr_x — 첫 번째 배열. Array(T)
• arr_y — 두 번째 배열. Array(T)

반환 값

arr_x와 arr_y의 Jaccard 인덱스를 반환합니다. Float64

예시

사용 예시

SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res

0.3333333333333333

도입 버전: v1.1.0

arrayJoin 함수는 배열이 포함된 행을 받아 이를 펼쳐, 배열의 각 요소에 대해 하나씩 여러 개의 행을 생성합니다. 이는 ClickHouse의 일반 함수가 동일한 행 내에서 입력 값을 출력 값에 매핑하는 방식이나, 집계 함수가 여러 행의 그룹을 받아 이를 단일 요약 행으로 "압축"하거나 "줄이는" 방식 (GROUP BY와 함께 사용할 경우에는 요약 행 내의 단일 값으로 줄임)과는 대조적입니다.

이 함수가 적용된 컬럼의 값을 제외하면 다른 컬럼의 값은 모두 그대로 복사되며, 해당 값은 대응하는 배열 값으로 대체됩니다.

unnest(버전 26.5부터)는 함수 호출 형식(SELECT unnest(arr))에서 arrayJoin의 대소문자를 구분하지 않는 별칭입니다. PostgreSQL 테이블 소스 구문은 지원되지 않습니다(FROM unnest(...), CROSS JOIN UNNEST(...), LATERAL). 이러한 쿼리에는 ARRAY JOIN 절을 사용하십시오.

unnest 별칭을 통한 사용을 포함해 arrayJoin은 조인 중에 평가되는 JOIN ON 조건에서 사용할 수 없습니다. 이러한 조건은 행 수를 유지해야 하기 때문입니다. 한쪽에만 적용되는 조건과 arrayJoin에 대한 동등 키는 조인 전에 추출되므로 영향을 받지 않습니다. 논리합으로 분리되지 않은 ALL INNER JOIN 조건도 영향을 받지 않는데, 이 경우 조건은 조인 후에 적용되기 때문입니다. 확장이 한쪽에만 의존하는 경우 조인 전에 하위 쿼리의 ARRAY JOIN으로 옮기십시오. arrayJoin 인수가 양쪽의 컬럼을 읽는 조건은 재구성해야 합니다.

구문

arrayJoin(arr)

별칭: unnest

인수

• arr — 펼칠 배열입니다. Array(T)

반환 값

arr를 펼쳐 얻은 행 집합을 반환합니다.

예시

기본 사용법

SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src

┌─dst─┬─'Hello'─┬─src─────┐
│   1 │ Hello   │ [1,2,3] │
│   2 │ Hello   │ [1,2,3] │
│   3 │ Hello   │ [1,2,3] │
└─────┴─────────┴─────────┘

arrayJoin은 쿼리의 모든 절에 영향을 미칩니다

-- The arrayJoin function affects all sections of the query, including the WHERE section. Notice the result 2, even though the subquery returned 1 row.

SELECT sum(1) AS impressions
FROM
(
    SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];

┌─impressions─┐
│           2 │
└─────────────┘

여러 arrayJoin 함수 사용하기

-- A query can use multiple arrayJoin functions. In this case, the transformation is performed multiple times and the rows are multiplied.

SELECT
    sum(1) AS impressions,
    arrayJoin(cities) AS city,
    arrayJoin(browsers) AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3
ORDER BY
    city,
    browser

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

최적화로 인한 예상치 못한 결과

-- Using multiple arrayJoin with the same expression may not produce the expected result due to optimizations.
-- For these cases, consider modifying the repeated array expression with extra operations that do not affect join result.
-- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- is technically correct, but will annihilate result set
    arrayJoin(arrayConcat(dice, [])) as second_throw -- intentionally changed expression to force re-evaluation
FROM (
    SELECT [1, 2, 3, 4, 5, 6] as dice
);

┌─first_throw─┬─second_throw─┐
│           1 │            1 │
│           1 │            2 │
│           1 │            3 │
│           1 │            4 │
│           1 │            5 │
│           1 │            6 │
│           2 │            1 │
│           2 │            2 │
│           2 │            3 │
│           2 │            4 │
│           2 │            5 │
│           2 │            6 │
│           3 │            1 │
│           3 │            2 │
│           3 │            3 │
│           3 │            4 │
│           3 │            5 │
│           3 │            6 │
│           4 │            1 │
│           4 │            2 │
│           4 │            3 │
│           4 │            4 │
│           4 │            5 │
│           4 │            6 │
│           5 │            1 │
│           5 │            2 │
│           5 │            3 │
│           5 │            4 │
│           5 │            5 │
│           5 │            6 │
│           6 │            1 │
│           6 │            2 │
│           6 │            3 │
│           6 │            4 │
│           6 │            5 │
│           6 │            6 │
└─────────────┴──────────────┘

ARRAY JOIN 구문 사용하기

-- Note the ARRAY JOIN syntax in the `SELECT` query below, which provides broader possibilities.
-- ARRAY JOIN allows you to convert multiple arrays with the same number of elements at a time.

SELECT
    sum(1) AS impressions,
    city,
    browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
    cities AS city,
    browsers AS browser
GROUP BY
    2,
    3
ORDER BY
    2,
    3

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

튜플 사용하기

-- You can also use Tuple

SELECT
    sum(1) AS impressions,
    (arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
    t.2 AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3
ORDER BY
    2,
    3

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

도입 버전: v1.1.0

람다 func(x [, y1, y2, ... yN])가 true를 반환하는 소스 배열의 마지막 요소를 반환합니다. 해당 요소가 없으면 기본값을 반환합니다.

구문

arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 대해 작동하는 람다 함수입니다. 람다 함수. - source — 처리할 소스 배열입니다. Array(T). - [, cond1, ... , condN] — 선택 사항입니다. 람다 함수에 추가 인수를 전달하는 N개의 조건 배열입니다. Array(T).

반환 값

func가 true인 소스 배열의 마지막 요소를 반환합니다. 해당하는 요소가 없으면 T의 기본값을 반환합니다.

예시

사용 예시

SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

c

일치하는 항목 없음

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

0	UInt8

도입된 버전: v1.1.0

func(x[, y1, y2, ... yN])가 true를 반환하는 소스 배열의 마지막 요소 인덱스를 반환합니다. 해당하는 요소가 없으면 '0'을 반환합니다.

구문

arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 대해 동작하는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

func가 true를 반환하는 소스 배열의 마지막 요소 인덱스를 반환하며, 해당 요소가 없으면 0을 반환합니다. UInt32

예시

사용 예시

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);

3

일치하는 항목 없음

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);

0

도입 버전: v1.1.0

람다 func(x [, y1, y2, ... yN])가 true를 반환하는 소스 배열의 마지막 요소를 반환합니다. 해당하는 요소가 없으면 NULL을 반환합니다.

구문

arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x [, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 적용되는 람다 함수입니다. 람다 함수. - source_arr — 처리할 소스 배열입니다. Array(T). - [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T).

반환 값

λ가 참이 아닌 소스 배열의 마지막 요소를 반환합니다. 해당하는 요소가 없으면 NULL을 반환합니다.

예시

사용 예시

SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

c

일치 항목 없음

SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

\N	Nullable(UInt8)

도입된 버전: v25.4.0

두 배열의 Levenshtein 거리를 계산합니다.

구문

arrayLevenshteinDistance(from, to)

인수

• from — 첫 번째 배열입니다. Array(T). - to — 두 번째 배열입니다. Array(T).

반환 값

첫 번째 배열과 두 번째 배열 간의 Levenshtein 거리입니다. Float64

예시

사용 예시

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

1

도입 버전: v25.4.0

각 요소에 대한 사용자 지정 가중치를 적용해 두 배열의 Levenshtein 거리를 계산합니다. 배열의 요소 수와 가중치의 수는 일치해야 합니다.

구문

arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)

인수

• from — 첫 번째 배열. Array(T). - to — 두 번째 배열. Array(T). - from_weights — 첫 번째 배열에 대한 가중치. Array((U)Int*|Float*)
• to_weights — 두 번째 배열에 대한 가중치. Array((U)Int*|Float*)

반환 값

각 요소에 대해 사용자 지정 가중치를 적용한 첫 번째 배열과 두 번째 배열 간의 Levenshtein 거리 Float64

예시

사용 예시

SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])

14

도입 버전: v1.1.0

원래 배열의 각 요소에 람다 함수를 적용해 얻은 배열을 반환합니다.

구문

arrayMap(func, arr)

인수

• func — 소스 배열(x)과 조건 배열(y)의 요소를 처리하는 람다 함수입니다. 람다 함수
• arr — 처리할 N개의 배열입니다. Array(T)

반환 값

람다 함수의 결과로 이루어진 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;

[3,4,5]

서로 다른 배열의 요소로 튜플 생성하기

SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res

[(1,4),(2,5),(3,6)]

도입 버전: v21.1.0

소스 배열의 최댓값 요소를 반환합니다.

람다 함수 func가 지정된 경우, 람다 함수의 결과 중 최댓값 요소를 반환합니다.

구문

arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 선택 사항입니다. 소스 배열(x)과 조건 배열(y)의 요소에 대해 동작하는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

소스 배열의 최댓값 요소를 반환합니다. 람다 함수가 제공된 경우에는 람다 함수 결과의 최댓값 요소를 반환합니다.

예시

기본 예시

SELECT arrayMax([5, 3, 2, 7]);

7

람다 함수와 함께 사용

SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

12

도입 버전: v21.1.0

소스 배열의 최솟값 요소를 반환합니다.

람다 함수 func를 지정하면 람다 결과에서 최솟값 요소를 반환합니다.

구문

arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 선택 사항입니다. 소스 배열(x)과 조건 배열(y)의 요소에 적용되는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• cond1_arr, ... — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

소스 배열의 최솟값 요소를 반환합니다. 람다 함수가 제공된 경우에는 람다 함수 결과의 최솟값 요소를 반환합니다.

예시

기본 예시

SELECT arrayMin([5, 3, 2, 7]);

2

람다 함수 사용

SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

4

도입 버전: v25.1.0

정규화된 Gini 계수를 계산합니다.

구문

arrayNormalizedGini(predicted, label)

인수

• predicted — 예측값입니다. Array(T)
• label — 실제값입니다. Array(T)

반환 값

예측값의 Gini 계수, 정규화된 값의 Gini 계수, 정규화된 Gini 계수(= 앞의 두 Gini 계수의 비율)를 포함하는 튜플입니다. Tuple(Float64, Float64, Float64)

예시

사용 예시

SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);

(0.18055555555555558,0.2638888888888889,0.6842105263157896)

도입 버전: v23.2.0

이 함수는 arrayReverseSort와 동일하지만, 부분 정렬을 수행할 수 있도록 추가 limit 인수를 제공합니다.

구문

arrayPartialReverseSort([f,] limit, arr [, arr1, ... ,arrN])

인수

• f(arr[, arr1, ... ,arrN]) — 배열 x의 원소에 적용할 람다 함수입니다. 람다 함수
• limit — 정렬이 수행되는 범위의 끝을 나타내는 인덱스 값입니다. (U)Int*
• arr — 정렬할 배열입니다. Array(T)
• arr1, ... ,arrN — f가 여러 인수를 받는 경우 사용할 추가 배열 N개입니다. Array(T)

반환 값

원본 배열과 크기가 같은 배열을 반환합니다. 이 배열에서 [1..limit] 범위의 원소는 내림차순으로 정렬되며, 나머지 원소 (limit..N]의 순서는 지정되지 않습니다.

예시

simple_int

SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])

[9,5,1,3]

simple_string

SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])

['lasso','gladly','expenses','embolism']

retain_sorted

SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)

[9,5]

lambda_simple

SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])

[1,3,5,9]

lambda_complex

SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

[0,1,2]

도입 버전: v23.2.0

원본 배열과 동일한 크기의 배열을 반환합니다. 이 배열에서 [1..limit] 범위의 원소는 원본 배열에서 무작위로 선택된 부분집합입니다. 나머지 (limit..n]에는 [1..limit] 범위에 포함되지 않은 원소가 정의되지 않은 순서로 들어갑니다. limit 값은 [1..n] 범위에 있어야 합니다. 이 범위를 벗어난 값은 전체 arrayShuffle을 수행하는 것과 동일합니다.

구문

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

인수

• arr — 섞을 배열입니다. Array(T)
• seed — 선택 사항입니다. 난수 생성에 사용할 시드 값입니다. 지정하지 않으면 무작위 값이 사용됩니다. (U)Int*
• limit — 선택 사항입니다. 원소 교환 횟수를 제한하는 값이며, 범위는 [1..N]입니다. (U)Int*

반환 값

원소가 부분적으로 섞인 배열입니다. Array(T)

예시

no_limit1

SELECT arrayPartialShuffle([1, 2, 3, 4], 0)

[2, 4, 3, 1]

no_limit2

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

[2,3,4,1]

random_seed

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

[3, 4, 1, 2]

explicit_seed

SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)

[3,2,1,4]

구체화하다

SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)

┌─arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42)─┬─arrayPartialShuffle([1, 2, 3], 2, 42)─┐
│ [3,2,1,4]                                             │ [3,2,1]                               │
│ [3,2,1,4]                                             │ [3,1,2]                               │
│ [4,3,2,1]                                             │ [1,3,2]                               │
│ [1,4,3,2]                                             │ [2,1,3]                               │
│ [3,4,1,2]                                             │ [3,2,1]                               │
│ [1,2,3,4]                                             │ [3,2,1]                               │
│ [1,4,3,2]                                             │ [1,2,3]                               │
│ [1,4,3,2]                                             │ [3,2,1]                               │
│ [3,1,2,4]                                             │ [3,2,1]                               │
│ [1,3,2,4]                                             │ [2,1,3]                               │
└───────────────────────────────────────────────────────┴───────────────────────────────────────┘

도입 버전: v23.2.0

이 함수는 arraySort와 동일하지만, limit 인수가 추가되어 부분 정렬을 수행할 수 있습니다.

구문

arrayPartialSort([f,] limit, arr [, arr1, ... ,arrN])

인수

• f(arr[, arr1, ... ,arrN]) — 배열 원소에 적용할 람다 함수입니다. 람다 함수
• limit — 정렬이 수행될 인덱스 값입니다. (U)Int*
• arr — 정렬할 배열입니다. Array(T)
• arr1, ... ,arrN — f가 여러 인수를 받을 때 사용하는 추가 배열 N개입니다. Array(T)

반환 값

원본 배열과 크기가 같은 배열을 반환합니다. 이 배열에서는 [1..limit] 범위의 원소가 오름차순으로 정렬됩니다. 나머지 원소 (limit..N]의 순서는 지정되지 않습니다.

예시

simple_int

SELECT arrayPartialSort(2, [5, 9, 1, 3])

[1,3,5,9]

simple_string

SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])

['embolism','expenses','gladly','lasso']

retain_sorted

SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)

[1,3]

lambda_simple

SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])

[9,5,1,3]

lambda_complex

SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

[2,1,0]

도입 버전: v1.1.0

배열의 마지막 요소를 제거합니다.

구문

arrayPopBack(arr)

인수

• arr — 마지막 요소를 제거할 대상 배열입니다. Array(T)

반환 값

arr와 동일하지만 마지막 요소가 제거된 배열을 반환합니다. Array(T)

예시

사용 예시

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

[1,2]

도입 버전: v1.1.0

배열에서 첫 번째 요소를 제거합니다.

구문

arrayPopFront(arr)

인수

• arr — 첫 번째 요소를 제거할 대상 배열입니다. Array(T)

반환 값

arr와 동일하지만 첫 번째 요소가 제거된 배열을 반환합니다. Array(T)

예시

사용 예시

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

[2,3]

도입 버전: v21.1.0

소스 배열 요소들의 곱을 반환합니다.

람다 함수 func가 지정된 경우, 람다 함수 결과 요소들의 곱을 반환합니다.

구문

arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 선택 사항입니다. 소스 배열(x)과 조건 배열(y)의 요소에 적용되는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

소스 배열 요소의 곱을 반환합니다. 람다 함수가 제공되면 람다 함수 결과 요소의 곱을 반환합니다. Float64

예시

기본 예시

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

24

람다 함수와 함께 사용하기

SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;

16

도입 버전: v1.1.0

배열의 끝에 항목 하나를 추가합니다.

구문

arrayPushBack(arr, x)

인수

• arr — 끝에 값 x를 추가할 배열입니다. Array(T)
• x —
• 배열 끝에 추가할 단일 값입니다. Array(T).

반환 값

arr와 동일하지만 배열 끝에 값 x가 추가된 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT arrayPushBack(['a'], 'b') AS res;

['a','b']

도입 버전: v1.1.0

배열의 맨 앞에 요소를 하나 추가합니다.

구문

arrayPushFront(arr, x)

인수

• arr — 끝에 값 x를 추가할 배열입니다. Array(T). - x —
• 배열의 시작 부분에 추가할 단일 값입니다. Array(T).

반환 값

arr와 동일하지만 배열의 시작 부분에 값 x가 추가된 배열을 반환합니다 Array(T)

예시

사용 예시

SELECT arrayPushFront(['b'], 'a') AS res;

['a','b']

도입 버전: v20.4.0

ROC(수신자 조작 특성) 곡선 아래 면적을 계산합니다. ROC 곡선은 모든 임계값에 대해 y축에 진양성률(TPR), x축에 위양성률(FPR)을 표시하여 그립니다. 결과값은 0에서 1 사이이며, 값이 높을수록 model 성능이 더 우수함을 의미합니다.

ROC AUC(간단히 AUC라고도 함)는 기계 학습의 개념입니다. 자세한 내용은 여기, 여기, 여기를 참조하십시오.

구문

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

별칭: arrayAUC

인수

• scores — 예측 모델이 산출한 점수입니다. Array((U)Int*) 또는 Array(Float*)
• labels — 샘플의 레이블로, 일반적으로 양성 샘플은 1, 음성 샘플은 0입니다. Array((U)Int*) 또는 Enum
• scale — 선택 사항입니다. 정규화된 면적을 반환할지 여부를 결정합니다. false이면 대신 TP(참양성) x FP(거짓양성) 곡선 아래 면적을 반환합니다. 기본값: true. Bool
• partial_offsets —
• 전체 AUC 대신 ROC 곡선의 부분 면적(ROC 공간의 수직 밴드에 해당)을 계산하기 위한 4개의 음이 아닌 정수로 이루어진 배열입니다. 이 옵션은 ROC AUC를 분산 계산할 때 유용합니다. 배열에는 다음 요소가 포함되어야 합니다: [higher_partitions_tp, higher_partitions_fp, total_positives, total_negatives]. 음이 아닌 정수의 배열입니다. 선택 사항입니다.
  • higher_partitions_tp: 더 높은 점수 파티션에 있는 양성 레이블 수입니다.
  • higher_partitions_fp: 더 높은 점수 파티션에 있는 음성 레이블 수입니다.
  • total_positives: 전체 데이터셋의 총 양성 샘플 수입니다.
  • total_negatives: 전체 데이터셋의 총 음성 샘플 수입니다.

반환 값

ROC(수신자 조작 특성) 곡선 아래 면적을 반환합니다. Float64

예시

사용 예시

SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

0.75

도입 버전: v23.10.0

입력 배열에서 무작위로 선택한 samples개의 요소로 이루어진 부분 집합을 반환합니다. samples가 입력 배열의 크기를 초과하면 표본 크기는 배열 크기로 제한됩니다. 즉, 배열의 모든 원소가 반환되지만 원소의 순서는 보장되지 않습니다. 이 함수는 평면 배열과 중첩 배열을 모두 처리할 수 있습니다.

구문

arrayRandomSample(arr, samples)

인수

• arr — 요소를 샘플링할 입력 배열 또는 다차원 배열입니다. Array(T)
• samples — 무작위 샘플에 포함할 요소의 개수입니다. (U)Int*

반환 값

입력 배열의 요소를 무작위로 샘플링한 배열입니다. Array(T)

예시

사용 예시

SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;

['cherry','apple']

다차원 배열 사용하기

SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;

[[3,4],[5,6]]

도입 버전: v1.1.0

배열 요소에 집계 함수를 적용하고 그 결과를 반환합니다. 집계 함수 이름은 'max', 'sum'처럼 작은따옴표로 묶인 문자열로 전달합니다. 매개변수화된 집계 함수를 사용할 때는 함수 이름 뒤의 괄호 안에 매개변수를 지정합니다. 'uniqUpTo(6)'

구문

arrayReduce(agg_f, arr1[, arr2, ... , arrN])

인수

• agg_f — 상수여야 하는 집계 함수 이름입니다. String
• arr1[, arr2, ... , arrN] — agg_f의 인수에 대응하는 N개의 배열입니다. Array(T)

반환 값

집계 함수 결과를 반환합니다.

예시

사용 예시

SELECT arrayReduce('max', [1, 2, 3]);

┌─arrayReduce('max', [1, 2, 3])─┐
│                             3 │
└───────────────────────────────┘

여러 인수를 받는 집계 함수 예시

--집계 함수가 여러 인수를 받는 경우, 동일한 크기의 여러 배열에 적용해야 합니다.

SELECT arrayReduce('maxIf', [3, 5], [1, 0]);

┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│                                    3 │
└──────────────────────────────────────┘

매개변수형 집계 함수를 사용하는 예시

SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│                                                           4 │
└─────────────────────────────────────────────────────────────┘

도입 버전: v20.4.0

지정된 범위에 있는 배열 요소에 집계 함수를 적용하고, 각 범위의 결과를 담은 배열을 반환합니다. 이 함수는 여러 번 arrayReduce(agg_func, arraySlice(arr1, index, length), ...)를 호출한 것과 동일한 결과를 반환합니다.

구문

arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])

인수

• agg_f — 사용할 집계 함수의 이름입니다. String
• ranges — 집계를 수행할 범위입니다. 집계를 시작할 인덱스 i와 집계를 수행할 범위 r로 이루어진 (i, r) 튜플의 배열입니다. Array(T) 또는 Tuple(T)
• arr1[, arr2, ... ,arrN] — 집계 함수의 인수로 사용할 N개의 배열입니다. Array(T)

반환 값

지정된 범위에서 집계 함수를 적용한 결과를 담은 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res

┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘

도입 버전: v25.11.0

배열에서 지정된 값과 같은 모든 요소를 제거합니다. NULL은 같은 값으로 간주됩니다.

구문

arrayRemove(arr, elem)

별칭: array_remove

인수

• arr — Array(T) - elem — T

반환 값

소스 배열 Array(T)의 부분 집합을 반환합니다.

예시

예시 1

SELECT arrayRemove([1, 2, 2, 3], 2)

[1,3]

예시 2

SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)

['a','b']

도입 버전: v1.1.0

배열의 길이를 변경합니다.

구문

arrayResize(arr, size[, extender])

인수

• arr — 크기를 조정할 배열입니다. Array(T)
• size — -배열의 새로운 길이입니다. size가 배열의 원래 크기보다 작으면 배열은 오른쪽부터 잘립니다. size가 배열의 원래 크기보다 크면 배열은 오른쪽으로 확장되며, 이때 extender 값 또는 배열 항목의 데이터 타입에 대한 기본값이 사용됩니다.
• extender — 배열을 확장할 때 사용할 값입니다. NULL일 수 있습니다.

반환 값

길이가 size인 배열입니다. Array(T)

예시

예시 1

SELECT arrayResize([1], 3);

[1,0,0]

예시 2

SELECT arrayResize([1], 3, NULL);

[1,NULL,NULL]

도입 버전: v1.1.0

주어진 배열 요소의 순서를 반대로 바꿉니다.

구문

arrayReverse(arr)

인수

• arr — 역순으로 뒤집을 배열입니다. Array(T)

반환 값

원래 배열과 크기가 같고 요소가 역순으로 정렬된 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT arrayReverse([1, 2, 3])

[3,2,1]

도입 버전: v20.1.0

arrayReverseFill 함수는 마지막 요소부터 첫 번째 요소까지 소스 배열을 순차적으로 처리하며, 각 위치에서 소스 배열과 조건 배열의 요소를 사용해 람다 조건을 평가합니다. 위치 i에서 조건이 false로 평가되면, 함수는 해당 요소를 배열의 현재 상태에서 i+1 위치의 요소로 대체합니다. 마지막 요소는 조건과 관계없이 항상 유지됩니다.

구문

arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소를 처리하는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

소스 배열의 각 요소가 람다 함수의 결과값으로 대체된 배열을 반환합니다. Array(T)

예시

하나의 배열을 사용하는 예시

SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res

[1,2,2,NULL]

두 개의 배열을 사용한 예시

SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;

[5,6,6,2]

도입 버전: v1.1.0

배열의 요소를 내림차순으로 정렬합니다. 함수 f를 지정하면, 배열 요소에 적용한 함수의 결과를 기준으로 주어진 배열을 정렬한 다음 정렬된 배열을 역순으로 뒤집습니다. f가 여러 인수를 받는 경우, arrayReverseSort 함수에는 여러 개의 배열이 전달되며 각 배열은 func의 인수에 대응합니다.

정렬할 배열에 -Inf, NULL, NaN 또는 Inf가 포함된 경우 다음 순서로 정렬됩니다:

1. -Inf
2. Inf
3. NaN
4. NULL

arrayReverseSort는 고차 함수입니다.

구문

arrayReverseSort([f,] arr [, arr1, ... ,arrN])

인수

• f(y1[, y2 ... yN]) — 배열 x의 요소에 적용할 람다 함수입니다. - arr — 정렬할 배열입니다. Array(T) - arr1, ..., arrN — 선택 사항입니다. f가 여러 인수를 받는 경우 사용하는 추가 배열 N개입니다.

반환 값

람다 함수가 제공되지 않으면 배열 x를 내림차순으로 정렬해 반환합니다. 그렇지 않으면 제공된 람다 함수의 로직에 따라 정렬한 뒤 역순으로 뒤집은 배열을 반환합니다. Array(T).

예시

예시 1

SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;

[5,3,4]

예시 2

SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;

[4,3,5]

도입 버전: v20.1.0

소스 배열을 여러 배열로 분할합니다. func(x[, y1, ..., yN])가 0이 아닌 값을 반환하면 해당 요소의 오른쪽을 기준으로 배열이 분할됩니다. 마지막 요소 뒤에서는 배열이 분할되지 않습니다.

구문

arrayReverseSplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 적용되는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. 람다 함수
• [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

배열의 배열을 반환합니다. Array(Array(T))

예시

사용 예시

SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

[[1],[2,3,4],[5]]

도입 버전: v23.8.0

배열을 지정된 개수의 요소만큼 왼쪽으로 순환 이동합니다. n이 음수이면 회전량의 절댓값만큼 오른쪽으로 순환 이동하는 것으로 처리됩니다.

구문

arrayRotateLeft(arr, n)

인수

• arr — 요소를 회전시킬 배열입니다.Array(T). - n — 회전할 요소의 개수입니다. (U)Int8/16/32/64.

반환 값

지정된 개수만큼 요소를 왼쪽으로 회전한 배열입니다 Array(T)

예시

사용 예시

SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;

[3,4,5,6,1,2]

n이 음수인 경우

SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;

[5,6,1,2,3,4]

도입 버전: v23.8.0

배열을 지정된 수의 요소만큼 오른쪽으로 순환 이동합니다. n의 음수 값은 회전 크기의 절댓값만큼 왼쪽으로 순환 이동하는 것으로 처리됩니다.

구문

arrayRotateRight(arr, n)

인수

• arr — 요소를 회전할 대상 배열입니다.Array(T). - n — 회전할 요소 개수입니다. (U)Int8/16/32/64.

반환 값

지정된 개수만큼 요소를 오른쪽으로 회전한 배열입니다 Array(T)

예시

사용 예시

SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;

[5,6,1,2,3,4]

n이 음수인 경우

SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;

[3,4,5,6,1,2]

도입 버전: v23.8.0

배열을 지정한 요소 수만큼 왼쪽으로 이동합니다. 새 요소는 제공된 인수나 배열 요소 타입의 기본값으로 채워집니다. 요소 수가 음수이면 배열은 오른쪽으로 이동합니다.

구문

arrayShiftLeft(arr, n[, default])

인수

• arr — 요소를 이동할 대상 배열입니다.Array(T). - n — 이동할 요소 수입니다.(U)Int8/16/32/64. - default — 선택 사항입니다. 새 요소에 사용할 기본값입니다.

반환 값

지정한 개수만큼 왼쪽으로 이동된 배열입니다 Array(T)

예시

사용 예시

SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;

[3,4,5,6,0,0]

n이 음수인 경우

SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;

[0,0,1,2,3,4]

기본값 사용하기

SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;

[3,4,5,6,42,42]

도입 버전: v23.8.0

지정한 수의 요소만큼 배열을 오른쪽으로 이동합니다. 새로 생기는 요소는 제공된 인수 또는 배열 요소 타입의 기본값으로 채워집니다. 요소 수가 음수이면 배열은 왼쪽으로 이동합니다.

구문

arrayShiftRight(arr, n[, default])

인수

• arr — 요소를 이동할 배열입니다. Array(T)
• n — 이동할 요소의 개수입니다. (U)Int8/16/32/64
• default — 선택 사항입니다. 새 요소에 사용할 기본값입니다.

반환 값

지정된 개수만큼 요소를 오른쪽으로 이동한 배열입니다. Array(T)

예시

사용 예시

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;

[0,0,1,2,3,4]

n이 음수인 경우

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;

[3,4,5,6,0,0]

기본값 사용하기

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;

[42,42,1,2,3,4]

도입 버전: v24.1.0

입력 배열에서 지정된 길이의 연속된 하위 배열, 즉 shingle의 배열(문자열의 ngram과 유사함)을 생성합니다.

구문

arrayShingles(arr, l)

인수

• arr — shingle 배열을 생성할 대상 배열입니다. Array(T)
• l — 각 shingle의 길이입니다. (U)Int*

반환 값

생성된 shingle 배열입니다. Array(T)

예시

사용 예시

SELECT arrayShingles([1, 2, 3, 4], 3) as res;

[[1,2,3],[2,3,4]]

도입 버전: v23.2.0

원본 배열과 동일한 크기의 배열을 반환하며, 요소는 무작위로 섞인 순서로 포함됩니다. 요소는 가능한 모든 순열이 동일한 확률로 나타나도록 재배열됩니다.

구문

arrayShuffle(arr [, seed])

인수

• arr — 섞을 배열입니다. Array(T)
• seed (optional) — 선택 사항입니다. 난수 생성에 사용할 시드입니다. 지정하지 않으면 임의의 시드가 사용됩니다. (U)Int*

반환 값

요소가 섞인 배열입니다. Array(T)

예시

시드 없이 사용하는 예시(결과가 일정하지 않음)

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

[1,4,2,3]

시드 없이 사용하는 예시(일관된 결과)

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

[3,2,1,4]

도입 버전: v25.4.0

가중치가 적용된 Levenshtein 거리를 기준으로 0부터 1까지 두 배열의 유사도를 계산합니다.

구문

arraySimilarity(from, to, from_weights, to_weights)

인수

• from — 첫 번째 배열 Array(T)
• to — 두 번째 배열 Array(T)
• from_weights — 첫 번째 배열의 가중치입니다. Array((U)Int*|Float*)
• to_weights — 두 번째 배열의 가중치입니다. Array((U)Int*|Float*)

반환 값

가중치가 적용된 Levenshtein distance를 기준으로 계산한 두 배열의 0과 1 사이 유사도를 반환합니다. Float64

예시

사용 예시

SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);

0.2222222222222222

도입 버전: v1.1.0

NULL 요소를 포함한 배열의 슬라이스를 반환합니다.

첫 번째 인수는 QBit일 수도 있습니다. 이 경우 결과는 선택한 차원에 대한 QBit(차원 부분 집합으로의 프로젝션)입니다. QBit의 차원은 타입의 일부이고 슬라이스는 최소 1개의 차원을 선택해야 하므로 offset과 length는 상수여야 합니다. QBit의 stride 그룹 경계에 맞춰 정렬된 슬라이스는 stride를 유지하며, 복사 없이 저장된 bit-plane 스트림을 재사용합니다.

구문

arraySlice(arr, offset [, length])

인수

• arr — 슬라이스할 배열입니다. Array(T) 또는 QBit
• offset — 배열의 끝에서부터의 오프셋입니다. 양수 값은 왼쪽부터의 오프셋을, 음수 값은 오른쪽부터의 들여쓰기를 나타냅니다. 배열 항목의 번호는 1부터 시작합니다. (U)Int*
• length — 필요한 슬라이스의 길이입니다. 음수 값을 지정하면 함수는 끝이 열린 슬라이스 [offset, array_length - length]를 반환합니다. 값을 생략하면 함수는 슬라이스 [offset, the_end_of_array]를 반환합니다. (U)Int*

반환 값

지정된 offset부터 length개의 요소를 포함하는 배열 슬라이스를 반환합니다. Array(T)

예시

사용 예시

SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;

[2,NULL,4]

도입 버전: v1.1.0

주어진 배열의 요소를 오름차순으로 정렬합니다. 람다 함수 f를 지정하면 정렬 순서는 배열의 각 요소에 람다 함수를 적용한 결과에 따라 결정됩니다. 람다 함수가 여러 인수를 받는 경우 arraySort 함수에 여러 개의 배열이 전달되며, 이 배열들은 f의 인수에 각각 대응합니다.

정렬할 배열에 -Inf, NULL, NaN, Inf가 포함된 경우 다음 순서로 정렬됩니다:

1. -Inf
2. Inf
3. NaN
4. NULL

arraySort는 고차 함수입니다.

구문

arraySort([f,] arr [, arr1, ... ,arrN])

인수

• f(y1[, y2 ... yN]) — 배열 x의 요소에 적용할 람다 함수입니다. - arr — 정렬할 배열입니다. Array(T) - arr1, ..., arrN — 선택 사항입니다. f가 여러 인수를 받는 경우 사용할 추가 배열 N개입니다.

반환 값

람다 함수가 제공되지 않으면 배열 arr를 오름차순으로 정렬해 반환하고, 그렇지 않으면 제공된 람다 함수의 로직에 따라 정렬된 배열을 반환합니다. Array(T).

예시

예시 1

SELECT arraySort([1, 3, 3, 0]);

[0,1,3,3]

예시 2

SELECT arraySort(['hello', 'world', '!']);

['!','hello','world']

예시 3

SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);

[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]

도입 버전: v20.1.0

소스 배열을 여러 개의 배열로 분할합니다. func(x [, y1, ..., yN])가 0이 아닌 값을 반환하면 해당 요소의 왼쪽을 기준으로 배열이 분할됩니다. 첫 번째 요소 앞에서는 배열이 분할되지 않습니다.

구문

arraySplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 소스 배열(x)과 조건 배열(y)의 요소에 적용되는 람다 함수입니다.람다 함수. - source_arr — 분할할 소스 배열입니다. Array(T). - [, cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T).

반환 값

배열의 배열 Array(Array(T))을 반환합니다.

예시

사용 예시

SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

[[1,2,3],[4,5]]

v21.1.0에서 도입됨

소스 배열 요소의 합계를 반환합니다.

람다 함수 func가 지정된 경우, 람다 함수 결과 요소의 합계를 반환합니다.

구문

arraySum([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

인수

• func(x[, y1, ..., yN]) — 선택 사항입니다. 소스 배열(x)과 조건 배열(y)의 요소에 대해 작동하는 람다 함수입니다. 람다 함수
• source_arr — 처리할 소스 배열입니다. Array(T)
• , cond1_arr, ... , condN_arr] — 선택 사항입니다. 람다 함수에 추가 인수를 제공하는 N개의 조건 배열입니다. Array(T)

반환 값

소스 배열 요소의 합을 반환합니다. 람다 함수가 제공된 경우에는 람다 함수 결과 요소의 합을 반환합니다.

예시

기본 예시

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

10

람다 함수와 함께 사용

SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);

8

도입 버전: v25.4.0

여러 배열을 받아, 모든 소스 배열에 공통으로 존재하지 않는 요소들로 이루어진 배열을 반환합니다. 결과에는 고유한 값만 포함됩니다.

구문

arraySymmetricDifference(arr1, arr2, ... , arrN)

인수

• arrN — 새 배열을 만드는 데 사용되는 N개의 배열입니다. Array(T).

반환 값

모든 소스 배열에 공통으로 존재하지 않는 고유 요소로 이루어진 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;

┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ []                         │ [3,2]                          │
└────────────────────────────┴────────────────────────────────┘

도입 버전: v26.6.0

입력 배열에서 가장 큰 요소 K개를 내림차순으로 정렬한 배열을 반환합니다. 람다 함수 f가 지정되면 각 요소에 f를 적용한 결과를 기준으로 요소를 비교합니다. f가 여러 인수를 받는 경우 추가 배열이 arrayTopK에 전달되며, 그 요소들은 f의 인수에 각각 대응합니다.

NULL 값은 건너뛰므로 결과에 포함되지 않습니다. 결과 크기는 최대 K이며, 입력 배열의 NULL이 아닌 요소 수가 K보다 적으면 더 작을 수 있습니다. 결과의 요소 타입은 입력 요소 타입에서 NULL을 허용하지 않는 대응 타입입니다.

arrayTopK는 고차 함수입니다.

관련 항목: 대신 가장 작은 요소 K개를 반환하는 arrayBottomK를 참고하십시오.

구문

arrayTopK([f,] K, arr [, arr1, ... ,arrN])

인수

• f(arr[, arr1, ... ,arrN]) — 선택 사항입니다. 각 요소의 정렬 키를 계산하는 람다 함수입니다. 람다 함수
• K — 반환할 가장 큰 요소의 개수입니다. (U)Int8/16/32/64
• arr — 배열입니다. Array(T)
• arr1, ... ,arrN — f가 여러 인수를 받는 경우 사용하는 추가 배열 N개입니다. Array(T)

반환 값

값이 가장 큰 arr의 요소(또는 람다 함수 결과가 가장 큰 요소)를 최대 K개까지 내림차순으로 정렬해 반환합니다. NULL 값은 제외합니다. 입력 타입이 Nullable(T)이더라도 반환되는 배열의 요소 타입은 T입니다.

예시

simple_int

SELECT arrayTopK(3, [1, 5, 2, 7, 3])

[7,5,3]

skip_nulls

SELECT arrayTopK(3, [1, NULL, 5, 2, NULL, 7])

[7,5,2]

fewer_than_k

SELECT arrayTopK(5, [1, NULL, 2])

[2,1]

lambda_simple

SELECT arrayTopK((x) -> -x, 2, [5, 9, 1, 3])

[1,3]

lambda_multi

SELECT arrayTopK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

['a','c']

도입 버전: v26.4.0

2차원 배열을 전치합니다.

모든 내부 배열의 길이는 동일해야 합니다.

구문

arrayTranspose(arr)

인수

• arr — 전치할 2차원 배열입니다. 모든 내부 배열의 길이는 동일해야 합니다. Array(Array(T))

반환 값

결과의 원소 [i][j]가 입력의 원소 [j][i]와 같은 전치된 2차원 배열입니다. Array(Array(T))

예시

정사각 행렬

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

[[1,3],[2,4]]

비정방 행렬

SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])

[[1,4],[2,5],[3,6]]

String 타입 요소

SELECT arrayTranspose([['a', 'b'], ['c', 'd']])

[['a','c'],['b','d']]

도입 버전: v24.10.0

여러 배열을 받아 소스 배열 중 하나 이상에 있는 모든 요소를 포함하는 배열을 반환합니다. 결과에는 고유한 값만 포함됩니다.

구문

arrayUnion(arr1, arr2, ..., arrN)

인수

• arrN — 새 배열을 구성하는 데 사용할 N개의 배열입니다. Array(T)

반환 값

소스 배열들에서 중복을 제거한 요소로 이루어진 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT
arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example

┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1]   │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘

도입 버전: v1.1.0

단일 인수가 전달되면 배열에서 서로 다른 요소의 수를 계산합니다. 여러 인수가 전달되면 여러 배열의 같은 위치에 있는 요소들로 구성된 서로 다른 튜플의 수를 계산합니다.

예를 들어 SELECT arrayUniq([1,2], [3,4], [5,6])는 다음과 같은 튜플을 만듭니다:

• 위치 1: (1,3,5)
• 위치 2: (2,4,6)

그런 다음 고유한 튜플의 수를 계산합니다. 이 경우는 2입니다.

전달되는 모든 배열의 길이는 같아야 합니다.

구문

arrayUniq(arr1[, arr2, ..., arrN])

인수

• arr1 — 고유 요소의 개수를 계산할 배열입니다. Array(T)
• [, arr2, ..., arrN] — 선택 사항입니다. 여러 배열의 같은 위치에 있는 요소들로 이루어진 고유 튜플의 개수를 계산할 때 사용하는 추가 배열입니다. Array(T)

반환 값

단일 인수의 경우 고유 요소의 개수를 반환합니다. 여러 인수의 경우 배열들의 같은 위치에 있는 요소들로 이루어진 고유 튜플의 개수를 반환합니다. UInt32

예시

단일 인수

SELECT arrayUniq([1, 1, 2, 2])

2

다중 인수

SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])

3

도입 버전: v20.1.0

상수 x로 채운 길이 length의 배열을 생성합니다.

구문

arrayWithConstant(N, x)

인수

• length — 배열의 요소 수입니다. (U)Int*
• x — 배열의 N개 요소에 들어갈 값으로, 타입은 임의입니다.

반환 값

값이 x인 N개 요소로 이루어진 배열을 반환합니다. Array(T)

예시

사용 예시

SELECT arrayWithConstant(3, 1)

[1,1,1]

도입 버전: v20.1.0

여러 배열을 하나의 배열로 결합합니다. 결과 배열에는 소스 배열의 대응하는 요소들이 인수에 나열된 순서대로 튜플로 묶여 포함됩니다.

구문

arrayZip(arr1, arr2, ... , arrN)

인수

• arr1, arr2, ... , arrN — 하나의 배열로 결합할 N개의 배열입니다. Array(T)

반환 값

소스 배열의 요소를 튜플로 묶은 배열을 반환합니다. 튜플의 데이터 타입은 입력 배열의 타입과 동일하며, 배열이 전달된 순서도 유지됩니다. Array(T)

예시

사용 예시

SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);

[('a',5),('b',2),('c',1)]

도입 버전: v20.1.0

여러 배열을 하나의 배열로 결합하며, 길이가 서로 다른 배열도 허용합니다. 결과 배열에는 소스 배열의 각 대응 요소가 인수에 나열된 순서대로 튜플로 묶여 포함됩니다.

구문

arrayZipUnaligned(arr1, arr2, ..., arrN)

인수

• arr1, arr2, ..., arrN — 하나의 배열로 결합할 N개의 배열입니다. Array(T)

반환 값

소스 배열의 요소들을 튜플로 묶은 배열을 반환합니다. 튜플의 데이터 타입은 입력 배열의 타입과 동일하며, 배열이 전달된 순서와 같습니다. Array(T) 또는 Tuple(T1, T2, ...)

예시

사용 예시

SELECT arrayZipUnaligned(['a'], [1, 2, 3]);

[('a',1),(NULL,2),(NULL,3)]

도입 버전: v1.1.0

배열에서 x와 같은 값의 요소 수를 반환합니다. arrayCount(elem -> elem = x, arr)와 동일합니다.

NULL 요소는 서로 구분되는 별도의 값으로 처리됩니다.

구문

countEqual(arr, x)

인수

• arr — 검색할 배열입니다. Array(T)
• x — 배열에서 개수를 셀 값입니다. 모든 타입이 가능합니다.

반환 값

배열에서 x와 같은 요소 수를 반환합니다. UInt64

예시

사용 예시

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

2

도입 버전: v1.1.0

입력 배열이 비어 있는지 확인합니다.

배열에 요소가 하나도 없으면 빈 것으로 간주됩니다.

이 함수는 String 또는 UUID 타입에도 사용할 수 있습니다.

구문

empty(arr)

인수

• arr — 입력 배열입니다. Array(T)

반환 값

배열이 비어 있으면 1, 비어 있지 않으면 0을 반환합니다 UInt8

예시

사용 예시

SELECT empty([]);

1

도입 버전: v1.1.0

비어 있는 Date 배열을 반환합니다

구문

emptyArrayDate()

인수

• 없음.

반환 값

빈 Date 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayDate()

[]

도입 버전: v1.1.0

빈 DateTime 배열을 반환합니다

구문

emptyArrayDateTime()

인수

• 없습니다.

반환 값

빈 DateTime 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayDateTime()

[]

도입된 버전: v1.1.0

비어 있는 Float32 배열을 반환합니다

구문

emptyArrayFloat32()

인수

• 없음.

반환 값

빈 Float32 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayFloat32()

[]

도입 버전: v1.1.0

빈 Float64 배열을 반환합니다

구문

emptyArrayFloat64()

인수

• 없습니다.

반환 값

비어 있는 Float64 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayFloat64()

[]

도입 버전: v1.1.0

빈 Int16 배열을 반환합니다

구문

emptyArrayInt16()

인수

• 없음

반환 값

비어 있는 Int16 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayInt16()

[]

도입 버전: v1.1.0

빈 Int32 배열을 반환합니다

구문

emptyArrayInt32()

인수

• 없음.

반환 값

비어 있는 Int32 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayInt32()

[]

도입 버전: v1.1.0

빈 Int64 배열을 반환합니다

구문

emptyArrayInt64()

인수

• 없습니다.

반환 값

비어 있는 Int64 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayInt64()

[]

도입 버전: v1.1.0

빈 Int8 배열을 반환합니다

구문

emptyArrayInt8()

인수

• 없음.

반환 값

빈 Int8 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayInt8()

[]

도입 버전: v1.1.0

빈 String 배열을 반환합니다

구문

emptyArrayString()

인수

• 없음.

반환 값

비어 있는 String 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayString()

[]

다음 버전에서 도입됨: v1.1.0

빈 배열을 받아 기본값과 동일한 단일 원소 배열을 반환합니다.

구문

emptyArrayToSingle(arr)

인수

• arr — 비어 있는 배열입니다. Array(T)

반환 값

배열의 기본 유형 기본값 1개를 포함하는 배열입니다. Array(T)

예시

기본 예시

CREATE TABLE test (
  a Array(Int32),
  b Array(String),
  c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO test VALUES ([], [], []);

SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;

┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0]                   │ ['']                  │ ['1970-01-01 00:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘

도입 버전: v1.1.0

빈 UInt16 배열을 반환합니다

구문

emptyArrayUInt16()

인수

• 없습니다.

반환 값

비어 있는 UInt16 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayUInt16()

[]

도입 버전: v1.1.0

빈 UInt32 배열을 반환합니다

구문

emptyArrayUInt32()

인수

• 없습니다.

반환 값

비어 있는 UInt32 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayUInt32()

[]

도입 버전: v1.1.0

비어 있는 UInt64 배열을 반환합니다

구문

emptyArrayUInt64()

인수

• 없습니다.

반환 값

비어 있는 UInt64 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayUInt64()

[]

도입 버전: v1.1.0

빈 UInt8 배열을 반환합니다

구문

emptyArrayUInt8()

인수

• 없습니다.

반환 값

빈 UInt8 배열입니다. Array(T)

예시

사용 예시

SELECT emptyArrayUInt8()

[]

도입 버전: v1.1.0

배열에 지정된 요소가 있는지, 맵에 지정된 키가 있는지, 또는 JSON 객체에 지정된 경로가 있는지를 반환합니다.

JSON에서는 점 표기법(예: 'a.b.c')을 사용해 중첩 경로를 지원합니다.