参数聚合函数

    计算自适应直方图。 它不能保证精确的结果。

    该函数使用 流式并行决策树算法. 当新数据输入函数时，hist图分区的边界将被调整。 在通常情况下，箱的宽度不相等。

    参数

    — 直方图bin个数，这个函数会自动计算bin的数量，而且会尽量使用指定值，如果无法做到，那就使用更小的bin个数。

    values — 输入值。

    返回值

    • Array 的 如下：

      1. ```
      2. [(lower_1, upper_1, height_1), ... (lower_N, upper_N, height_N)]
      3. ```
      5. - `lower` — bin的下边界。
      6. - `upper` — bin的上边界。
      7. - `height` — bin的计算权重。

    示例

    1. SELECT histogram(5)(number + 1)
    2. FROM (
    3.     SELECT *
    4.     FROM system.numbers
    5.     LIMIT 20
    6. )
    1. ┌─histogram(5)(plus(number, 1))───────────────────────────────────────────┐
    2. │ [(1,4.5,4),(4.5,8.5,4),(8.5,12.75,4.125),(12.75,17,4.625),(17,20,3.25)] │
    3. └─────────────────────────────────────────────────────────────────────────┘

    您可以使用 bar 功能，例如:

    1. WITH histogram(5)(rand() % 100) AS hist
    2. SELECT
    3.     arrayJoin(hist).3 AS height,
    4.     bar(height, 0, 6, 5) AS bar
    5. FROM
    6. (
    7.     SELECT *
    8.     FROM system.numbers
    9.     LIMIT 20
    10. )
    1. ┌─height─┬─bar───┐
    2. │  2.125 │ █▋    │
    3. │   3.25 │ ██▌   │
    4. │  5.625 │ ████▏ │
    5. │  5.625 │ ████▏ │
    6. │  3.375 │ ██▌   │
    7. └────────┴───────┘

    在这种情况下，您应该记住您不知道直方图bin边界。

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

    检查序列是否包含与模式匹配的事件链。

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

    警告

    在同一秒钟发生的事件可能以未定义的顺序排列在序列中，影响结果。

    参数

    • pattern — 模式字符串。 参考 模式语法.

    • timestamp — 包含时间的列。典型的时间类型是： Date 和 DateTime。您还可以使用任何支持的 数据类型。

    • cond1, cond2 — 事件链的约束条件。 数据类型是： UInt8。 最多可以传递32个条件参数。 该函数只考虑这些条件中描述的事件。 如果序列包含未在条件中描述的数据，则函数将跳过这些数据。

    返回值

    • 1，如果模式匹配。
    • 0，如果模式不匹配。

    类型: UInt8.

    模式语法

    • (?N) — 在位置N匹配条件参数。 条件在编号 [1, 32] 范围。 例如, (?1) 匹配传递给 cond1 参数。

    • .* — 匹配任何事件的数字。 不需要条件参数来匹配这个模式。

    • (?t operator value) — 分开两个事件的时间。 例如： (?1)(?t>1800)(?2) 匹配彼此发生超过1800秒的事件。 这些事件之间可以存在任意数量的任何事件。 您可以使用 >=, >, <, <=, == 运算符。

    例

    考虑在数据 t 表:

    1. ┌─time─┬─number─┐
    2. │    1 │      1 │
    3. │    2 │      3 │
    4. │    3 │      2 │
    5. └──────┴────────┘

    执行查询:

    1. SELECT sequenceMatch('(?1)(?2)')(time, number = 1, number = 2) FROM t
    1. ┌─sequenceMatch('(?1)(?2)')(time, equals(number, 1), equals(number, 2))─┐
    2. │                                                                     1 │
    3. └───────────────────────────────────────────────────────────────────────┘

    该函数找到了数字2跟随数字1的事件链。 它跳过了它们之间的数字3，因为该数字没有被描述为事件。 如果我们想在搜索示例中给出的事件链时考虑这个数字，我们应该为它创建一个条件。

    1. ┌─sequenceMatch('(?1)(?2)')(time, equals(number, 1), equals(number, 2), equals(number, 3))─┐
    2. │                                                                                        0 │
    3. └──────────────────────────────────────────────────────────────────────────────────────────┘

    在这种情况下，函数找不到与模式匹配的事件链，因为数字3的事件发生在1和2之间。 如果在相同的情况下，我们检查了数字4的条件，则序列将与模式匹配。

    1. SELECT sequenceMatch('(?1)(?2)')(time, number = 1, number = 2, number = 4) FROM t
    1. ┌─sequenceMatch('(?1)(?2)')(time, equals(number, 1), equals(number, 2), equals(number, 4))─┐
    2. │                                                                                        1 │
    3. └──────────────────────────────────────────────────────────────────────────────────────────┘

    计算与模式匹配的事件链的数量。该函数搜索不重叠的事件链。当前链匹配后，它开始搜索下一个链。

    警告

    在同一秒钟发生的事件可能以未定义的顺序排列在序列中，影响结果。

    参数

    • pattern — 模式字符串。 参考：模式语法.

    • timestamp — 包含时间的列。典型的时间类型是： Date 和 DateTime。您还可以使用任何支持的 数据类型。

    • cond1, cond2 — 事件链的约束条件。 数据类型是： UInt8。 最多可以传递32个条件参数。该函数只考虑这些条件中描述的事件。 如果序列包含未在条件中描述的数据，则函数将跳过这些数据。

    返回值

    • 匹配的非重叠事件链数。

    类型: UInt64.

    示例

    考虑在数据 t 表:

    1. ┌─time─┬─number─┐
    2. │    1 │      1 │
    3. │    2 │      3 │
    4. │    3 │      2 │
    5. │    4 │      1 │
    6. │    5 │      3 │
    7. │    6 │      2 │
    8. └──────┴────────┘

    计算数字2在数字1之后出现的次数以及它们之间的任何其他数字:

    1. SELECT sequenceCount('(?1).*(?2)')(time, number = 1, number = 2) FROM t
    1. ┌─sequenceCount('(?1).*(?2)')(time, equals(number, 1), equals(number, 2))─┐
    2. │                                                                       2 │
    3. └─────────────────────────────────────────────────────────────────────────┘

    另请参阅

    windowFunnel

    搜索滑动时间窗中的事件链，并计算从链中发生的最大事件数。

    该函数采用如下算法：

    • 该函数搜索触发链中的第一个条件并将事件计数器设置为1。 这是滑动窗口启动的时刻。

    • 如果来自链的事件在窗口内顺序发生，则计数器将递增。 如果事件序列中断，则计数器不会增加。

    • 如果数据在不同的完成点具有多个事件链，则该函数将仅输出最长链的大小。

    语法

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

    参数

    • window — 滑动窗户的大小，单位是秒。
    • mode - 这是一个可选的参数。
      • 'strict' - 当 'strict' 设置时，windowFunnel()仅对唯一值应用匹配条件。
    • timestamp — 包含时间的列。 数据类型支持： 日期, 和其他无符号整数类型（请注意，即使时间戳支持 UInt64 类型，它的值不能超过Int64最大值，即2^63-1）。
    • cond — 事件链的约束条件。 UInt8 类型。

    返回值

    滑动时间窗口内连续触发条件链的最大数目。
    对选择中的所有链进行了分析。

    类型: Integer.

    示例

    确定设定的时间段是否足以让用户选择手机并在在线商店中购买两次。

    设置以下事件链:

    1. 用户登录到其在应用商店中的帐户 (eventID = 1003).
    2. 用户搜索手机 (eventID = 1007, product = 'phone').
    3. 用户下了订单 (eventID = 1009).
    4. 用户再次下订单 (eventID = 1010).

    输入表:

    1. ┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐
    2. │ 2019-01-28 │       1 │ 2019-01-29 10:00:00 │    1003 │ phone   │
    3. └────────────┴─────────┴─────────────────────┴─────────┴─────────┘
    4. ┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐
    5. │ 2019-01-31 │       1 │ 2019-01-31 09:00:00 │    1007 │ phone   │
    6. └────────────┴─────────┴─────────────────────┴─────────┴─────────┘
    7. ┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐
    8. │ 2019-01-30 │       1 │ 2019-01-30 08:00:00 │    1009 │ phone   │
    9. └────────────┴─────────┴─────────────────────┴─────────┴─────────┘
    10. ┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐
    11. │ 2019-02-01 │       1 │ 2019-02-01 08:00:00 │    1010 │ phone   │
    12. └────────────┴─────────┴─────────────────────┴─────────┴─────────┘

    了解用户user_id 可以在2019的1-2月期间通过链条多远。

    结果:

    1. ┌─level─┬─c─┐
    2. │     4 │ 1 │
    3. └───────┴───┘

    该函数将一组条件作为参数，类型为1到32个 UInt8 类型的参数，用来表示事件是否满足特定条件。
    任何条件都可以指定为参数（如 ).

    除了第一个以外，条件成对适用：如果第一个和第二个是真的，第二个结果将是真的，如果第一个和第三个是真的，第三个结果将是真的，等等。

    语法

    1. retention(cond1, cond2, ..., cond32);

    参数

    • cond — 返回 UInt8 结果（1或0）的表达式。

    返回值

    数组为1或0。

    • 1 — 条件满足。
    • 0 — 条件不满足。

    类型: UInt8.

    示例

    让我们考虑使用 retention 功能的一个例子 ，以确定网站流量。

    1. 举例说明，先创建一张表。

    1. CREATE TABLE retention_test(date Date, uid Int32) ENGINE = Memory;
    3. INSERT INTO retention_test SELECT '2020-01-01', number FROM numbers(5);
    4. INSERT INTO retention_test SELECT '2020-01-02', number FROM numbers(10);
    5. INSERT INTO retention_test SELECT '2020-01-03', number FROM numbers(15);

    输入表:

    查询:

    1. SELECT * FROM retention_test

    结果:

    1. ┌───────date─┬─uid─┐
    2. │ 2020-01-01 │   0 │
    3. │ 2020-01-01 │   1 │
    4. │ 2020-01-01 │   2 │
    5. │ 2020-01-01 │   3 │
    6. │ 2020-01-01 │   4 │
    7. └────────────┴─────┘
    8. ┌───────date─┬─uid─┐
    9. │ 2020-01-02 │   0 │
    10. │ 2020-01-02 │   1 │
    12. │ 2020-01-02 │   4 │
    13. │ 2020-01-02 │   5 │
    14. │ 2020-01-02 │   6 │
    15. │ 2020-01-02 │   7 │
    16. │ 2020-01-02 │   8 │
    17. │ 2020-01-02 │   9 │
    18. └────────────┴─────┘
    19. ┌───────date─┬─uid─┐
    20. │ 2020-01-03 │   0 │
    21. │ 2020-01-03 │   1 │
    22. │ 2020-01-03 │   2 │
    23. │ 2020-01-03 │   3 │
    24. │ 2020-01-03 │   4 │
    25. │ 2020-01-03 │   5 │
    26. │ 2020-01-03 │   6 │
    27. │ 2020-01-03 │   7 │
    28. │ 2020-01-03 │   8 │
    29. │ 2020-01-03 │   9 │
    30. │ 2020-01-03 │  10 │
    31. │ 2020-01-03 │  11 │
    32. │ 2020-01-03 │  12 │
    33. │ 2020-01-03 │  13 │
    34. │ 2020-01-03 │  14 │
    35. └────────────┴─────┘

    2. 按唯一ID uid 对用户进行分组，使用 retention 功能。

    查询:

    1. SELECT
    2.     uid,
    3.     retention(date = '2020-01-01', date = '2020-01-02', date = '2020-01-03') AS r
    4. FROM retention_test
    5. WHERE date IN ('2020-01-01', '2020-01-02', '2020-01-03')
    6. GROUP BY uid
    7. ORDER BY uid ASC

    结果:

    1. ┌─uid─┬─r───────┐
    2. │   0 │ [1,1,1] │
    3. │   1 │ [1,1,1] │
    4. │   2 │ [1,1,1] │
    5. │   3 │ [1,1,1] │
    6. │   4 │ [1,1,1] │
    7. │   5 │ [0,0,0] │
    8. │   6 │ [0,0,0] │
    9. │   7 │ [0,0,0] │
    10. │   8 │ [0,0,0] │
    11. │   9 │ [0,0,0] │
    12. │  10 │ [0,0,0] │
    13. │  11 │ [0,0,0] │
    14. │  12 │ [0,0,0] │
    15. │  13 │ [0,0,0] │
    16. │  14 │ [0,0,0] │
    17. └─────┴─────────┘

    3. 计算每天的现场访问总数。

    查询:

    1. SELECT
    2.     sum(r[1]) AS r1,
    3.     sum(r[2]) AS r2,
    4.     sum(r[3]) AS r3
    5. FROM
    6. (
    7.     SELECT
    8.         uid,
    9.         retention(date = '2020-01-01', date = '2020-01-02', date = '2020-01-03') AS r
    10.     FROM retention_test
    11.     WHERE date IN ('2020-01-01', '2020-01-02', '2020-01-03')
    12.     GROUP BY uid
    13. )

    结果:

    1. ┌─r1─┬─r2─┬─r3─┐
    2. │  5 │  5 │  5 │
    3. └────┴────┴────┘

    条件:

    • r1-2020-01-01期间访问该网站的独立访问者数量（ cond1 条件）。
    • r3-在2020-01-01和2020-01-03之间的特定时间段内访问该网站的唯一访问者的数量 (cond1 和 条件）。

    uniqUpTo(N)(x)

    计算小于或者等于N的不同参数的个数。如果结果大于N，那返回N+1。

    建议使用较小的Ns，比如：10。N的最大值为100。

    对于聚合函数的状态，它使用的内存量等于1+N*一个字节值的大小。
    对于字符串，它存储8个字节的非加密哈希。 也就是说，计算是近似的字符串。

    该函数也适用于多个参数。

    它的工作速度尽可能快，除了使用较大的N值并且唯一值的数量略小于N的情况。

    用法示例:

    和 基本一致， 除了一个键数组作为参数传递。这在使用高基数key时尤其有用。