Quantile

计算数字序列的近似分位数。
此函数应用 reservoir sampling，使用高达8192的水塘大小和随机数发生器采样。
结果是不确定的。要获得精确的分位数，使用 quantileExact 函数。
当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用 quantiles 函数。

语法

quantile(level)(expr)

别名: median。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。我们推荐 level 值的范围为 [0.01, 0.99]。默认值：0.5。当 level=0.5 时，该函数计算 中位数。
• expr — 求值表达式，类型为数值类型data types, Date 或 DateTime。

返回值

• 指定层次的分位数。

类型:

• Float64 用于数字数据类型输入。
• Date 如果输入值是 Date 类型。
• DateTime 如果输入值是 DateTime 类型。

示例

输入表:

┌─val─┐
│   1 │
│   1 │
│   2 │
│   3 │
└─────┘

查询:

SELECT quantile(val) FROM t

结果:

┌─quantile(val)─┐
│           1.5 │
└───────────────┘

计算数字序列的近似分位数。

此功能适用 水塘抽样，使用储存器最大到8192和随机数发生器进行采样。 结果是非确定性的。 要获得精确的分位数，请使用 quantileExact 功能。

当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用quantiles功能。

语法

quantileDeterministic(level)(expr, determinator)

别名: medianDeterministic。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。 我们推荐 level 值的范围为 [0.01, 0.99]。默认值：0.5。 当 level=0.5时，该函数计算 中位数。

• expr — 求值表达式，类型为数值类型data types, Date 或 DateTime。

• determinator — 一个数字，其hash被用来代替在水塘抽样中随机生成的数字，这样可以保证取样的确定性。你可以使用用户ID或者事件ID等任何正数，但是如果相同的 determinator 出现多次，那结果很可能不正确。
  返回值

• 指定层次的近似分位数。

类型:

• Float64 用于数字数据类型输入。
• Date 如果输入值是 Date 类型。
• DateTime 如果输入值是 DateTime 类型。

示例

输入表:

┌─val─┐
│   1 │
│   1 │
│   2 │
│   3 │
└─────┘

查询:

SELECT quantileDeterministic(val, 1) FROM t

结果:

┌─quantileDeterministic(val, 1)─┐
│                           1.5 │
└───────────────────────────────┘

toc_priority: 202

准确计算数字序列的分位数。

为了准确计算，所有输入的数据被合并为一个数组，并且部分的排序。因此该函数需要 O(n) 的内存，n为输入数据的个数。但是对于少量数据来说，该函数还是非常有效的。

当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用 quantiles 函数。

语法

quantileExact(level)(expr)

别名: medianExact。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。我们推荐 level 值的范围为 [0.01, 0.99]。默认值：0.5。当 level=0.5 时，该函数计算中位数。
• expr — 求值表达式，类型为数值类型data types, Date 或 DateTime。

返回值

• 指定层次的分位数。

类型:

• Float64 对于数字数据类型输入。
• 日期 如果输入值具有 Date 类型。
• 日期时间 如果输入值具有 DateTime 类型。

示例

查询:

SELECT quantileExact(number) FROM numbers(10)

结果:

┌─quantileExact(number)─┐
│                     5 │
└───────────────────────┘

和 quantileExact 相似, 准确计算数字序列的分位数。

为了准确计算，所有输入的数据被合并为一个数组，并且全排序。这排序算法的复杂度是 O(N·log(N)), 其中 N = std::distance(first, last) 比较。

返回值取决于分位数级别和所选取的元素数量，即如果级别是 0.5, 函数返回偶数元素的低位中位数，奇数元素的中位数。中位数计算类似于 python 中使用的median_low的实现。

对于所有其他级别， 返回 level * size_of_array 值所对应的索引的元素值。

例如:

SELECT quantileExactLow(0.1)(number) FROM numbers(10)

┌─quantileExactLow(0.1)(number)─┐
│                             1 │
└───────────────────────────────┘

当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用 quantiles 函数。

语法

quantileExactLow(level)(expr)

别名: medianExactLow。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。我们推荐 level 值的范围为 [0.01, 0.99]。默认值：0.5。当 level=0.5 时，该函数计算 中位数。
• expr — — 求值表达式，类型为数值类型data types, Date 或 DateTime。

返回值

• 指定层次的分位数。

类型:

• Float64 用于数字数据类型输入。
• Date 如果输入值是 Date 类型。
• DateTime 如果输入值是 DateTime 类型。

示例

查询:

SELECT quantileExactLow(number) FROM numbers(10)

结果:

┌─quantileExactLow(number)─┐
│                        4 │
└──────────────────────────┘

和 quantileExact 相似, 准确计算数字序列的分位数。

