postgres - 可以使用窗口函数来解决此查询吗？

Posted 2023-03-31

【中文标题】postgres - 可以使用窗口函数来解决此查询吗？

【英文标题】：postgres - Can a window function be used to solve this query?

【发布时间】：2019-11-29 22:51:21

【问题描述】：

我有以下架构中的数据：

| user_id | date   | score  |
| ------- | ------ | ------ |
| 1       | 201901 | 1      |
| 1       | 201902 | 2      |
| 1       | 201903 | 3      |
| 2       | 201901 | 1      |
| 2       | 201902 | -1     |
| 2       | 201903 | 2      |

我需要得出以下结果：

| user_id | one_score  | two_score | three_score | max_score | min_score |
| ------- | ---------- | --------- | ----------- | --------- | --------- |
| 1       | 1          | 3         | 6           | 3         | 1         |
| 2       | 1          | 0         | 2           | 2         | -1        |

注意 one_score 是第一个结果的总和，two_score 是前两个结果的总和，而三个 score 是与 user_id 关联的前三个结果的总和。

到目前为止，我的查询的总体布局是：

SELECT
  MAX(score),
  MIN(score)
FROM scores
GROUP BY user_id

我不确定计算 one_score、two_score 和 three_score 的最佳方法是什么。一种可能的方法是为每种情况编写一个自定义聚合函数，将整个列作为输入：

SELECT
  MAX(score),
  MIN(score),
  one_score(score),
  two_score(score),
  three_score(score)
FROM scores
GROUP BY user_id

我想知道是否有比这涉及窗口函数更好的方法。似乎我应该在每列中更改的是 sum 函数正在应用的行数，而不是为每种情况编写单独的函数。如何为滚动总和 one_score、two_score、three_score 编写窗口函数？

注意 - 这是一个从“真实世界”案例建模的简化案例，有两个不同之处：

它不是求和函数，而是数学表达式 范围将变化很大（最后 10、最后 30、最后 50 等），而不是 1、2、3 的范围。

【问题讨论】：

如何保证每个用户恰好有 3 个与之关联的分数？如果更少或更多应该怎么办？

【参考方案1】：

您可以使用row_number() 窗口函数对每个用户的行数进行编号，然后将这些编号用于FILTER 子句到sum()。

SELECT x.user_id,
       sum(x.score) FILTER (WHERE x.rn <= 1) one_score,
       sum(x.score) FILTER (WHERE x.rn <= 2) two_score,
       sum(x.score) FILTER (WHERE x.rn <= 3) three_score,
       max(x.score) max_score,
       min(x.score) min_score
       FROM (SELECT s.user_id,
                    s.score,
                    row_number() OVER (PARTITION BY s.user_id
                                       ORDER BY s.date) rn
                    FROM scores s) X
       GROUP BY x.user_id;

db<>fiddle

【参考方案2】：

我喜欢 OP 关于自定义聚合的想法：

create or replace function limited_sum_state(int[], int, int)
returns int[] language plpgsql as $$
begin
    if $1[1] < $2 then
        $1[1] := $1[1] + 1;
        $1[2] := $1[2] + $3;
    end if;
    return $1;
end $$;

create or replace function limited_sum_final(int[])
returns int language sql as $$
    select $1[2]
$$;

create aggregate sum_of_first_elements(int, int) (
    sfunc = limited_sum_state,
    stype = int[],
    finalfunc = limited_sum_final,
    initcond = '0, 0');

现在我们可以用一种优雅的方式编写查询：

select
    user_id,
    sum_of_first_elements(1, score order by date) as one_score,
    sum_of_first_elements(2, score order by date) as two_score,
    sum_of_first_elements(3, score order by date) as three_score,
    max(score) as max_score,
    min(score) as min_score
from scores
group by user_id;

Db<>fiddle.

【讨论】：

这会只做一次求和吗？

不，聚合函数有三个独立的实例。如果运算（此处求和）代价高昂，一种更高效的方法是在累积函数中计算，将结果聚合到数组并返回数组元素。

我认为这更符合 OP 的要求

也许可以，但我看不到将其编码为单个聚合的方法。这涉及到一个三级查询，很难一概而论。上述自定义聚合的优点是易于使用和一定程度的通用性（您可以轻松更改所需的第一个元素的数量）。

【参考方案3】：

对于包括 Postgres 在内的大多数 DBMS，您可以针对您的情况使用 sum(..) over ( partition by ... order by ... )、max(..) over ( partition by ... ) 和 min(..) over ( partition by ... ) 窗口分析函数。但是通过这种方式，你会得到那些应该被透视的结果。然后，我们需要在旋转过程中为分数的序数增加一个值。因此，子查询中需要rank() 或row_number() 函数，以便在主查询中使用生成的值。因此，请考虑：

select user_id,
       max(case when rnk = 1 then score end) as score_one,
       max(case when rnk = 2 then score end) as score_two,
       max(case when rnk = 3 then score end) as score_three,
       max(max_score) as max_score,
       min(min_score) as min_score
  from
  (
   select user_id,
          rank() over ( partition by user_id order by date ) as rnk,
          sum(score) over ( partition by user_id order by date ) as score,
          max(score) over ( partition by user_id ) as max_score,
          min(score) over ( partition by user_id ) as min_score
     from scores
   ) q
  group by user_id

Demo