mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-11-17 13:13:36 +00:00

christophe.kalenzaga 2dae69a40b add == operators in sequence*() aggregate fuctions

2021-06-15 18:58:20 +02:00

37 KiB

Raw Blame History

toc_priority	toc_title
38	Параметрические агрегатные функции

Параметрические агрегатные функции

Некоторые агрегатные функции могут принимать не только столбцы-аргументы (по которым производится свёртка), но и набор параметров - констант для инициализации. Синтаксис - две пары круглых скобок вместо одной. Первая - для параметров, вторая - для аргументов.

histogram

Рассчитывает адаптивную гистограмму. Не гарантирует точного результата.

histogram(number_of_bins)(values)

Функция использует A Streaming Parallel Decision Tree Algorithm. Границы столбцов устанавливаются по мере поступления новых данных в функцию. В общем случае столбцы имею разную ширину.

Аргументы

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

С помощью функции bar можно визуализировать гистограмму, например:

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, …)

Проверяет, содержит ли последовательность событий цепочку, которая соответствует указанному шаблону.

sequenceMatch(pattern)(timestamp, cond1, cond2, ...)

!!! warning "Предупреждение" События, произошедшие в одну и ту же секунду, располагаются в последовательности в неопределенном порядке, что может повлиять на результат работы функции.

Аргументы

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

Функция нашла цепочку событий, в которой число 2 следует за числом 1. Число 3 между ними было пропущено, поскольку оно не было использовано ни в одном из условий.

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

В этом случае функция не может найти цепочку событий, соответствующую шаблону, поскольку событие для числа 3 произошло между 1 и 2. Если бы в этом же случае мы бы проверяли условие на событие для числа 4, то цепочка бы соответствовала шаблону.

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

sequenceCount(pattern)(time, cond1, cond2, …)

Вычисляет количество цепочек событий, соответствующих шаблону. Функция обнаруживает только непересекающиеся цепочки событий. Она начитает искать следующую цепочку только после того, как полностью совпала текущая цепочка событий.

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

Вычислим сколько раз число 2 стоит после числа 1, причем между 1 и 2 могут быть любые числа:

SELECT sequenceCount('(?1).*(?2)')(time, number = 1, number = 2) FROM t

┌─sequenceCount('(?1).*(?2)')(time, equals(number, 1), equals(number, 2))─┐
│                                                                       2 │
└─────────────────────────────────────────────────────────────────────────┘

Смотрите также

sequenceMatch

windowFunnel

Отыскивает цепочки событий в скользящем окне по времени и вычисляет максимальное количество произошедших событий из цепочки.

Функция работает по алгоритму:

Функция отыскивает данные, на которых срабатывает первое условие из цепочки, и присваивает счетчику событий значение 1. С этого же момента начинается отсчет времени скользящего окна.
Если в пределах окна последовательно попадаются события из цепочки, то счетчик увеличивается. Если последовательность событий нарушается, то счетчик не растет.
Если в данных оказалось несколько цепочек разной степени завершенности, то функция выдаст только размер самой длинной цепочки.

Синтаксис

windowFunnel(window, [mode, [mode, ... ]])(timestamp, cond1, cond2, ..., condN)

Аргументы

timestamp — имя столбца, содержащего временные отметки. Date, DateTime и другие параметры с типом Integer. В случае хранения меток времени в столбцах с типом UInt64, максимально допустимое значение соответствует ограничению для типа Int64, т.е. равно 2^63-1.
cond — условия или данные, описывающие цепочку событий. UInt8.

Параметры

window — ширина скользящего окна по времени. Это время между первым и последним условием. Единица измерения зависит от timestamp и может варьироваться. Должно соблюдаться условие timestamp события cond1 <= timestamp события cond2 <= ... <= timestamp события condN <= timestamp события cond1 + window.
mode — необязательный параметр. Может быть установленно несколько значений одновременно.
- 'strict' — не учитывать подряд идущие повторяющиеся события.
- 'strict_order' — запрещает посторонние события в искомой последовательности. Например, при поиске цепочки A->B->C в A->B->D->C поиск будет остановлен на D и функция вернет 2.
- 'strict_increase' — условия прменяются только для событий со строго возрастающими временными метками.

Возвращаемое значение

Максимальное количество последовательно сработавших условий из цепочки в пределах скользящего окна по времени. Исследуются все цепочки в выборке.

Тип: Integer.

Пример

Определим, успевает ли пользователь за установленный период выбрать телефон в интернет-магазине, купить его и сделать повторный заказ.

Зададим следующую цепочку событий:

Пользователь вошел в личный кабинет (eventID = 1001).
Пользователь ищет телефон (eventID = 1003, 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 смог пройти по цепочке за период в январе-феврале 2019-го года.

Запрос:

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;

retention

Аналитическая функция, которая показывает, насколько выдерживаются те или иные условия, например, удержание динамики/уровня посещаемости сайта.

Функция принимает набор (от 1 до 32) логических условий, как в WHERE, и применяет их к заданному набору данных.

Условия, кроме первого, применяются попарно: результат второго будет истинным, если истинно первое и второе, третьего - если истинно первое и третье и т.д.

Синтаксис

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

2. Сгруппируем пользователей по уникальному идентификатору uid с помощью функции retention.

Запрос:

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

3. Рассчитаем количество посещений сайта за день.

Запрос:

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

uniqUpTo(N)(x)

Вычисляет количество различных значений аргумента, если оно меньше или равно N. В случае, если количество различных значений аргумента больше N, возвращает N + 1.

Рекомендуется использовать для маленьких N - до 10. Максимальное значение N - 100.

Для состояния агрегатной функции используется количество оперативки равное 1 + N * размер одного значения байт. Для строк запоминается не криптографический хэш, имеющий размер 8 байт. То есть, для строк вычисление приближённое.

Функция также работает для нескольких аргументов.

Работает максимально быстро за исключением патологических случаев, когда используется большое значение N и количество уникальных значений чуть меньше N.

Пример применения:

Задача: показывать в отчёте только поисковые фразы, по которым было хотя бы 5 уникальных посетителей.
Решение: пишем в запросе GROUP BY SearchPhrase HAVING uniqUpTo(4)(UserID) >= 5

sequenceNextNode

Возвращает значение следующего события, соответствующего цепочке событий.

Экспериментальная функция, чтобы включить ее, выполните: 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 — название столбца, содержащего 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  Результат
                                     
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 // Начало не может быть исходной точкой, поскольку столбец ref не соответствует 'ref1'.
 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 // Конец не может быть исходной точкой, поскольку столбец ref не соответствует 'ref4'.

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

37 KiB Raw Blame History Unescape Escape

Параметрические агрегатные функции

histogram

sequenceMatch(pattern)(timestamp, cond1, cond2, …)

sequenceCount(pattern)(time, cond1, cond2, …)

windowFunnel

retention

uniqUpTo(N)(x)

sequenceNextNode

37 KiB

Raw Blame History