为了准确计算，所有输入的数据被合并为一个数组，并且全排序。这排序算法的复杂度是 O(N·log(N)), 其中 N = std::distance(first, last) 比较。

返回值取决于分位数级别和所选取的元素数量，即如果级别是 0.5, 函数返回偶数元素的低位中位数，奇数元素的中位数。中位数计算类似于 python 中使用的median_high的实现。

对于所有其他级别， 返回 level * size_of_array 值所对应的索引的元素值。

这个实现与当前的 quantileExact 实现完全相似。

当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用 quantiles 函数。

语法

quantileExactHigh(level)(expr)

别名: medianExactHigh。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。我们推荐 level 值的范围为 [0.01, 0.99]。默认值：0.5。当 level=0.5 时，该函数计算 中位数。
• expr — — 求值表达式，类型为数值类型data types, Date 或 DateTime。

返回值

• 指定层次的分位数。

类型:

• Float64 用于数字数据类型输入。
• Date 如果输入值是 Date 类型。
• DateTime 如果输入值是 DateTime 类型。

示例

查询:

SELECT quantileExactHigh(number) FROM numbers(10)

结果:

┌─quantileExactHigh(number)─┐
│                         5 │
└───────────────────────────┘

考虑到每个元素的权重，然后准确计算数值序列的分位数。

为了准确计算，所有输入的数据被合并为一个数组，并且部分的排序。每个输入值需要根据 weight 计算求和。该算法使用哈希表。正因为如此，在数据重复较多的时候使用的内存是少于quantileExact的。 您可以使用此函数代替 quantileExact 并指定weight为 1 。

当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用 quantiles 函数。

语法

quantileExactWeighted(level)(expr, weight)

别名: medianExactWeighted。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。我们推荐 level 值的范围为 [0.01, 0.99]. 默认值：0.5。当 level=0.5 时，该函数计算 中位数。
• expr — 求值表达式，类型为数值类型data types, Date 或 DateTime。
• weight — 权重序列。 权重是一个数据出现的数值。

返回值

• 指定层次的分位数。

类型:

• Float64 对于数字数据类型输入。
• 日期 如果输入值具有 Date 类型。
• 日期时间 如果输入值具有 DateTime 类型。

示例

输入表:

┌─n─┬─val─┐
│ 0 │   3 │
│ 1 │   2 │
│ 2 │   1 │
│ 5 │   4 │
└───┴─────┘

查询:

SELECT quantileExactWeighted(n, val) FROM t

结果:

┌─quantileExactWeighted(n, val)─┐
│                             1 │
└───────────────────────────────┘

语法

quantiles(level1, level2, …)(x)

所有分位数函数(quantile)也有相应的分位数(quantiles)函数: quantiles, quantilesDeterministic, quantilesTiming, quantilesTimingWeighted, quantilesExact, quantilesExactWeighted, quantilesTDigest。 这些函数一次计算所列的级别的所有分位数, 并返回结果值的数组。

使用t-digest 算法计算数字序列近似分位数。

最大误差为1%。 内存消耗为 log(n)，这里 n 是值的个数。 结果取决于运行查询的顺序，并且是不确定的。

该函数的性能低于 quantile 或 quantileTiming 的性能。 从状态大小和精度的比值来看，这个函数比 quantile 更优秀。

当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用 quantiles 函数。

语法

quantileTDigest(level)(expr)

别名: medianTDigest。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。我们推荐 level 值的范围为 [0.01, 0.99] 。默认值：0.5。当 level=0.5 时，该函数计算 中位数。
• expr — 求值表达式，类型为数值类型data types, Date 或 DateTime。

返回值

• 指定层次的分位数。

类型:

• Float64 用于数字数据类型输入。
• Date 如果输入值是 Date 类型。
• DateTime 如果输入值是 DateTime 类型。

示例

查询:

SELECT quantileTDigest(number) FROM numbers(10)

结果:

┌─quantileTDigest(number)─┐
│                     4.5 │
└─────────────────────────┘

使用t-digest 算法计算数字序列近似分位数。该函数考虑了每个序列成员的权重。最大误差为1%。 内存消耗为 log(n)，这里 n 是值的个数。

该函数的性能低于 quantile 或 quantileTiming 的性能。 从状态大小和精度的比值来看，这个函数比 quantile 更优秀。

结果取决于运行查询的顺序，并且是不确定的。

当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用 quantiles 函数。

语法

quantileTDigestWeighted(level)(expr, weight)

别名: medianTDigestWeighted。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。我们推荐 level 值的范围为 [0.01, 0.99] 。默认值：0.5。 当 level=0.5 时，该函数计算 中位数。
• expr — 求值表达式，类型为数值类型data types, Date 或 DateTime。
• weight — 权重序列。 权重是一个数据出现的数值。

