Sql 递归CTE以组合值

请注意，这不是评论中引用的问题的副本，因为这需要CTE

如何创建一个递归的公共表表达式，它组合了分组数据（如

string\u agg（）

或

group\u concat（）

）

例如，我有一个简单的数据集，如下所示：

┌──────┬──────────┐
│ code │ category │
╞══════╪══════════╡
│ 1    │ A        │
├──────┼──────────┤
│ 1    │ B        │
├──────┼──────────┤
│ 2    │ A        │
├──────┼──────────┤
│ 3    │ B        │
├──────┼──────────┤
│ 4    │ B        │
├──────┼──────────┤
│ 4    │ C        │
├──────┼──────────┤
│ 4    │ D        │
├──────┼──────────┤
│ 5    │ B        │
└──────┴──────────┘

我想生成一个结果集，该结果集按组组合类别，如下所示：

┌──────┬──────────┐
│ code │ category │
╞══════╪══════════╡
│ 1    │ A,B      │
├──────┼──────────┤
│ 2    │ A        │
├──────┼──────────┤
│ 3    │ B        │
├──────┼──────────┤
│ 4    │ B,C,D    │
├──────┼──────────┤
│ 5    │ B        │
└──────┴──────────┘

我认为答案可能是通用的，但我对为PostgreSQL、SQLite和SQL Server找到解决方案特别感兴趣

只要有足够的推力，猪就能飞得很好。然而，这不一定是个好主意。
-

首先，获取所有不同的

code

值。 然后确定每个

代码的第一个（最小的）
类别
值。
然后，在递归中，为每个
code
获取下一个较大的
category
值。
结果由为每个
代码执行最新步骤的所有行组成：

WITH RECURSIVE OinkOink(code, category, combined, step) AS (
  SELECT code,
         (SELECT MIN(MyTable.category)
          FROM MyTable
          WHERE MyTable.code = DistinctCodes.code),
         (SELECT MIN(MyTable.category)
          FROM MyTable
          WHERE MyTable.code = DistinctCodes.code),
         1
  FROM (SELECT DISTINCT code
        FROM MyTable) AS DistinctCodes

  UNION ALL

  SELECT code,
         (SELECT MIN(MyTable.category)
          FROM MyTable
          WHERE MyTable.code     = OinkOink.code
            AND MyTable.category > OinkOink.category),
         combined || ',' ||
           (SELECT MIN(MyTable.category)
            FROM MyTable
            WHERE MyTable.code     = OinkOink.code
              AND MyTable.category > OinkOink.category),
         step + 1
  FROM OinkOink
  WHERE EXISTS (SELECT *
                FROM MyTable
                WHERE MyTable.code     = OinkOink.code
                  AND MyTable.category > OinkOink.category)
)
SELECT code, combined
FROM OinkOink
JOIN (SELECT code,
             MAX(step) AS step
      FROM OinkOink
      GROUP BY code) AS LargestSteps
USING (code, step)
ORDER BY code;

只要有足够的推力，猪就能飞得很好。然而，这不一定是个好主意。

-

首先，获取所有不同的
code
值。
然后确定每个
代码的第一个（最小的）
类别
值。
然后，在递归中，为每个
code
获取下一个较大的
category
值。
结果由为每个
代码执行最新步骤的所有行组成：

WITH RECURSIVE OinkOink(code, category, combined, step) AS (
  SELECT code,
         (SELECT MIN(MyTable.category)
          FROM MyTable
          WHERE MyTable.code = DistinctCodes.code),
         (SELECT MIN(MyTable.category)
          FROM MyTable
          WHERE MyTable.code = DistinctCodes.code),
         1
  FROM (SELECT DISTINCT code
        FROM MyTable) AS DistinctCodes

  UNION ALL

  SELECT code,
         (SELECT MIN(MyTable.category)
          FROM MyTable
          WHERE MyTable.code     = OinkOink.code
            AND MyTable.category > OinkOink.category),
         combined || ',' ||
           (SELECT MIN(MyTable.category)
            FROM MyTable
            WHERE MyTable.code     = OinkOink.code
              AND MyTable.category > OinkOink.category),
         step + 1
  FROM OinkOink
  WHERE EXISTS (SELECT *
                FROM MyTable
                WHERE MyTable.code     = OinkOink.code
                  AND MyTable.category > OinkOink.category)
)
SELECT code, combined
FROM OinkOink
JOIN (SELECT code,
             MAX(step) AS step
      FROM OinkOink
      GROUP BY code) AS LargestSteps
USING (code, step)
ORDER BY code;

答案肯定不是泛型或ANSI标准，您不需要递归CTE来回答这个问题。标记实际使用的数据库。根据示例和结果，它看起来像concat行值，还有@Anagha不，它不是复制品。我正在寻找使用CTE的解决方案。其他答案不是。答案肯定不是通用的或ANSI标准的，你不需要递归CTE来回答这个问题。标记实际使用的数据库。根据示例和结果，它看起来像concat行值，还有@Anagha不，它不是复制品。我正在寻找使用CTE的解决方案。其他答案则不然。