일부 집계 함수는 인수로 사용하는 컬럼(압축에 사용됨)뿐만 아니라 초기화에 사용하는 상수인 매개변수 집합도 받을 수 있습니다. 구문에서는 괄호를 한 쌍이 아니라 두 쌍 사용합니다. 첫 번째는 매개변수용이고, 두 번째는 인수용입니다.
적응형 히스토그램을 계산합니다. 정확한 결과를 보장하지 않습니다.
histogram(number_of_bins)(values)
values — 입력 값을 생성하는 표현식입니다.
매개변수
number_of_bins — 히스토그램 구간 수의 상한입니다. 함수가 구간 수를 자동으로 계산합니다. 지정한 구간 수에 맞추려고 시도하지만, 그러지 못하면 더 적은 수의 구간을 사용합니다.
반환 값
-
다음 형식의 배열 튜플입니다.
[(lower_1, upper_1, height_1), ... (lower_N, upper_N, height_N)]
lower — 구간의 하한입니다.upper — 구간의 상한입니다.height — 계산된 구간 높이입니다.
예시
SELECT histogram(5)(number + 1)
FROM (
SELECT *
FROM system.numbers
LIMIT 20
)
┌─histogram(5)(plus(number, 1))───────────────────────────────────────────┐
│ [(1,4.5,4),(4.5,8.5,4),(8.5,12.75,4.125),(12.75,17,4.625),(17,20,3.25)] │
└─────────────────────────────────────────────────────────────────────────┘
WITH histogram(5)(rand() % 100) AS hist
SELECT
arrayJoin(hist).3 AS height,
bar(height, 0, 6, 5) AS bar
FROM
(
SELECT *
FROM system.numbers
LIMIT 20
)
┌─height─┬─bar───┐
│ 2.125 │ █▋ │
│ 3.25 │ ██▌ │
│ 5.625 │ ████▏ │
│ 5.625 │ ████▏ │
│ 3.375 │ ██▌ │
└────────┴───────┘
sequenceMatch(pattern)(timestamp, cond1, cond2, ...)
같은 초에 발생한 이벤트는 시퀀스 내에서 순서가 정의되지 않을 수 있으며, 그에 따라 결과가 달라질 수 있습니다.
-
timestamp — 시간 데이터가 포함된 것으로 간주되는 컬럼입니다. 일반적인 데이터 타입은 Date 및 DateTime입니다. 지원되는 UInt 데이터 타입도 사용할 수 있습니다.
-
cond1, cond2 — 이벤트 체인을 설명하는 조건입니다. 데이터 타입: UInt8. 조건 인수는 최대 32개까지 전달할 수 있습니다. 함수는 이러한 조건에 해당하는 이벤트만 고려합니다. 시퀀스에 어떤 조건에도 해당하지 않는 데이터가 포함되어 있으면 함수는 이를 건너뜁니다.
매개변수
pattern — 패턴 문자열입니다. 패턴 구문을 참조하십시오.
반환 값
- 패턴과 일치하면 1입니다.
- 패턴과 일치하지 않으면 0입니다.
유형: UInt8.
-
(?N) — N 위치의 조건 인수와 일치합니다. 조건에는 [1, 32] 범위의 번호가 매겨집니다. 예를 들어, (?1)은 cond1 매개변수에 전달된 인수와 일치합니다.
-
.* — 임의 개수의 이벤트와 일치합니다. 패턴의 이 요소와 일치시키기 위해 조건 인수는 필요하지 않습니다.
-
(?t operator value) — 두 이벤트 사이의 시간 간격을 초 단위로 설정합니다. 예를 들어, 패턴 (?1)(?t>1800)(?2)는 서로 1800초보다 긴 간격을 두고 발생하는 이벤트와 일치합니다. 이 이벤트들 사이에는 임의 개수의 어떤 이벤트든 올 수 있습니다. >=, >, <, <=, == 연산자를 사용할 수 있습니다.
예시
t 테이블의 데이터를 살펴보겠습니다:
┌─time─┬─number─┐
│ 1 │ 1 │
│ 2 │ 3 │
│ 3 │ 2 │
└──────┴────────┘
SELECT sequenceMatch('(?1)(?2)')(time, number = 1, number = 2) FROM t
┌─sequenceMatch('(?1)(?2)')(time, equals(number, 1), equals(number, 2))─┐
│ 1 │
└───────────────────────────────────────────────────────────────────────┘
SELECT sequenceMatch('(?1)(?2)')(time, number = 1, number = 2, number = 3) FROM t
┌─sequenceMatch('(?1)(?2)')(time, equals(number, 1), equals(number, 2), equals(number, 3))─┐
│ 0 │
└──────────────────────────────────────────────────────────────────────────────────────────┘
SELECT sequenceMatch('(?1)(?2)')(time, number = 1, number = 2, number = 4) FROM t
┌─sequenceMatch('(?1)(?2)')(time, equals(number, 1), equals(number, 2), equals(number, 4))─┐
│ 1 │
└──────────────────────────────────────────────────────────────────────────────────────────┘
같은 초에 발생한 이벤트는 시퀀스 내에서 순서가 정의되지 않을 수 있으며, 이로 인해 결과에 영향을 줄 수 있습니다.
sequenceCount(pattern)(timestamp, cond1, cond2, ...)
-
timestamp — 시간 데이터가 포함된 것으로 간주되는 컬럼입니다. 일반적인 데이터 타입은 Date 및 DateTime입니다. 지원되는 UInt 데이터 타입도 사용할 수 있습니다.
-
cond1, cond2 — 이벤트 체인을 설명하는 조건입니다. 데이터 타입: UInt8. 조건 인수는 최대 32개까지 전달할 수 있습니다. 이 함수는 이러한 조건에 해당하는 이벤트만 고려합니다. 시퀀스에 어떤 조건에도 해당하지 않는 데이터가 포함되어 있으면 함수는 이를 건너뜁니다.
매개변수
pattern — 패턴 문자열입니다. 패턴 구문을 참조하십시오.
반환 값
- 서로 겹치지 않게 일치한 이벤트 체인의 개수입니다.
유형: UInt64.
예시
t 테이블의 데이터를 예로 들어 보겠습니다:
┌─time─┬─number─┐
│ 1 │ 1 │
│ 2 │ 3 │
│ 3 │ 2 │
│ 4 │ 1 │
│ 5 │ 3 │
│ 6 │ 2 │
└──────┴────────┘
SELECT sequenceCount('(?1).*(?2)')(time, number = 1, number = 2) FROM t
┌─sequenceCount('(?1).*(?2)')(time, equals(number, 1), equals(number, 2))─┐
│ 2 │
└─────────────────────────────────────────────────────────────────────────┘
같은 초에 발생한 이벤트는 시퀀스에서 순서가 정해져 있지 않을 수 있으므로 결과에 영향을 줄 수 있습니다.
sequenceMatchEvents(pattern)(timestamp, cond1, cond2, ...)
-
timestamp — 시간 데이터가 들어 있는 것으로 간주되는 컬럼입니다. 일반적인 데이터 타입은 Date 및 DateTime입니다. 지원되는 UInt 데이터 타입도 사용할 수 있습니다.
-
cond1, cond2 — 이벤트의 연쇄를 설명하는 조건입니다. 데이터 타입: UInt8입니다. 최대 32개의 조건 인수를 전달할 수 있습니다. 함수는 이러한 조건으로 설명된 이벤트만 고려합니다. 시퀀스에 어떤 조건으로도 설명되지 않은 데이터가 포함되어 있으면 함수는 이를 건너뜁니다.
매개변수
pattern — 패턴 문자열입니다. 패턴 구문을 참조하십시오.
반환 값
- 이벤트 체인에서 일치한 조건 인수(?N)에 대한 타임스탬프 배열입니다. 배열의 각 위치는 패턴에서 해당 조건 인수의 위치와 일치합니다.
유형: 배열.
예시
t 테이블의 데이터를 살펴보겠습니다:
┌─time─┬─number─┐
│ 1 │ 1 │
│ 2 │ 3 │
│ 3 │ 2 │
│ 4 │ 1 │
│ 5 │ 3 │
│ 6 │ 2 │
└──────┴────────┘
SELECT sequenceMatchEvents('(?1).*(?2).*(?1)(?3)')(time, number = 1, number = 2, number = 4) FROM t
┌─sequenceMatchEvents('(?1).*(?2).*(?1)(?3)')(time, equals(number, 1), equals(number, 2), equals(number, 4))─┐
│ [1,3,4] │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
-
함수는 체인에서 첫 번째 조건을 만족하는 데이터를 찾고 이벤트 카운터를 1로 설정합니다. 이 시점부터 슬라이딩 윈도우가 시작됩니다.
-
체인의 이벤트가 윈도우 내에서 순차적으로 발생하면 카운터가 증가합니다. 이벤트 시퀀스가 중간에 끊기면 카운터는 증가하지 않습니다.
-
데이터에 완료된 정도가 서로 다른 여러 이벤트 체인이 있으면, 이 함수는 가장 긴 체인의 크기만 반환합니다.
구문
windowFunnel(window, [mode, [mode, ... ]])(timestamp, cond1, cond2, ..., condN)
timestamp — 타임스탬프가 들어 있는 컬럼의 이름입니다. 지원되는 데이터 타입: Date, DateTime, 그 밖의 부호 없는 정수 타입(timestamp는 UInt64 타입을 지원하지만 값은 Int64의 최댓값인 2^63 - 1을 초과할 수 없다는 점에 유의하십시오).cond — 이벤트 체인을 나타내는 조건 또는 데이터입니다. UInt8.
매개변수
window — 슬라이딩 윈도우의 길이이며, 첫 번째 조건과 마지막 조건 사이의 시간 인터벌입니다. window의 단위는 timestamp 자체에 따라 달라집니다. 다음 표현식으로 결정됩니다: timestamp of cond1 <= timestamp of cond2 <= ... <= timestamp of condN <= timestamp of cond1 + window.mode — 선택적 인수입니다. 하나 이상의 모드를 설정할 수 있습니다.
'strict_deduplication' — 이벤트 시퀀스에서 동일한 조건이 성립하면, 해당 반복 이벤트가 이후 처리를 중단시킵니다. 참고: 동일한 이벤트에 여러 조건이 동시에 성립하는 경우 예상과 다르게 동작할 수 있습니다.'strict_order' — 다른 이벤트가 끼어드는 것을 허용하지 않습니다. 예를 들어 A->B->D->C의 경우 D에서 A->B->C 탐색을 중단하며 최대 이벤트 수준은 2입니다.'strict_increase' — 타임스탬프가 엄격히 증가하는 이벤트에만 조건을 적용합니다.'strict_once' — 하나의 이벤트가 조건을 여러 번 충족하더라도 체인에서는 한 번만 계산합니다.'allow_reentry' — 엄격한 순서를 위반하는 이벤트를 무시합니다. 예를 들어 A->A->B->C의 경우 중복된 A를 무시하고 A->B->C를 찾으며 최대 이벤트 수준은 3입니다.
반환 값
슬라이딩 시간 윈도우 내에서 체인에서 연속적으로 트리거된 조건의 최대 개수입니다.
선택된 모든 체인을 분석합니다.
유형: Integer.
예시
정해진 시간 안에 사용자가 온라인 스토어에서 휴대전화를 고르고 두 번 구매할 수 있는지 확인합니다.
다음과 같은 이벤트 체인을 설정합니다.
- 사용자가 스토어 계정에 로그인했습니다(
eventID = 1003).
- 사용자가 휴대전화를 검색합니다(
eventID = 1007, product = 'phone').
- 사용자가 주문했습니다(
eventID = 1009).
- 사용자가 다시 주문했습니다(
eventID = 1010).
입력 테이블:
┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐
│ 2019-01-28 │ 1 │ 2019-01-29 10:00:00 │ 1003 │ phone │
└────────────┴─────────┴─────────────────────┴─────────┴─────────┘
┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐
│ 2019-01-31 │ 1 │ 2019-01-31 09:00:00 │ 1007 │ phone │
└────────────┴─────────┴─────────────────────┴─────────┴─────────┘
┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐
│ 2019-01-30 │ 1 │ 2019-01-30 08:00:00 │ 1009 │ phone │
└────────────┴─────────┴─────────────────────┴─────────┴─────────┘
┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐
│ 2019-02-01 │ 1 │ 2019-02-01 08:00:00 │ 1010 │ phone │
└────────────┴─────────┴─────────────────────┴─────────┴─────────┘
user_id가 이벤트 체인에서 어디까지 도달했는지 확인합니다.
SELECT
level,
count() AS c
FROM
(
SELECT
user_id,
windowFunnel(6048000000000000)(timestamp, eventID = 1003, eventID = 1009, eventID = 1007, eventID = 1010) AS level
FROM trend
WHERE (event_date >= '2019-01-01') AND (event_date <= '2019-02-02')
GROUP BY user_id
)
GROUP BY level
ORDER BY level ASC;
┌─level─┬─c─┐
│ 4 │ 1 │
└───────┴───┘
allow_reentry 모드가 사용자 재진입 패턴을 사용할 때 어떻게 작동하는지 보여줍니다:
-- 샘플 데이터: 사용자가 결제 시작 -> 상품 상세 -> 결제 재시작 -> 결제 완료 순으로 방문
-- allow_reentry 미사용 시: 2단계(상품 상세 페이지)에서 중단
-- allow_reentry 사용 시: 4단계(결제 완료)까지 도달
SELECT
level,
count() AS users
FROM
(
SELECT
user_id,
windowFunnel(3600, 'strict_order', 'allow_reentry')(
timestamp,
action = 'begin_checkout', -- 1단계: 결제 시작
action = 'view_product_detail', -- 2단계: 상품 상세 조회
action = 'begin_checkout', -- 3단계: 결제 재시작 (재진입)
action = 'complete_payment' -- 4단계: 결제 완료
) AS level
FROM user_events
WHERE event_date = today()
GROUP BY user_id
)
GROUP BY level
ORDER BY level ASC;
UInt8 유형의 조건 집합을 인수로 받습니다. 인수는 1개부터 32개까지 지정할 수 있습니다.
(WHERE와 같이) 어떤 조건이든 인수로 지정할 수 있습니다.
첫 번째를 제외한 조건은 쌍으로 적용됩니다. 첫 번째와 두 번째가 모두 true이면 두 번째의 결과는 true가 되고, 첫 번째와 세 번째가 모두 true이면 세 번째의 결과는 true가 되는 식입니다.
구문
retention(cond1, cond2, ..., cond32);
cond — UInt8 결과(1 또는 0)를 반환하는 표현식입니다.
반환 값
1 또는 0으로 이루어진 배열입니다.
- 1 — 이벤트에 대해 조건이 충족되었습니다.
- 0 — 이벤트에 대해 조건이 충족되지 않았습니다.
유형: UInt8.
예시
사이트 트래픽을 확인하기 위해 retention 함수를 계산하는 예시를 살펴보겠습니다.
1. 예시를 보여 주기 위한 테이블을 생성합니다.
CREATE TABLE retention_test(date Date, uid Int32) ENGINE = Memory;
INSERT INTO retention_test SELECT '2020-01-01', number FROM numbers(5);
INSERT INTO retention_test SELECT '2020-01-02', number FROM numbers(10);
INSERT INTO retention_test SELECT '2020-01-03', number FROM numbers(15);
SELECT * FROM retention_test
┌───────date─┬─uid─┐
│ 2020-01-01 │ 0 │
│ 2020-01-01 │ 1 │
│ 2020-01-01 │ 2 │
│ 2020-01-01 │ 3 │
│ 2020-01-01 │ 4 │
└────────────┴─────┘
┌───────date─┬─uid─┐
│ 2020-01-02 │ 0 │
│ 2020-01-02 │ 1 │
│ 2020-01-02 │ 2 │
│ 2020-01-02 │ 3 │
│ 2020-01-02 │ 4 │
│ 2020-01-02 │ 5 │
│ 2020-01-02 │ 6 │
│ 2020-01-02 │ 7 │
│ 2020-01-02 │ 8 │
│ 2020-01-02 │ 9 │
└────────────┴─────┘
┌───────date─┬─uid─┐
│ 2020-01-03 │ 0 │
│ 2020-01-03 │ 1 │
│ 2020-01-03 │ 2 │
│ 2020-01-03 │ 3 │
│ 2020-01-03 │ 4 │
│ 2020-01-03 │ 5 │
│ 2020-01-03 │ 6 │
│ 2020-01-03 │ 7 │
│ 2020-01-03 │ 8 │
│ 2020-01-03 │ 9 │
│ 2020-01-03 │ 10 │
│ 2020-01-03 │ 11 │
│ 2020-01-03 │ 12 │
│ 2020-01-03 │ 13 │
│ 2020-01-03 │ 14 │
└────────────┴─────┘
retention 함수를 사용하여 고유 ID uid별로 사용자를 그룹화합니다.
SELECT
uid,
retention(date = '2020-01-01', date = '2020-01-02', date = '2020-01-03') AS r
FROM retention_test
WHERE date IN ('2020-01-01', '2020-01-02', '2020-01-03')
GROUP BY uid
ORDER BY uid ASC
┌─uid─┬─r───────┐
│ 0 │ [1,1,1] │
│ 1 │ [1,1,1] │
│ 2 │ [1,1,1] │
│ 3 │ [1,1,1] │
│ 4 │ [1,1,1] │
│ 5 │ [0,0,0] │
│ 6 │ [0,0,0] │
│ 7 │ [0,0,0] │
│ 8 │ [0,0,0] │
│ 9 │ [0,0,0] │
│ 10 │ [0,0,0] │
│ 11 │ [0,0,0] │
│ 12 │ [0,0,0] │
│ 13 │ [0,0,0] │
│ 14 │ [0,0,0] │
└─────┴─────────┘
SELECT
sum(r[1]) AS r1,
sum(r[2]) AS r2,
sum(r[3]) AS r3
FROM
(
SELECT
uid,
retention(date = '2020-01-01', date = '2020-01-02', date = '2020-01-03') AS r
FROM retention_test
WHERE date IN ('2020-01-01', '2020-01-02', '2020-01-03')
GROUP BY uid
)
┌─r1─┬─r2─┬─r3─┐
│ 5 │ 5 │ 5 │
└────┴────┴────┘
r1- 2020-01-01에 사이트를 방문한 순 방문자 수(cond1 조건).r2- 2020-01-01부터 2020-01-02 사이의 특정 시간 범위에 사이트를 방문한 순 방문자 수(cond1 및 cond2 조건).r3- 2020-01-01과 2020-01-03의 특정 시간 범위에 사이트를 방문한 순 방문자 수(cond1 및 cond3 조건).
지정된 한도 N까지 인수의 서로 다른 값 개수를 계산합니다. 서로 다른 인수 값의 개수가 N보다 크면 이 함수는 N + 1을 반환하고, 그렇지 않으면 정확한 값을 계산합니다.
작은 N값(최대 10)에 사용하는 것이 좋습니다. N의 최댓값은 100입니다.
집계 함수 상태에 대해 이 함수는 1 + N * 값 1개의 바이트 크기에 해당하는 메모리를 사용합니다.
문자열을 처리할 때 이 함수는 8바이트 비암호화 해시를 저장하므로, 문자열에 대해서는 계산 결과가 근사값입니다.
예를 들어, 웹사이트에서 사용자가 수행한 모든 검색 쿼리를 기록하는 테이블이 있다고 가정하겠습니다. 테이블의 각 행은 하나의 검색 쿼리를 나타내며, 사용자 ID, 검색 쿼리, 쿼리의 timestamp에 해당하는 컬럼을 포함합니다. uniqUpTo를 사용하면 최소 5명의 고유 사용자가 검색한 키워드만 표시하는 보고서를 만들 수 있습니다.
SELECT SearchPhrase
FROM SearchLog
GROUP BY SearchPhrase
HAVING uniqUpTo(4)(UserID) >= 5
uniqUpTo(4)(UserID)는 각 SearchPhrase에 대해 고유한 UserID 값의 개수를 계산하지만, 최대 4개의 고유 값만 셉니다. 특정 SearchPhrase에 대해 고유한 UserID 값이 4개를 초과하면 함수는 5(4 + 1)를 반환합니다. 그러면 HAVING 절은 고유한 UserID 값의 수가 5보다 작은 SearchPhrase 값을 걸러냅니다. 이렇게 하면 최소 5명의 고유 사용자가 사용한 검색 키워드 목록을 얻을 수 있습니다.
이 함수는 sumMap와 동일하게 동작하지만, 여기에 더해 필터링에 사용할 키 배열도 매개변수로 받습니다. 이는 특히 키의 카디널리티가 높은 경우에 유용합니다.
구문
sumMapFiltered(keys_to_keep)(keys, values)
매개변수
keys_to_keep: 필터링에 사용할 키의 배열입니다.keys: 키의 배열입니다.values: 값의 배열입니다.
반환 값
- 2개의 배열로 이루어진 튜플을 반환합니다. 첫 번째 배열에는 정렬된 순서의 키가, 두 번째 배열에는 해당 키별로 합산된 값이 들어 있습니다.
예시
CREATE TABLE sum_map
(
`date` Date,
`timeslot` DateTime,
`statusMap` Nested(status UInt16, requests UInt64)
)
ENGINE = Log
INSERT INTO sum_map VALUES
('2000-01-01', '2000-01-01 00:00:00', [1, 2, 3], [10, 10, 10]),
('2000-01-01', '2000-01-01 00:00:00', [3, 4, 5], [10, 10, 10]),
('2000-01-01', '2000-01-01 00:01:00', [4, 5, 6], [10, 10, 10]),
('2000-01-01', '2000-01-01 00:01:00', [6, 7, 8], [10, 10, 10]);
SELECT sumMapFiltered([1, 4, 8])(statusMap.status, statusMap.requests) FROM sum_map;
┌─sumMapFiltered([1, 4, 8])(statusMap.status, statusMap.requests)─┐
1. │ ([1,4,8],[10,20,10]) │
└─────────────────────────────────────────────────────────────────┘
sumMapFilteredWithOverflow
sumMapFilteredWithOverflow(keys_to_keep)(keys, values)
매개변수
keys_to_keep: 필터링할 키의 배열입니다.keys: 키의 배열입니다.values: 값의 배열입니다.
반환 값
- 두 개의 배열로 이루어진 튜플을 반환합니다. 하나는 정렬된 순서의 키이고, 다른 하나는 각 키에 해당하는 합산 값입니다.
예시
이 예시에서는 sum_map 테이블을 생성하고 일부 데이터를 삽입한 다음, 결과를 비교하기 위해 sumMapFilteredWithOverflow, sumMapFiltered, 그리고 toTypeName 함수를 사용합니다. 생성한 테이블에서 requests의 타입은 UInt8입니다. sumMapFiltered는 오버플로우를 방지하기 위해 합산된 값의 타입을 UInt64로 승격하지만, sumMapFilteredWithOverflow는 타입을 UInt8로 유지합니다. 이 타입은 결과를 저장하기에 충분히 크지 않으므로, 즉 오버플로우가 발생합니다.
CREATE TABLE sum_map
(
`date` Date,
`timeslot` DateTime,
`statusMap` Nested(status UInt8, requests UInt8)
)
ENGINE = Log
INSERT INTO sum_map VALUES
('2000-01-01', '2000-01-01 00:00:00', [1, 2, 3], [10, 10, 10]),
('2000-01-01', '2000-01-01 00:00:00', [3, 4, 5], [10, 10, 10]),
('2000-01-01', '2000-01-01 00:01:00', [4, 5, 6], [10, 10, 10]),
('2000-01-01', '2000-01-01 00:01:00', [6, 7, 8], [10, 10, 10]);
SELECT sumMapFilteredWithOverflow([1, 4, 8])(statusMap.status, statusMap.requests) as summap_overflow, toTypeName(summap_overflow) FROM sum_map;
SELECT sumMapFiltered([1, 4, 8])(statusMap.status, statusMap.requests) as summap, toTypeName(summap) FROM sum_map;
┌─sum──────────────────┬─toTypeName(sum)───────────────────┐
1. │ ([1,4,8],[10,20,10]) │ Tuple(Array(UInt8), Array(UInt8)) │
└──────────────────────┴───────────────────────────────────┘
┌─summap───────────────┬─toTypeName(summap)─────────────────┐
1. │ ([1,4,8],[10,20,10]) │ Tuple(Array(UInt8), Array(UInt64)) │
└──────────────────────┴────────────────────────────────────┘
SET allow_experimental_funnel_functions = 1로 설정하십시오.
구문
sequenceNextNode(direction, base)(timestamp, event_column, base_condition, event1, event2, event3, ...)
-
direction — 진행 방향을 지정하는 데 사용됩니다.
- forward — 앞으로 진행합니다.
- backward — 뒤로 진행합니다.
-
base — 기준점을 설정하는 데 사용됩니다.
- head — 기준점을 첫 번째 이벤트로 설정합니다.
- tail — 기준점을 마지막 이벤트로 설정합니다.
- first_match — 기준점을 처음으로 일치한
event1로 설정합니다.
- last_match — 기준점을 마지막으로 일치한
event1로 설정합니다.
인수
timestamp — 타임스탬프가 들어 있는 컬럼의 이름입니다. 지원되는 데이터 타입: Date, DateTime 및 기타 부호 없는 정수 타입.event_column — 반환할 다음 이벤트의 값이 들어 있는 컬럼의 이름입니다. 지원되는 데이터 타입: String 및 Nullable(String).base_condition — 기준점이 충족해야 하는 조건입니다.event1, event2, … — 이벤트 체인을 설명하는 조건입니다. UInt8.
반환 값
event_column[next_index] — 패턴이 일치하고 다음 값이 존재하는 경우입니다.NULL - 패턴이 일치하지 않거나 다음 값이 존재하지 않는 경우입니다.
유형: Nullable(String).
예시
이 함수는 이벤트가 A->B->C->D->E일 때 B->C 다음 이벤트, 즉 D를 확인하려는 경우 사용할 수 있습니다.
A->B 다음 이벤트를 찾는 쿼리 문은 다음과 같습니다:
CREATE TABLE test_flow (
dt DateTime,
id int,
page String)
ENGINE = MergeTree()
PARTITION BY toYYYYMMDD(dt)
ORDER BY id;
INSERT INTO test_flow VALUES (1, 1, 'A') (2, 1, 'B') (3, 1, 'C') (4, 1, 'D') (5, 1, 'E');
SELECT id, sequenceNextNode('forward', 'head')(dt, page, page = 'A', page = 'A', page = 'B') as next_flow FROM test_flow GROUP BY id;
┌─id─┬─next_flow─┐
│ 1 │ C │
└────┴───────────┘
forward와 head의 동작
ALTER TABLE test_flow DELETE WHERE 1 = 1 settings mutations_sync = 1;
INSERT INTO test_flow VALUES (1, 1, 'Home') (2, 1, 'Gift') (3, 1, 'Exit');
INSERT INTO test_flow VALUES (1, 2, 'Home') (2, 2, 'Home') (3, 2, 'Gift') (4, 2, 'Basket');
INSERT INTO test_flow VALUES (1, 3, 'Gift') (2, 3, 'Home') (3, 3, 'Gift') (4, 3, 'Basket');
SELECT id, sequenceNextNode('forward', 'head')(dt, page, page = 'Home', page = 'Home', page = 'Gift') FROM test_flow GROUP BY id;
dt id page
1970-01-01 09:00:01 1 Home // 기준점, Home과 일치함
1970-01-01 09:00:02 1 Gift // Gift와 일치함
1970-01-01 09:00:03 1 Exit // 결과
1970-01-01 09:00:01 2 Home // 기준점, Home과 일치함
1970-01-01 09:00:02 2 Home // Gift와 일치하지 않음
1970-01-01 09:00:03 2 Gift
1970-01-01 09:00:04 2 Basket
1970-01-01 09:00:01 3 Gift // 기준점, Home과 일치하지 않음
1970-01-01 09:00:02 3 Home
1970-01-01 09:00:03 3 Gift
1970-01-01 09:00:04 3 Basket
backward와 tail의 동작
SELECT id, sequenceNextNode('backward', 'tail')(dt, page, page = 'Basket', page = 'Basket', page = 'Gift') FROM test_flow GROUP BY id;
dt id page
1970-01-01 09:00:01 1 Home
1970-01-01 09:00:02 1 Gift
1970-01-01 09:00:03 1 Exit // 기준점, Basket과 불일치
1970-01-01 09:00:01 2 Home
1970-01-01 09:00:02 2 Home // 결과값
1970-01-01 09:00:03 2 Gift // Gift와 일치
1970-01-01 09:00:04 2 Basket // 기준점, Basket과 일치
1970-01-01 09:00:01 3 Gift
1970-01-01 09:00:02 3 Home // 결과값
1970-01-01 09:00:03 3 Gift // 기준점, Gift와 일치
1970-01-01 09:00:04 3 Basket // 기준점, Basket과 일치
forward 및 first_match의 작동 방식
SELECT id, sequenceNextNode('forward', 'first_match')(dt, page, page = 'Gift', page = 'Gift') FROM test_flow GROUP BY id;
dt id page
1970-01-01 09:00:01 1 Home
1970-01-01 09:00:02 1 Gift // 기준점
1970-01-01 09:00:03 1 Exit // 결과
1970-01-01 09:00:01 2 Home
1970-01-01 09:00:02 2 Home
1970-01-01 09:00:03 2 Gift // 기준점
1970-01-01 09:00:04 2 Basket The result
1970-01-01 09:00:01 3 Gift // 기준점
1970-01-01 09:00:02 3 Home // 결과
1970-01-01 09:00:03 3 Gift
1970-01-01 09:00:04 3 Basket
SELECT id, sequenceNextNode('forward', 'first_match')(dt, page, page = 'Gift', page = 'Gift', page = 'Home') FROM test_flow GROUP BY id;
dt id page
1970-01-01 09:00:01 1 Home
1970-01-01 09:00:02 1 Gift // 기준점
1970-01-01 09:00:03 1 Exit // Home과 일치하지 않음
1970-01-01 09:00:01 2 Home
1970-01-01 09:00:02 2 Home
1970-01-01 09:00:03 2 Gift // 기준점
1970-01-01 09:00:04 2 Basket // Home과 일치하지 않음
1970-01-01 09:00:01 3 Gift // 기준점
1970-01-01 09:00:02 3 Home // Home과 일치함
1970-01-01 09:00:03 3 Gift // 결과값
1970-01-01 09:00:04 3 Basket
backward 및 last_match의 동작 방식
SELECT id, sequenceNextNode('backward', 'last_match')(dt, page, page = 'Gift', page = 'Gift') FROM test_flow GROUP BY id;
dt id page
1970-01-01 09:00:01 1 Home // 결과
1970-01-01 09:00:02 1 Gift // 기준점
1970-01-01 09:00:03 1 Exit
1970-01-01 09:00:01 2 Home
1970-01-01 09:00:02 2 Home // 결과
1970-01-01 09:00:03 2 Gift // 기준점
1970-01-01 09:00:04 2 Basket
1970-01-01 09:00:01 3 Gift
1970-01-01 09:00:02 3 Home // 결과
1970-01-01 09:00:03 3 Gift // 기준점
1970-01-01 09:00:04 3 Basket
SELECT id, sequenceNextNode('backward', 'last_match')(dt, page, page = 'Gift', page = 'Gift', page = 'Home') FROM test_flow GROUP BY id;
dt id page
1970-01-01 09:00:01 1 Home // Home과 일치하지만 결과는 NULL
1970-01-01 09:00:02 1 Gift // 기준점
1970-01-01 09:00:03 1 Exit
1970-01-01 09:00:01 2 Home // 결과
1970-01-01 09:00:02 2 Home // Home과 일치
1970-01-01 09:00:03 2 Gift // 기준점
1970-01-01 09:00:04 2 Basket
1970-01-01 09:00:01 3 Gift // 결과
1970-01-01 09:00:02 3 Home // Home과 일치
1970-01-01 09:00:03 3 Gift // 기준점
1970-01-01 09:00:04 3 Basket
base_condition의 동작
CREATE TABLE test_flow_basecond
(
`dt` DateTime,
`id` int,
`page` String,
`ref` String
)
ENGINE = MergeTree
PARTITION BY toYYYYMMDD(dt)
ORDER BY id;
INSERT INTO test_flow_basecond VALUES (1, 1, 'A', 'ref4') (2, 1, 'A', 'ref3') (3, 1, 'B', 'ref2') (4, 1, 'B', 'ref1');
SELECT id, sequenceNextNode('forward', 'head')(dt, page, ref = 'ref1', page = 'A') FROM test_flow_basecond GROUP BY id;
dt id page ref
1970-01-01 09:00:01 1 A ref4 // head의 ref 컬럼이 'ref1'과 일치하지 않기 때문에 head는 기준점(base point)이 될 수 없습니다.
1970-01-01 09:00:02 1 A ref3
1970-01-01 09:00:03 1 B ref2
1970-01-01 09:00:04 1 B ref1
SELECT id, sequenceNextNode('backward', 'tail')(dt, page, ref = 'ref4', page = 'B') FROM test_flow_basecond GROUP BY id;
dt id page ref
1970-01-01 09:00:01 1 A ref4
1970-01-01 09:00:02 1 A ref3
1970-01-01 09:00:03 1 B ref2
1970-01-01 09:00:04 1 B ref1 // tail의 ref 컬럼이 'ref4'와 일치하지 않기 때문에 tail은 기준점(base point)이 될 수 없습니다.
SELECT id, sequenceNextNode('forward', 'first_match')(dt, page, ref = 'ref3', page = 'A') FROM test_flow_basecond GROUP BY id;
dt id page ref
1970-01-01 09:00:01 1 A ref4 // ref 컬럼이 'ref3'과 일치하지 않으므로 이 행은 기준점이 될 수 없습니다.
1970-01-01 09:00:02 1 A ref3 // 기준점
1970-01-01 09:00:03 1 B ref2 // 결과
1970-01-01 09:00:04 1 B ref1
SELECT id, sequenceNextNode('backward', 'last_match')(dt, page, ref = 'ref2', page = 'B') FROM test_flow_basecond GROUP BY id;
dt id page ref
1970-01-01 09:00:01 1 A ref4
1970-01-01 09:00:02 1 A ref3 // 결과
1970-01-01 09:00:03 1 B ref2 // 기준점
1970-01-01 09:00:04 1 B ref1 // 이 행은 ref 컬럼이 'ref2'와 일치하지 않으므로 기준점이 될 수 없습니다.