返回值

• 指定层次的分位数。

类型:

• Float64 用于数字数据类型输入。
• Date 如果输入值是 Date 类型。
• DateTime 如果输入值是 DateTime 类型。

示例

查询:

SELECT quantileTDigestWeighted(number, 1) FROM numbers(10)

结果:

┌─quantileTDigestWeighted(number, 1)─┐
│                                4.5 │
└────────────────────────────────────┘

使用确定的精度计算数字数据序列的分位数。

结果是确定性的（它不依赖于查询处理顺序）。该函数针对描述加载网页时间或后端响应时间等分布的序列进行了优化。

当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用quantiles函数。

语法

quantileTiming(level)(expr)

别名: medianTiming。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。我们推荐 level 值的范围为 [0.01, 0.99] 。默认值：0.5。当 level=0.5 时，该函数计算 中位数。

• expr — 求值表达式 返回 Float* 类型数值。

  • 如果输入负值，那结果是不可预期的。
  • 如果输入值大于30000（页面加载时间大于30s），那我们假设为30000。

精度

计算是准确的，如果:

• 值的总数不超过5670。
• 总数值超过5670，但页面加载时间小于1024ms。

否则，计算结果将四舍五入到16毫秒的最接近倍数。

!!! note "注"
对于计算页面加载时间分位数， 此函数比quantile更有效和准确。

返回值

• 指定层次的分位数。

类型: Float32。

!!! note "注"
如果没有值传递给函数（当使用 quantileTimingIf), NaN被返回。 这样做的目的是将这些案例与导致零的案例区分开来。 参见 ORDER BY clause 对于 NaN 值排序注意事项。

示例

输入表:

┌─response_time─┐
│            72 │
│           112 │
│           126 │
│           145 │
│           104 │
│           242 │
│           313 │
│           168 │
│           108 │
└───────────────┘

查询:

SELECT quantileTiming(response_time) FROM t

结果:

┌─quantileTiming(response_time)─┐
│                           126 │
└───────────────────────────────┘

toc_priority: 205

根据每个序列成员的权重，使用确定的精度计算数字序列的分位数。

结果是确定性的（它不依赖于查询处理顺序）。该函数针对描述加载网页时间或后端响应时间等分布的序列进行了优化。

当在一个查询中使用多个不同层次的 quantile* 时，内部状态不会被组合（即查询的工作效率低于组合情况）。在这种情况下，使用quantiles功能。

语法

quantileTimingWeighted(level)(expr, weight)

别名: medianTimingWeighted。

参数

• level — 分位数层次。可选参数。从0到1的一个float类型的常量。我们推荐 level 值的范围为 [0.01, 0.99] 。默认值：0.5。当 level=0.5 时，该函数计算 中位数。

• expr — 求值表达式 返回 Float* 类型数值。

  • 如果输入负值，那结果是不可预期的。
  • 如果输入值大于30000（页面加载时间大于30s），那我们假设为30000。

• weight — 权重序列。 权重是一个数据出现的数值。

精度

计算是准确的，如果:

• 值的总数不超过5670。
• 总数值超过5670，但页面加载时间小于1024ms。

否则，计算结果将四舍五入到16毫秒的最接近倍数。

!!! note "注"
对于计算页面加载时间分位数， 此函数比quantile更有效和准确。

返回值

• 指定层次的分位数。

类型: Float32。

!!! note "注"
如果没有值传递给函数（当使用 quantileTimingIf), NaN被返回。 这样做的目的是将这些案例与导致零的案例区分开来。 参见 ORDER BY clause 对于 NaN 值排序注意事项。

示例

输入表:

┌─response_time─┬─weight─┐
│            68 │      1 │
│           104 │      2 │
│           112 │      3 │
│           126 │      2 │
│           138 │      1 │
│           162 │      1 │
└───────────────┴────────┘

查询:

SELECT quantileTimingWeighted(response_time, weight) FROM t

结果:

┌─quantileTimingWeighted(response_time, weight)─┐
│                                           112 │
└───────────────────────────────────────────────┘

类似于 quantileTimingWeighted , 但接受多个分位数层次参数，并返回一个由这些分位数值组成的数组。

示例

输入表:

┌─response_time─┬─weight─┐
│            68 │      1 │
│           104 │      2 │
│           112 │      3 │
│           126 │      2 │
│           138 │      1 │
│           162 │      1 │
└───────────────┴────────┘

查询:

SELECT quantilesTimingWeighted(0,5, 0.99)(response_time, weight) FROM t

结果:

┌─quantilesTimingWeighted(0.5, 0.99)(response_time, weight)─┐
│ [112,162]                                                 │
└───────────────────────────────────────────────────────────┘