SQL-分区的笛卡尔积

有一个非常复杂的问题，我无法独自思考。在查询的表中有5列：

PK_ID

，它是值的唯一标识符，

ID

，它连接一个组中的聚合值，

计数

，表示应该聚合多少个值组（如果没有足够的数据，则应从查询结果中删除具有此类

ID

的组），

num

，表示组内聚合值的数量，以及要聚合的

值

(Table T1)

PK_ID |   ID  |  num  |  count |  value
------+-------+-------+--------+--------
 1    |   1   |   1   |   3    |   A
------+-------+-------+--------+--------
 2    |   1   |   2   |   3    |   B
------+-------+-------+--------+--------
 3    |   1   |   3   |   3    |   C
------+-------+-------+--------+--------
 4    |   1   |   1   |   3    |   D
------+-------+-------+--------+--------
 5    |   1   |   3   |   3    |   E
------+-------+-------+--------+--------
 6    |   1   |   2   |   3    |   F
------+-------+-------+--------+--------
 7    |   1   |   3   |   3    |   G
------+-------+-------+--------+--------
 8    |   2   |   1   |   2    |   H
------+-------+-------+--------+--------
 9    |   2   |   2   |   2    |   I
------+-------+-------+--------+--------
 10   |   2   |   1   |   2    |   J
------+-------+-------+--------+--------
 11   |   3   |   1   |   5    |   X

这种查询的结果将是：

PK_ID | T1_ID | cross_aggr | T1_PK_IDs
------+-------+------------+-----------
  1   |   1   | {A, B, C}  | {1, 2, 3}
------+-------+------------+-----------
  2   |   1   | {A, B, E}  | {1, 2, 5}
------+-------+------------+-----------
  3   |   1   | {A, B, G}  | {1, 2, 7}
------+-------+------------+-----------
  4   |   1   | {A, F, C}  | {1, 6, 3}
------+-------+------------+-----------
  5   |   1   | {A, F, E}  | {1, 6, 5}
------+-------+------------+-----------
  6   |   1   | {A, F, G}  | {1, 6, 7}
------+-------+------------+-----------
  7   |   1   | {D, B, C}  | {4, 2, 3}
------+-------+------------+-----------
  8   |   1   | {D, B, E}  | {4, 2, 5}
------+-------+------------+-----------
  9   |   1   | {D, B, G}  | {4, 2, 7}
------+-------+------------+-----------
  10  |   1   | {D, F, C}  | {4, 6, 3}
------+-------+------------+-----------
  11  |   1   | {D, F, E}  | {4, 6, 5}
------+-------+------------+-----------
  12  |   1   | {D, F, G}  | {4, 6, 7}
------+-------+------------+-----------
  13  |   2   | {H, I}     | {8, 9}
------+-------+------------+-----------
  14  |   2   | {J, I}     | {10, 9}

因此，它返回每个组中
值
的每个可能组合，由
ID
定义，由
count
描述，这些值按每个
num
的顺序进行聚合

看起来我必须使用
交叉连接
（与线性代数中笛卡尔积的工作方式相同），但是
交叉连接
似乎只有在
连接
ed表的数量事先已知的情况下才起作用，但是存在
计数
的复杂性。
计数
本身可能会（我的意思是它没有，但它可以）范围从
2
到
无限

我曾想过用
窗口
函数、
按
ID
和
num
分区来处理它，但在那之后我就被卡住了，因为似乎没有办法得到这些分区的笛卡尔积

我是否应该到此为止，并找到另一种方法来处理数据，或者有没有一种方法可以组成这样一个查询？
这听起来像是一个图形漫游问题，需要一个递归查询

with recursive cte as (
    select id, num, cnt, 1 as lvl,
        array[value::text] as arr_values, 
        array[pk_id::int] as arr_pk_id
    from mytable where num = 1
    union all
    select c.id, t.num, c.cnt, c.lvl + 1, 
        c.arr_values || t.value::text, 
        c.arr_pk_id  || t.pk_id
    from cte c
    inner join mytable t 
        on  t.id = c.id 
        and t.num = c.num + 1 
        and t.num <= c.cnt
)
select id, arr_values, arr_pk_id 
from cte 
where array_length(arr_pk_id, 1) = cnt
order by arr_pk_id

这读起来像是一个图行走问题——需要递归查询

with recursive cte as (
    select id, num, cnt, 1 as lvl,
        array[value::text] as arr_values, 
        array[pk_id::int] as arr_pk_id
    from mytable where num = 1
    union all
    select c.id, t.num, c.cnt, c.lvl + 1, 
        c.arr_values || t.value::text, 
        c.arr_pk_id  || t.pk_id
    from cte c
    inner join mytable t 
        on  t.id = c.id 
        and t.num = c.num + 1 
        and t.num <= c.cnt
)
select id, arr_values, arr_pk_id 
from cte 
where array_length(arr_pk_id, 1) = cnt
order by arr_pk_id

兄弟，对不起，我是在胡闹。我不敢相信这真的是可能的，似乎SQL有太多我不知道的地方，这就是为什么它对很多人来说是如此有限的原因。但是当像你这样的人进入游戏时，这种语言的潜力被发挥到了极致。非常感谢你，你应该得到比我给你更多的声誉用我的+1.bro抱歉，我是在摆弄这件事。我不敢相信这真的是可能的，似乎SQL有太多我不知道的地方，这就是为什么它对很多人来说如此有限。但是当像你这样的人进入游戏时，这种语言的潜力被发挥到了极致。非常感谢你，你应该得到比我多得多的声誉n给你我的+1。