배열 함수 - ClickHouse Documentation

array

도입 버전: v1.1.0 함수 인수로 배열을 생성합니다. 인수는 상수여야 하며, 서로 공통 상위 타입(common supertype)을 가져야 합니다. 그렇지 않으면 생성할 배열의 타입을 결정할 수 없으므로, 최소 1개의 인수를 전달해야 합니다. 즉, 이 함수로는 빈 배열을 생성할 수 없습니다. 빈 배열을 생성하려면 emptyArray* 함수를 사용하십시오. 동일한 기능에는 [ ] 연산자를 사용하십시오. 구문

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

인수

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

반환 값 전달된 인수들 가운데 가장 작은 공통 타입이 ‘T’인 배열을 반환합니다. Array(T) 예시 올바른 사용

Query

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

Response

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

잘못된 사용법

Query

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

Response

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보다 성능을 더 명확하게 비교할 수 있게 해줍니다. 자세한 내용은 여기, 여기, 여기를 참조하십시오. 구문

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: 전체 데이터셋의 총 양성 샘플 수입니다.

arr_partial_offsets를 사용하는 경우 arr_scores와 arr_labels에는 전체 데이터셋이 아니라 점수의 특정 인터벌에 해당하는 파티션만 포함되어야 합니다. 데이터셋은 연속된 파티션으로 나뉘어야 하며, 각 파티션에는 점수가 특정 범위에 속하는 데이터 하위 집합이 포함되어야 합니다. 예를 들면 다음과 같습니다.

한 파티션에는 [0, 0.5) 범위의 모든 점수가 포함될 수 있습니다.
다른 파티션에는 [0.5, 1.0] 범위의 점수가 포함될 수 있습니다.

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

Query

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

Response

┌─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을 반환합니다. 구문

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 예시 모든 요소가 일치하는 경우

Query

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

Response

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

Query

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

Response

arrayAutocorrelation

도입 버전: 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) 예시 선형

Query

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

Response

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

대칭

Query

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

Response

[1, -0.6666666666666669, 0.16666666666666674]

상수

Query

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

Response

[nan, nan, nan]

제한됨

Query

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

Response

[1, 0.4]

arrayAvg

도입 버전: 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 예시 기본 예시

Query

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

Response

2.5

람다 함수와 함께 사용하기

Query

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

Response

6.5

arrayCompact

도입 버전: v20.1.0 null 값을 포함해 배열에서 연속으로 중복되는 요소를 제거합니다. 결과 배열의 값 순서는 소스 배열의 순서를 따릅니다. 구문

arrayCompact(arr)

인수

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

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

Query

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

Response

[1,nan,2,3]

arrayConcat

도입 버전: v1.1.0 인수로 전달된 배열들을 결합합니다. 구문

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

인수

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

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

Query

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

Response

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

arrayCount

도입 버전: 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 예시 사용 예시

Query

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

Response

arrayCumSum

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

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

인수

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

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

Query

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

Response

[1, 2, 3, 4]

람다 사용

Query

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

Response

[2, 6, 12]

arrayCumSumNonNegative

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

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

인수

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

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

Query

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

Response

[1, 2, 0, 1]

람다 사용 시

Query

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

Response

[2, 0, 6]

arrayDifference

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

arrayDifference(arr)

인수

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

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

Query

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

Response

[0,1,1,1]

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

Query

SELECT arrayDifference([0, 10000000000000000000]);

Response

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

arrayDistinct

도입 버전: v1.1.0 배열에서 중복을 제거한 요소만 포함된 배열을 반환합니다. 구문

arrayDistinct(arr)

인수

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

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

Query

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

Response

[1,2,3]

arrayDotProduct

지원 버전: v23.5.0 두 배열의 내적을 반환합니다.

두 벡터의 크기는 반드시 같아야 합니다. 배열과 튜플에는 서로 다른 타입의 요소가 함께 포함될 수도 있습니다.

구문

arrayDotProduct(v1, v2)

인수

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

반환 값 두 벡터의 내적입니다.

반환 타입은 인수의 타입에 따라 결정됩니다. 배열 또는 Tuple에 서로 다른 타입의 요소가 섞여 있으면 결과 타입은 공통 상위 타입이 됩니다.

(U)Int* 또는 Float* 또는 Decimal 예시 배열 예시

Query

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

Response

32    UInt16

Tuple 예시

Query

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

Response

32    Float64

arrayElement

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

ClickHouse의 배열은 1부터 시작하는 인덱스를 사용합니다.

음수 인덱스도 지원합니다. 이 경우 끝에서부터 번호를 매긴 해당 요소를 선택합니다. 예를 들어 arr[-1]은 배열의 마지막 항목입니다. 연산자 [n]도 동일한 기능을 제공합니다. 구문

arrayElement(arr, n)

인수

arr — 검색할 배열입니다. Array(T). - n — 가져올 요소의 위치입니다. (U)Int*.

반환 값 제공된 배열 인수에서 결합된 단일 배열을 반환합니다. Array(T) 예시 사용 예시

Query

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

Response

음수 인덱스 사용

Query

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

Response

[n] 표기법 사용하기

Query

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

Response

배열 범위를 벗어난 인덱스

Query

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

Response

arrayElementOrNull

도입 버전: v1.1.0 주어진 배열에서 인덱스 n에 해당하는 요소를 반환합니다. 여기서 n은 임의의 정수 유형이 될 수 있습니다. 인덱스가 배열 범위를 벗어나면 기본값 대신 NULL을 반환합니다.

ClickHouse의 배열은 인덱스가 1부터 시작합니다.

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

arrayElementOrNull(arrays)

인수

arrays — 임의 개수의 배열 인수입니다. Array

반환 값 주어진 배열 인수들을 결합한 단일 배열을 반환합니다. Array(T) 예시 사용 예시

Query

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

