배열 함수

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)

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

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 │
└─────────────────────────────────────────────────┘

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

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]

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

2.5

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

6.5

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

[1,nan,2,3]

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

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

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

5

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]

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]

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

[0,1,1,1]

SELECT arrayDifference([0, 10000000000000000000]);

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

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

[1,2,3]

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

32    UInt16

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

32    Float64

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

2

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

3

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

2

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

0

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)

NULL

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

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

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

┌─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 │
└────┴────────────────┴─────────────┴─────┘

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

[1,2,1,3]

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

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

[1,2,1,3]

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

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

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

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

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

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]

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

┌──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 │
└─────────┴─────────┴────────┘

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

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

[1, 1, 2]

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

[1, 1, 2]

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

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

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

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

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

[1, 2, 2, 4]

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

[1, NULL, NULL]

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

[1]

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

['apple', 'cherry']

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

0

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]

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

['abc World']

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

[2]

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

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

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)

NULL Nullable(UInt8)

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

[1, 2, 3]

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

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]                    │
└────────────────────┴────────────────────────┘

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

0.3333333333333333

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

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

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

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

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

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

┌─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 │
└─────────────┴──────────────┘

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

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

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

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

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

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

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

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)

NULL Nullable(UInt8)

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

1

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

14

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

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

7

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

12

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

2

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

4

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

(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)