Response

음수 인덱싱

Query

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

Response

배열 범위를 벗어난 인덱스

Query

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

Response

NULL

arrayEnumerate

지원 시작 버전: 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을 사용한 기본 예시

Query

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

┌─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 소스 배열과 동일한 크기의 배열을 반환하며, 각 요소가 소스 배열에서 처음 등장하는 위치를 나타냅니다. 구문

arrayEnumerateDense(arr)

인수

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

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

Query

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

Response

[1,2,1,3]

arrayEnumerateDenseRanked

도입 버전: 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 예시 기본 사용법

Query

-- clear_depth=1, max_array_depth=1로 설정하면 arrayEnumerateDense와 동일한 결과를 반환합니다.

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

Response

[1,2,1,3]

다차원 배열 사용

Query

-- 이 예시에서 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

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

clear_depth를 늘린 예시

Query

-- clear_depth=2로 변경하면 각 행에 대해 열거가 새로 시작됩니다.

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

Response

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

arrayEnumerateUniq

도입 버전: v1.1.0 소스 배열과 동일한 크기의 배열을 반환하며, 각 요소가 같은 값을 가진 요소들 가운데 몇 번째 위치인지를 나타냅니다. 이 함수는 ARRAY JOIN 및 배열 요소 집계에 사용할 때 유용합니다. 이 함수는 동일한 크기의 여러 배열을 인수로 받을 수 있습니다. 이 경우 고유성은 모든 배열의 동일한 위치에 있는 요소들로 이루어진 튜플을 기준으로 판단됩니다. 구문

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

인수

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

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

Query

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

Response

[1, 1, 2, 1]

여러 개의 배열

Query

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

Response

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

ARRAY JOIN 집계

Query

-- 각 목표 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

┌──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 소스 배열과 동일한 차원의 배열(또는 다차원 배열)을 반환하며, 각 요소가 같은 값을 가진 요소들 사이에서 몇 번째 위치에 있는지를 나타냅니다. 배열 내부를 어느 깊이까지 확인할지 지정할 수 있으므로, 다차원 배열도 열거할 수 있습니다. 구문

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

Query

-- clear_depth=1이고 max_array_depth=1인 경우, arrayEnumerateUniqRanked의 결과는
-- 동일한 배열에 대해 arrayEnumerateUniq가 반환하는 결과와 같습니다.

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

Response

[1, 1, 2]

예시 2

Query

-- 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

[1, 1, 2]

예시 3

Query

-- 이 예시에서 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

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

예시 4

Query

-- clear_depth=2로 변경하면 각 행마다 요소가 별도로 열거됩니다.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

Response

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

arrayExcept

도입 버전: v25.9.0 원래 순서를 유지하면서 except에 없는 source의 요소를 담은 배열을 반환합니다. 이 함수는 두 배열 간의 차집합 연산을 수행합니다. source의 각 요소에 대해 해당 요소가 except에 있는지(정확히 비교하여) 확인합니다. 없으면 해당 요소가 결과에 포함됩니다. 이 연산은 다음과 같은 특성을 유지합니다.

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

구문

arrayExcept(source, except)

인수

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

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

Query

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

Response

[1, 2, 2, 4]

with_nulls1

Query

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

Response

[1, NULL, NULL]

with_nulls2

Query

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

Response

[1]

문자열

Query

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

Response

['apple', 'cherry']

arrayExists

도입 버전: 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 예시 사용 예시

Query

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

Response

arrayFill

도입 버전: 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)을 반환합니다. 예시 단일 배열을 사용하는 예시

Query

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

Response

[1, 1, 2, 2]

두 개의 배열 예시

Query

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

[5, 5, 6, 6]

arrayFilter

도입 버전: 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

Query

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

Response

['abc World']

예시 2

Query

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

Response

[2]

arrayFirst

도입 버전: 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의 기본값을 반환합니다. 예시 사용 예시

Query

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

Response

일치 항목 없음

Query

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

Response

0 UInt8

arrayFirstIndex

도입 버전: 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 예시 사용 예시

Query

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

Response

일치 없음

Query

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

Response

arrayFirstOrNull

도입 버전: 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을 반환합니다. 예시 사용 예시

Query

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

Response

일치하는 항목이 없습니다

Query

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

Response

NULL Nullable(UInt8)

arrayFlatten

도입 버전: v20.1.0 배열의 배열을 1차원 배열로 변환합니다. 함수:

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

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

arrayFlatten(arr)

별칭: flatten 인수

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

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

Query

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

Response

[1, 2, 3]

arrayFold

도입 버전: v23.10.0 같은 크기의 하나 이상의 배열에 람다 함수를 적용하고 결과를 누산기에 누적합니다. 구문

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 결과는 다음 단계에서 다시 사용됩니다. 람다 함수
arr1 [, arr2, arr3, ... arrN] — 연산을 수행할 N개의 배열입니다. Array(T)
acc — 람다 함수의 반환 타입과 동일한 타입의 누산기 값입니다.

반환 값 최종 acc 값을 반환합니다. 예시 사용 예시

Query

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

Response

피보나치 수열

Query

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

Response

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

여러 배열 사용 예시

Query

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

Response

arrayIntersect

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

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

인수

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

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

Query

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

Response

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

arrayJaccardIndex

도입 버전: v23.7.0 두 배열의 자카드 지수를 반환합니다. 구문

arrayJaccardIndex(arr_x, arr_y)

인수

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

반환 값 arr_x와 arr_y의 Jaccard 인덱스를 반환합니다. Float64 예시 사용 예시

Query

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

Response

0.3333333333333333

arrayJoin

도입 버전: v1.1.0 arrayJoin 함수는 배열이 포함된 행을 받아 이를 펼쳐, 배열의 각 요소에 대해 하나씩 여러 개의 행을 생성합니다. 이는 ClickHouse의 일반 함수가 동일한 행 내에서 입력 값을 출력 값에 매핑하는 방식이나, 집계 함수가 여러 행의 그룹을 받아 이를 단일 요약 행으로 “압축”하거나 “줄이는” 방식 (GROUP BY와 함께 사용할 경우에는 요약 행 내의 단일 값으로 줄임)과는 대조적입니다. 이 함수가 적용된 컬럼의 값을 제외하면 다른 컬럼의 값은 모두 그대로 복사되며, 해당 값은 대응하는 배열 값으로 대체됩니다. 구문

arrayJoin(arr)

별칭: unnest 인수

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

반환 값 arr를 펼쳐 얻은 행 집합을 반환합니다. 예시 기본 사용법

Query

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

Response

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

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

Query

-- arrayJoin 함수는 WHERE 절을 포함한 쿼리의 모든 절에 영향을 미칩니다. 서브쿼리가 1개의 행을 반환했음에도 결과가 2임에 주목하십시오.

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

Response

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

여러 arrayJoin 함수 사용하기

Query

- 하나의 쿼리에서 여러 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

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

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

Query

-- 동일한 표현식으로 여러 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

┌─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 구문 사용하기

Query

-- 아래 `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

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

튜플 사용하기

Query

-- 튜플을 사용할 수도 있습니다

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

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

arrayLast

도입 버전: 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의 기본값을 반환합니다. 예시 사용 예시

Query

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

Response

일치하는 항목 없음

Query

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

Response

0 UInt8

arrayLastIndex

도입된 버전: 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 예시 사용 예시

Query

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

Response

일치하는 항목 없음

Query

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

Response

arrayLastOrNull

도입 버전: 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을 반환합니다. 예시 사용 예시

Query

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

Response

일치 항목 없음

Query

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

Response

NULL Nullable(UInt8)

arrayLevenshteinDistance

도입된 버전: v25.4.0 두 배열의 Levenshtein 거리를 계산합니다. 구문

arrayLevenshteinDistance(from, to)

인수

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

반환 값 첫 번째 배열과 두 번째 배열 간의 Levenshtein 거리입니다. Float64 예시 사용 예시

Query

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

Response

arrayLevenshteinDistanceWeighted

도입 버전: 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 예시 사용 예시

Query

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

Response

arrayMap

도입 버전: v1.1.0 원래 배열의 각 요소에 람다 함수를 적용해 얻은 배열을 반환합니다. 구문

arrayMap(func, arr)

인수

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

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

Query

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

Response

[3, 4, 5]

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

Query

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

Response

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

arrayMax

도입 버전: 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)

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

Query

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

Response

람다 함수와 함께 사용

Query

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

Response

arrayMin

도입 버전: 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)

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

Query

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

Response

람다 함수 사용

Query

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

Response

arrayNormalizedGini

도입 버전: v25.1.0 정규화된 Gini 계수를 계산합니다. 구문

arrayNormalizedGini(predicted, label)

인수

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

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

Query

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

Response

(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)

arrayPartialReverseSort

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

정렬된 요소만 유지하려면 arrayResize를 사용하십시오.

구문

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

인수

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

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

Query

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

Response

[9, 5, 1, 3]

simple_string

Query

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

Response

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

retain_sorted

Query

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

Response

[9, 5]

lambda_simple

Query

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

Response

[1, 3, 5, 9]

lambda_complex

Query

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

Response

[0, 1, 2]

arrayPartialShuffle

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

이 함수는 상수를 구체화하지 않습니다.limit 값은 [1..N] 범위에 있어야 합니다. 이 범위를 벗어난 값은 전체 arrayShuffle을 수행하는 것과 동일합니다.

구문

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

인수

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

반환 값 요소가 부분적으로 섞인 배열입니다. Array(T) 예시 no_limit1

Query

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

Response

[2, 4, 3, 1]

no_limit2

Query

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

Response

[4, 1, 3, 2]

random_seed

Query

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

Response

[3, 4, 1, 2]

explicit_seed

Query

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

Response

[3, 2, 1, 4]

구체화하다

Query

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

Response

┌─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를 사용하세요.

구문

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

인수

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

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

Query

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

Response

[1, 3, 5, 9]

simple_string

Query

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

Response

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

retain_sorted

Query

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

Response

[1, 3]

lambda_simple

Query

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

Response

[9, 5, 1, 3]

lambda_complex

Query

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

Response

[2, 1, 0]

arrayPopBack

도입 버전: v1.1.0 배열의 마지막 요소를 제거합니다. 구문

arrayPopBack(arr)

인수

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

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

Query

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

Response

[1, 2]

arrayPopFront

도입 버전: v1.1.0 배열에서 첫 번째 요소를 제거합니다. 구문

arrayPopFront(arr)

인수

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

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

Query

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

Response

[2, 3]

arrayProduct

도입 버전: 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 예시 기본 예시

Query

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

Response

람다 함수와 함께 사용하기

Query

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

Response

arrayPushBack

도입 버전: v1.1.0 배열의 끝에 항목 하나를 추가합니다. 구문

arrayPushBack(arr, x)

인수

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

숫자 배열에는 숫자만 추가할 수 있고, 문자열 배열에는 문자열만 추가할 수 있습니다.
숫자를 추가할 때 ClickHouse는 배열의 데이터 타입에 맞춰 x의 타입을 자동으로 설정합니다.
NULL일 수 있습니다. 이 함수는 배열에 NULL 요소를 추가하며, 배열 요소의 타입은 Nullable로 변환됩니다.

ClickHouse의 데이터 타입에 대한 자세한 내용은 데이터 타입를 참조하십시오.

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

Query

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

Response

['a','b']

arrayPushFront

도입 버전: v1.1.0 배열의 맨 앞에 요소를 하나 추가합니다. 구문

arrayPushFront(arr, x)

인수

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

숫자 배열에는 숫자만 추가할 수 있고, 문자열 배열에는 문자열만 추가할 수 있습니다.
숫자를 추가할 때 ClickHouse는 배열의 데이터 타입에 맞게 x의 타입을 자동으로 설정합니다.
NULL일 수 있습니다. 이 함수는 배열에 NULL 요소를 추가하며, 배열 요소의 타입은 Nullable로 변환됩니다.

ClickHouse의 데이터 타입에 대한 자세한 내용은 데이터 타입을 참조하십시오.

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

Query

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

Response

['a','b']

arrayROCAUC

도입 버전: 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: 전체 데이터셋의 총 음성 샘플 수입니다.

arr_partial_offsets를 사용하는 경우 arr_scores와 arr_labels는 전체 데이터셋 중 점수 구간 하나에 해당하는 파티션만 포함해야 합니다. 데이터셋은 연속된 파티션으로 나누어야 하며, 각 파티션에는 점수가 특정 범위에 속하는 데이터의 부분 집합이 포함되어야 합니다. 예를 들면 다음과 같습니다:

한 파티션에는 [0, 0.5) 범위의 모든 점수가 포함될 수 있습니다.
다른 파티션에는 [0.5, 1.0] 범위의 점수가 포함될 수 있습니다.

반환 값 ROC(receiver operating characteristic) 곡선 아래 면적을 반환합니다. Float64 예시 사용 예시

Query

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

Response

0.75

arrayRandomSample

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

arrayRandomSample(arr, samples)

인수

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

반환 값 입력 배열의 요소를 무작위로 샘플링한 배열입니다. Array(T) 예시 사용 예시

Query

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

Response

['cherry','apple']

다차원 배열 사용하기

Query

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

Response

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

arrayReduce

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

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

인수

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

반환 값 집계 함수 결과를 반환합니다. 예시 사용 예시

Query

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

Response

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

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

Query

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

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

Response

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

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

Query

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

Response

┌─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), ...)를 호출한 것과 동일한 결과를 반환합니다. 구문

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) 예시 사용 예시

Query

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

Response

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

arrayRemove

도입 버전: v25.11.0 배열에서 지정된 값과 같은 모든 요소를 제거합니다. NULL은 같은 값으로 간주됩니다. 구문

arrayRemove(arr, elem)

별칭: array_remove 인수

arr — Array(T) - elem — T

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

Query

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

Response

[1, 3]

예시 2

Query

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

Response

['a', 'b']

arrayResize

도입 버전: v1.1.0 배열의 길이를 변경합니다. 구문

arrayResize(arr, size[, extender])

인수

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

반환 값 길이가 size인 배열입니다. Array(T) 예시 예시 1

Query

SELECT arrayResize([1], 3);

Response

[1,0,0]

예시 2

Query

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

Response

[1,NULL,NULL]

arrayReverse

도입 버전: v1.1.0 주어진 배열 요소의 순서를 반대로 바꿉니다.

함수 reverse(arr)는 동일한 기능을 수행하지만, 배열뿐 아니라 다른 데이터 타입에도 적용할 수 있습니다.

구문

arrayReverse(arr)

인수

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

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

Query

SELECT arrayReverse([1, 2, 3])

Response

[3,2,1]

arrayReverseFill

도입 버전: 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) 예시 하나의 배열을 사용하는 예시

Query

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

Response

[1, 2, 2, NULL]

두 개의 배열을 사용한 예시

Query

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

[5, 6, 6, 2]

arrayReverseSort

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

-Inf
Inf
NaN
NULL

arrayReverseSort는 고차 함수입니다. 구문

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

인수

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

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

Query

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

Response

[5,3,4]

예시 2

Query

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

Response

[4,3,5]

arrayReverseSplit

도입 버전: 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)) 예시 사용 예시

Query

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

Response

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

arrayRotateLeft

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

arrayRotateLeft(arr, n)

인수

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

반환 값 지정된 개수만큼 요소를 왼쪽으로 회전한 배열입니다 Array(T) 예시 사용 예시

Query

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

Response

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

n이 음수인 경우

Query

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

Response

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

arrayRotateRight

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

arrayRotateRight(arr, n)

인수

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

반환 값 지정된 개수만큼 요소를 오른쪽으로 회전한 배열입니다 Array(T) 예시 사용 예시

Query

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

Response

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

n이 음수인 경우

Query

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

Response

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

arrayShiftLeft

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

arrayShiftLeft(arr, n[, default])

인수

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

반환 값 지정한 개수만큼 왼쪽으로 이동된 배열입니다 Array(T) 예시 사용 예시

Query

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

Response

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

n이 음수인 경우

Query

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

Response

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

기본값 사용하기

Query

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

Response

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

arrayShiftRight

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

arrayShiftRight(arr, n[, default])

인수

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

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

Query

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

Response

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

n이 음수인 경우

Query

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

Response

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

기본값 사용하기

Query

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

Response

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

arrayShingles

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

arrayShingles(arr, l)

인수

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

반환 값 생성된 shingle 배열입니다. Array(T) 예시 사용 예시

Query

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

Response

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

arrayShuffle

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

이 함수는 상수를 구체화하지 않습니다.

구문

arrayShuffle(arr [, seed])

인수

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

반환 값 요소가 섞인 배열입니다. Array(T) 예시 시드 없이 사용하는 예시(결과가 일정하지 않음)

Query

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

Response

[1,4,2,3]

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

Query

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

Response

[3,2,1,4]

arraySimilarity

도입 버전: 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 예시 사용 예시

Query

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

Response

0.2222222222222222

arraySlice

도입 버전: v1.1.0 NULL 요소를 포함한 배열의 슬라이스를 반환합니다. 구문

arraySlice(arr, offset [, length])

인수

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

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

Query

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

Response

[2, NULL, 4]

arraySort

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

-Inf
Inf
NaN
NULL

arraySort는 고차 함수입니다. 구문

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

인수

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

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

Query

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

Response

[0,1,3,3]

예시 2

Query

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

Response

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

예시 3

Query

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

Response

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

arraySplit

도입 버전: 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))을 반환합니다. 예시 사용 예시

Query

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

Response

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

arraySum

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)

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

Query

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

Response

람다 함수와 함께 사용

Query

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

Response

arraySymmetricDifference

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

2개를 초과하는 집합의 대칭차는 수학적으로 정의되며, 입력 집합 중 홀수 개의 집합에 포함되는 모든 요소의 집합을 의미합니다. 반면 arraySymmetricDifference 함수는 단순히 모든 입력 집합에 공통으로 포함되지 않는 요소들의 집합을 반환합니다.

구문

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

인수

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

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

Query

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

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

arrayTranspose

추가된 버전: v26.4.0 2차원 배열을 전치합니다. 모든 내부 배열의 길이는 동일해야 합니다. 구문

arrayTranspose(arr)

인수

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

반환 값 결과의 원소 [i][j]가 입력의 원소 [j][i]와 같은 전치된 2차원 배열입니다. Array(Array(T)) 예시 정사각 행렬

Query

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

Response

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

비정방 행렬

Query

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

Response

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

String 타입 요소

Query

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

Response

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

arrayUnion

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

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

인수

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

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

Query

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

┌─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)를 사용할 수 있습니다.

구문

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

인수

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

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

Query

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

Response

다중 인수

Query

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

Response

arrayWithConstant

도입 버전: v20.1.0 상수 x로 채운 길이 length의 배열을 생성합니다. 구문

arrayWithConstant(N, x)

인수

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

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

Query

SELECT arrayWithConstant(3, 1)

Response

[1, 1, 1]

arrayZip

도입 버전: v20.1.0 여러 배열을 하나의 배열로 결합합니다. 결과 배열에는 소스 배열의 대응하는 요소들이 인수에 나열된 순서대로 튜플로 묶여 포함됩니다. 구문

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

인수

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

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

Query

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

Response

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

arrayZipUnaligned

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

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

인수

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

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

Query

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

Response

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

countEqual

도입 버전: v1.1.0 배열에서 x와 같은 값의 요소 수를 반환합니다. arrayCount(elem -> elem = x, arr)와 동일합니다. NULL 요소는 서로 구분되는 별도의 값으로 처리됩니다. 구문

countEqual(arr, x)

인수

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

반환 값 배열에서 x와 같은 요소 수를 반환합니다. UInt64 예시 사용 예시

Query

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

Response

empty

지원 시작 버전: v1.1.0 입력 배열이 비어 있는지 확인합니다. 배열에 요소가 하나도 없으면 빈 것으로 간주됩니다.

optimize_functions_to_subcolumns 설정을 활성화하면 최적화할 수 있습니다. optimize_functions_to_subcolumns = 1이면 함수는 전체 배열 컬럼을 읽고 처리하는 대신 size0 서브컬럼만 읽습니다. 쿼리 SELECT empty(arr) FROM TABLE;는 SELECT arr.size0 = 0 FROM TABLE;로 변환됩니다.

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

empty(arr)

인수

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

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

Query

SELECT empty([]);

Response

emptyArrayDate

도입 버전: v1.1.0 비어 있는 Date 배열을 반환합니다 구문

emptyArrayDate()

인수

없음.

반환 값 빈 Date 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayDate

Response

[]

emptyArrayDateTime

v1.1.0에서 도입됨 빈 DateTime 배열을 반환합니다 구문

emptyArrayDateTime()

인수

없습니다.

반환 값 빈 DateTime 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayDateTime

Response

[]

emptyArrayFloat32

도입된 버전: v1.1.0 비어 있는 Float32 배열을 반환합니다 구문

emptyArrayFloat32()

인수

없음.

반환 값 빈 Float32 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayFloat32

Response

[]

emptyArrayFloat64

v1.1.0에 도입됨 빈 Float64 배열을 반환합니다 구문

emptyArrayFloat64()

인수

없습니다.

반환 값 비어 있는 Float64 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayFloat64

Response

[]

emptyArrayInt16

도입 버전: v1.1.0 빈 Int16 배열을 반환합니다 구문

emptyArrayInt16()

인수

없음

반환 값 비어 있는 Int16 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayInt16

Response

[]

emptyArrayInt32

도입 버전: v1.1.0 빈 Int32 배열을 반환합니다 구문

emptyArrayInt32()

인수

없음.

반환 값 비어 있는 Int32 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayInt32

Response

[]

emptyArrayInt64

도입 버전: v1.1.0 빈 Int64 배열을 반환합니다 구문

emptyArrayInt64()

인수

없습니다.

반환 값 비어 있는 Int64 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayInt64

Response

[]

emptyArrayInt8

도입 버전: v1.1.0 빈 Int8 배열을 반환합니다 구문

emptyArrayInt8()

인수

없음.

반환 값 빈 Int8 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayInt8

Response

[]

emptyArrayString

v1.1.0에 도입됨 빈 String 배열을 반환합니다 구문

emptyArrayString()

인수

없음.

반환 값 비어 있는 String 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayString

Response

[]

emptyArrayToSingle

다음 버전에서 도입됨: v1.1.0 빈 배열을 받아 기본값과 동일한 단일 요소 배열을 반환합니다. 구문

emptyArrayToSingle(arr)

인수

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

반환 값 배열의 기본 타입 기본값 1개를 포함하는 배열입니다. Array(T) 예시 기본 예시

Query

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

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

emptyArrayUInt16

v1.1.0에서 도입됨 빈 UInt16 배열을 반환합니다 구문

emptyArrayUInt16()

인수

없습니다.

반환 값 비어 있는 UInt16 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayUInt16

Response

[]

emptyArrayUInt32

도입 버전: v1.1.0 빈 UInt32 배열을 반환합니다 구문

emptyArrayUInt32()

인수

없습니다.

반환 값 비어 있는 UInt32 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayUInt32

Response

[]

emptyArrayUInt64

도입 버전: v1.1.0 비어 있는 UInt64 배열을 반환합니다 구문

emptyArrayUInt64()

인수

없습니다.

반환 값 비어 있는 UInt64 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayUInt64

Response

[]

emptyArrayUInt8

도입 버전: v1.1.0 빈 UInt8 배열을 반환합니다 구문

emptyArrayUInt8()

인수

없습니다.

반환 값 빈 UInt8 배열입니다. Array(T) 예시 사용 예시

Query

SELECT emptyArrayUInt8

Response

[]

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))). 구문

has(haystack, needle)

인수

haystack — 소스 배열, 맵 또는 JSON입니다. Array 또는 Map 또는 JSON
needle — 검색할 값입니다(배열의 요소, 맵의 키 또는 JSON의 경로 문자열).

반환 값 haystack에 지정한 needle이 포함되어 있으면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 배열 기본 사용법

Query

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

Response

배열을 찾을 수 없습니다

Query

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

Response

맵 기본 사용법

Query

SELECT has(map('a', 1, 'b', 2), 'b')

Response

JSON 경로

Query

SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')

Response

hasAll

도입 버전: v1.1.0 한 배열이 다른 배열의 부분집합인지 확인합니다.

빈 배열은 모든 배열의 부분집합입니다.
NULL은 값으로 처리됩니다.
두 배열의 값 순서는 중요하지 않습니다.

구문

hasAll(set, subset)

인수

set — 요소 집합을 담고 있는 임의 타입의 배열입니다. Array(T)
subset — set와 공통 상위 타입을 가지며, set의 부분집합인지 검사할 요소를 담고 있는 임의 타입의 배열입니다. Array(T)

반환 값

set에 subset의 모든 요소가 포함되어 있으면 1입니다.
그렇지 않으면 0입니다.

set과 subset의 요소가 공통 상위 타입을 갖지 않으면 NO_COMMON_TYPE 예외가 발생합니다. 예시 빈 배열

Query

SELECT hasAll([], [])

Response

NULL 값이 포함된 배열

Query

SELECT hasAll([1, Null], [Null])

Response

서로 다른 자료형의 값을 포함하는 배열

Query

SELECT hasAll([1.0, 2, 3, 4], [1, 3])

Response

String 값이 포함된 배열

Query

SELECT hasAll(['a', 'b'], ['a'])

Response

공통 타입이 없는 배열

Query

SELECT hasAll([1], ['a'])

Response

NO_COMMON_TYPE 예외가 발생합니다

중첩 배열

Query

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

Response

hasAny

도입 버전: v1.1.0 두 배열에 공통 요소가 있는지 확인합니다.

Null은 값으로 처리됩니다.
두 배열의 값 순서는 중요하지 않습니다.

구문

hasAny(arr_x, arr_y)

인수

arr_x — 요소 집합을 가진 임의 타입의 배열입니다. Array(T)
arr_y — 배열 arr_x와 공통 상위 타입을 갖는 임의 타입의 배열입니다. Array(T)

반환 값

1 — arr_x와 arr_y에 공통 요소가 하나 이상 있는 경우입니다.
0 — 그 밖의 경우입니다.

두 배열의 요소 중 하나라도 공통 상위 타입을 갖지 않으면 NO_COMMON_TYPE 예외가 발생합니다. 예시 한 배열이 비어 있는 경우

Query

SELECT hasAny([1], [])

Response

NULL 값이 포함된 배열

Query

SELECT hasAny([Null], [Null, 1])

Response

서로 다른 타입의 값을 포함하는 배열

Query

SELECT hasAny([-128, 1., 512], [1])

Response

공통 유형이 없는 배열

Query

SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])

Response

`NO_COMMON_TYPE` 예외가 발생합니다

중첩 배열

Query

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

Response

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 예외를 발생시킵니다. 구문

hasSubstr(arr1, arr2)

인수

arr1 — 원소 집합으로 이루어진 임의 타입의 배열. Array(T)
arr2 — 원소 집합으로 이루어진 임의 타입의 배열. Array(T)

반환 값 배열 arr1에 배열 arr2가 포함되어 있으면 1을 반환합니다. 그렇지 않으면 0을 반환합니다. UInt8 예시 두 배열이 모두 비어 있는 경우

Query

SELECT hasSubstr([], [])

Response

NULL 값을 포함한 배열

Query

SELECT hasSubstr([1, Null], [Null])

Response

서로 다른 유형의 값을 포함하는 배열

Query

SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])

Response

문자열이 포함된 배열

Query

SELECT hasSubstr(['a', 'b'], ['a'])

Response

유효한 순서를 가진 배열

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])

Response

정렬 순서가 잘못된 배열

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])

Response

중첩 배열

Query

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

Response

공통 타입이 없는 배열

Query

SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])

Response

`NO_COMMON_TYPE` 예외가 발생합니다

indexOf

도입 버전: v1.1.0 배열에 값 ‘x’를 가진 첫 번째 요소가 있으면 그 요소의 인덱스(1부터 시작)를 반환합니다. 배열에 찾는 값이 없으면 함수는 0을 반환합니다. NULL로 설정된 요소도 일반 값처럼 처리됩니다. 구문

indexOf(arr, x)

인수

arr — x를 찾을 배열입니다. Array(T)
x — arr에서 인덱스를 반환할 첫 번째 일치 요소의 값입니다. UInt64

반환 값 존재하면 arr에서 첫 번째 x의 인덱스(1부터 시작)를 반환합니다. 그렇지 않으면 0을 반환합니다. UInt64 예시 기본 예시

Query

SELECT indexOf([5, 4, 1, 3], 3)

Response

NULL을 포함하는 배열

Query

SELECT indexOf([1, 3, NULL, NULL], NULL)

Response

indexOfAssumeSorted

도입 버전: v24.12.0 배열에 값이 ‘x’인 요소가 있으면 첫 번째 요소의 인덱스(1부터 시작)를 반환합니다. 배열에 찾는 값이 없으면 함수는 0을 반환합니다.

indexOf 함수와 달리, 이 함수는 배열이 오름차순으로 정렬되어 있다고 가정합니다. 배열이 정렬되어 있지 않으면 결과는 정의되지 않습니다.

구문

indexOfAssumeSorted(arr, x)

인수

arr — 검색할 정렬된 배열입니다. Array(T)
x — 정렬된 arr에서 처음 일치하는 요소의 값으로, 해당 요소의 인덱스를 반환합니다. UInt64

반환 값 arr에 x가 있으면 첫 번째 x의 인덱스(1부터 시작)를 반환합니다. 없으면 0을 반환합니다. UInt64 예시 기본 예시

Query

SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)

Response

kql_array_sort_asc

도입 버전: v23.10.0 하나 이상의 배열을 오름차순으로 정렬합니다. 첫 번째 배열을 정렬하고, 이후 배열은 첫 번째 배열의 정렬된 순서에 맞춰 재배열됩니다. NULL 값은 끝에 배치됩니다. 이 함수는 KQL(Kusto Query Language) 호환 함수입니다. 구문

kql_array_sort_asc(array1[, array2, ..., nulls_last])

인수

array1 — 정렬할 배열입니다. Array(T)
array2 — 선택 사항입니다. array1의 정렬 순서에 맞춰 재정렬할 추가 배열입니다. Array(T)
nulls_last — 선택 사항입니다. null 값을 마지막에 배치할지 여부를 나타내는 불리언 값입니다. 기본값은 true입니다. UInt8

반환 값 오름차순으로 정렬된 배열의 튜플을 반환합니다. Tuple(Array, ...) 예시 기본 사용법

Query

SELECT kql_array_sort_asc([3, 1, 2])

Response

([1, 2, 3])

kql_array_sort_desc

도입 버전: v23.10.0 하나 이상의 배열을 내림차순으로 정렬합니다. 첫 번째 배열이 정렬되고, 그 뒤의 배열은 첫 번째 배열의 정렬된 순서에 맞춰 다시 정렬됩니다. NULL 값은 맨 끝에 배치됩니다. 이 함수는 KQL(Kusto Query Language) 호환 함수입니다. 구문

kql_array_sort_desc(array1[, array2, ..., nulls_last])

인수

array1 — 정렬할 배열입니다. Array(T)
array2 — array1의 정렬 순서에 맞춰 다시 정렬할 선택적 추가 배열입니다. Array(T)
nulls_last — null 값이 마지막에 오도록 할지 여부를 나타내는 선택적 불리언 값입니다. 기본값은 true입니다. UInt8

반환 값 내림차순으로 정렬된 배열 튜플을 반환합니다. Tuple(Array, ...) 예시 기본 사용법

Query

SELECT kql_array_sort_desc([3, 1, 2])

Response

([3, 2, 1])

length

도입 버전: v1.1.0 문자열 또는 배열의 길이를 계산합니다.

String 또는 FixedString 인수의 경우 문자열의 바이트 수를 계산합니다.
Array 인수의 경우 배열의 요소 수를 계산합니다.
FixedString 인수에 적용하면 이 함수는 상수 표현식입니다.

문자열의 바이트 수는 유니코드 “코드 포인트”의 개수와 같지 않으며, 유니코드 “grapheme clusters” (일반적으로 “문자”라고 부르는 것)의 개수와도 같지 않고, 화면에 표시되는 문자열 너비와도 같지 않다는 점에 유의하십시오. 문자열에 ASCII NULL 바이트가 포함되어 있어도 문제없으며, 이 역시 계산에 포함됩니다. 구문

length(x)

별칭: OCTET_LENGTH 인수

x — 바이트 수(String/FixedString) 또는 요소 수(Array)를 계산할 값입니다. String 또는 FixedString 또는 Array(T)

반환 값 String/FixedString x의 바이트 수 또는 배열 x의 요소 수를 반환합니다. UInt64 예시 String 예시

Query

SELECT length('Hello, world!')

Response

배열 예시

Query

SELECT length(['Hello', 'world'])

Response

constexpr 예시

Query

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

┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │                      0 │                            1 │
│ hello1 │                      0 │                            1 │
│ hello2 │                      0 │                            1 │
└────────┴────────────────────────┴──────────────────────────────┘

유니코드 예시

Query

SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)

Response

┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │            8 │                4 │ ёлка │           10 │                5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘

ascii_vs_utf8 예시

Query

SELECT 'ábc' AS str, length(str), lengthUTF8(str)

Response

┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │            4 │               3 │
└─────┴──────────────┴─────────────────┘

notEmpty

도입 버전: v1.1.0 입력 배열이 비어 있지 않은지 확인합니다. 배열에 요소가 하나 이상 있으면 비어 있지 않은 것으로 간주합니다.

optimize_functions_to_subcolumns 설정을 활성화하면 최적화할 수 있습니다. optimize_functions_to_subcolumns = 1이면 이 함수는 전체 배열 컬럼을 읽고 처리하는 대신 size0 서브컬럼만 읽습니다. 쿼리 SELECT notEmpty(arr) FROM table는 SELECT arr.size0 != 0 FROM TABLE로 변환됩니다.

이 함수는 String 및 UUID에도 사용할 수 있습니다. 구문

notEmpty(arr)

인수

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

반환 값 배열이 비어 있지 않으면 1을, 비어 있으면 0을 반환합니다. UInt8 예시 사용 예시

Query

SELECT notEmpty([1,2]);

Response

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에서 지정한 요소 수를 초과하는 전체 길이의 배열을 반환하면 예외가 발생합니다.
인수 중 하나라도 Nullable(nothing) 타입이면 NULL을 반환합니다. 인수 중 하나라도 NULL 값(Nullable(T) 타입)이면 예외가 발생합니다.

구문

range([start, ] end [, step])

인수

start — 선택 사항입니다. 배열의 첫 번째 요소입니다. step을 사용하는 경우 필수입니다. 기본값: 0. - end — 필수입니다. 배열이 이 값 직전까지 생성됩니다. - step — 선택 사항입니다. 배열의 각 요소 사이의 증가 간격을 지정합니다. 기본값: 1.

반환 값 start부터 end - 1까지 step 간격의 숫자 배열입니다. Array(T) 예시 사용 예시

Query

SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);

Response

┌─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에 도입됨 단일 값으로 이루어진 배열을 생성합니다. 구문

replicate(x, arr)

인수

x — 결과 배열을 채울 값입니다. Any
arr — 배열입니다. Array(T)

반환 값 값 x로 채운, arr와 길이가 같은 배열을 반환합니다. Array(T) 예시 사용 예시

Query

SELECT replicate(1, ['a', 'b', 'c']);

Response

┌─replicate(1, ['a', 'b', 'c'])───┐
│ [1, 1, 1]                       │
└─────────────────────────────────┘

reverse

도입 버전: v1.1.0 입력 배열의 요소 순서나 입력 문자열의 문자 순서를 반대로 바꿉니다. 구문

reverse(arr | str)

인수

arr | str — 소스 배열 또는 문자열입니다. Array(T) 또는 String

반환 값 요소 또는 문자의 순서가 역순으로 된 배열 또는 문자열을 반환합니다. 예시 배열 역순

Query

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

Response

[4, 3, 2, 1]

문자열 뒤집기

Query

SELECT reverse('abcd');

Response

'dcba'

거리 함수

지원되는 모든 함수에 대한 설명은 거리 함수 문서에서 확인할 수 있습니다.

​array

​arrayAUCPR

​arrayAll

​arrayAutocorrelation

​arrayAvg

​arrayCompact

​arrayConcat

​arrayCount

​arrayCumSum

​arrayCumSumNonNegative

​arrayDifference

​arrayDistinct

​arrayDotProduct

​arrayElement

​arrayElementOrNull

​arrayEnumerate

​arrayEnumerateDense

​arrayEnumerateDenseRanked

​arrayEnumerateUniq

​arrayEnumerateUniqRanked

​arrayExcept

​arrayExists

​arrayFill

​arrayFilter

​arrayFirst

​arrayFirstIndex

​arrayFirstOrNull

​arrayFlatten

​arrayFold

​arrayIntersect

​arrayJaccardIndex

​arrayJoin

​arrayLast

​arrayLastIndex

​arrayLastOrNull

​arrayLevenshteinDistance

​arrayLevenshteinDistanceWeighted

​arrayMap

​arrayMax

​arrayMin

​arrayNormalizedGini

​arrayPartialReverseSort

​arrayPartialShuffle

​arrayPartialSort

​arrayPopBack

​arrayPopFront

​arrayProduct

​arrayPushBack

​arrayPushFront

​arrayROCAUC

​arrayRandomSample

​arrayReduce

​arrayReduceInRanges

​arrayRemove

​arrayResize

​arrayReverse

​arrayReverseFill

​arrayReverseSort

​arrayReverseSplit

​arrayRotateLeft

​arrayRotateRight

​arrayShiftLeft

​arrayShiftRight

​arrayShingles

​arrayShuffle

​arraySimilarity

​arraySlice

​arraySort

​arraySplit

​arraySum

​arraySymmetricDifference

​arrayTranspose

​arrayUnion

​arrayUniq

​arrayWithConstant

​arrayZip

​arrayZipUnaligned

​countEqual

​empty

​emptyArrayDate

array

arrayAUCPR

arrayAll

arrayAutocorrelation

arrayAvg

arrayCompact

arrayConcat

arrayCount

arrayCumSum

arrayCumSumNonNegative

arrayDifference

arrayDistinct

arrayDotProduct

arrayElement

arrayElementOrNull

arrayEnumerate

arrayEnumerateDense

arrayEnumerateDenseRanked

arrayEnumerateUniq

arrayEnumerateUniqRanked

arrayExcept

arrayExists

arrayFill

arrayFilter

arrayFirst

arrayFirstIndex

arrayFirstOrNull

arrayFlatten

arrayFold

arrayIntersect

arrayJaccardIndex

arrayJoin

arrayLast

arrayLastIndex

arrayLastOrNull

arrayLevenshteinDistance

arrayLevenshteinDistanceWeighted

arrayMap

arrayMax

arrayMin

arrayNormalizedGini

arrayPartialReverseSort

arrayPartialShuffle

arrayPartialSort

arrayPopBack

arrayPopFront

arrayProduct

arrayPushBack

arrayPushFront

arrayROCAUC

arrayRandomSample

arrayReduce

arrayReduceInRanges

arrayRemove

arrayResize

arrayReverse

arrayReverseFill

arrayReverseSort

arrayReverseSplit

arrayRotateLeft

arrayRotateRight

arrayShiftLeft

arrayShiftRight

arrayShingles

arrayShuffle

arraySimilarity

arraySlice

arraySort

arraySplit

arraySum

arraySymmetricDifference

arrayTranspose

arrayUnion

arrayUniq

arrayWithConstant

arrayZip

arrayZipUnaligned

countEqual

empty

emptyArrayDate