Question

我正在尝试优化SQL查询以使我的报告看起来更好。我的查询从一个表读取数据，按几个列分组，并计算一些聚合字段（计数和总和）。

SELECT A, B, C, COUNT(*), SUM(D) FROM T
GROUP BY A, B, C
ORDER BY A, B, C

现在，我们假设B和C列是一些定义的常量字符串，例如， B可以是'B1'或'B2'，C可以是'C1'或'C2'。因此，示例结果集是：

A  | B  | C  | COUNT(*) | SUM(D)
--------------------------------
A1 | B1 | C1 |       34 |   1752
A1 | B1 | C2 |        4 |    183
A1 | B2 | C1 |      199 |   8926
A1 | B2 | C2 |       56 |   2511
A2 | B1 | C2 |        6 |     89
A2 | B2 | C2 |       12 |    231
A3 | B1 | C1 |       89 |    552
...

正如您所看到的，对于'A1'，我有四种可能的（B，C）组合，但'A2'并非如此。我的问题是：如何在给定的表中生成（B，C）组合不存在的摘要行？也就是说，我怎样才能打印这些行：

A  | B  | C  | COUNT(*) | SUM(D)
--------------------------------
A2 | B1 | C1 |        0 |      0
A2 | B2 | C1 |        0 |      0

我能看到的唯一解决方案是创建一些包含所有（B，C）值的辅助表，然后使用该aux表进行RIGHT OUTER JOIN。但我正在寻找一种更清洁的方式......

谢谢大家。

Answer 1

辅助表不必是真正的表，它可以是公用表表达式 - 至少如果你可以从表本身获得所有可能的值（或者你感兴趣的所有值）。使用@Bob Jarvis'查询生成所有可能的组合，您可以执行以下操作：

WITH CTE AS (
    SELECT * FROM (SELECT DISTINCT a FROM T)
    JOIN (SELECT DISTINCT b, c FROM T) ON (1 = 1)
)
SELECT CTE.A, CTE.B, CTE.C,
    SUM(CASE WHEN T.A IS NULL THEN 0 ELSE 1 END), NVL(SUM(T.D),0)
FROM CTE
LEFT JOIN T ON T.A = CTE.A AND T.B = CTE.B AND T.C = CTE.C
GROUP BY CTE.A, CTE.B, CTE.C
ORDER BY CTE.A, CTE.B, CTE.C;

如果您有固定的值可能不在表中，那么它会更复杂（或者更丑陋，并且随着更多可能的值而变得更糟）：

WITH CTE AS (
    SELECT * FROM (SELECT DISTINCT a FROM T)
    JOIN (SELECT 'B1' AS B FROM DUAL
        UNION ALL SELECT 'B2' FROM DUAL) ON (1 = 1)
    JOIN (SELECT 'C1' AS C FROM DUAL
        UNION ALL SELECT 'C2' FROM DUAL) ON (1 = 1)
)
SELECT CTE.A, CTE.B, CTE.C,
    SUM(CASE WHEN T.A IS NULL THEN 0 ELSE 1 END), NVL(SUM(T.D),0)
FROM CTE
LEFT JOIN T ON T.A = CTE.A AND T.B = CTE.B AND T.C = CTE.C
GROUP BY CTE.A, CTE.B, CTE.C
ORDER BY CTE.A, CTE.B, CTE.C;

但是你必须加入某些知道'缺失'值的东西。如果在其他地方需要相同的逻辑，并且您有固定的值，那么永久表可能更清晰 - 当然，可能需要维护。您还可以考虑使用流水线函数作为代理表，但可能依赖于卷。

Answer 2

问题是，如果您的数据库中没有特定的组合，引擎如何知道将该组合包含在结果中？为了在结果中包含所有组合，您需要提供所有组合 - 无论是在主表中还是在用于引用的其他表中。例如，您可以使用如下数据创建另一个表R：

A  | B  | C  
------------
A1 | B1 | C1
A1 | B1 | C2
A1 | B2 | C1
A1 | B2 | C2
A2 | B1 | C1
A2 | B1 | C2
A2 | B2 | C1
A2 | B2 | C2
A3 | B1 | C1
A3 | B1 | C2
A3 | B1 | C1
A3 | B2 | C2
...

然后您的查询将如下所示：

SELECT r.*, COUNT(t.d), coalesce(SUM(t.d), 0)
FROM r LEFT OUTER JOIN t on (r.a=t.a and r.b=t.b and r.c=t.c)
GROUP BY r.a, r.b, r.c
ORDER BY r.a, r.b, r.c

这将返回您想要的0 | 0用于主表中不存在的组合的集合。请注意，这只有在您确实知道要包含的每种可能组合时才有可能，但情况可能并非总是如此。

另一方面，如果您的A，B，C是数值，并且您只想在一个范围内包含所有数字，那么可能还有另一种处理方式，如下所示：

SELECT a.n, b.n, c.n, COUNT(t.d), coalesce(SUM(t.d), 0)
FROM (SELECT (rownum) "n" FROM DUAL WHERE LEVEL >= start_a CONNECT BY LEVEL <= end_a) a,
     (SELECT (rownum) "n" FROM DUAL WHERE LEVEL >= start_b CONNECT BY LEVEL <= end_b) b,
     (SELECT (rownum) "n" FROM DUAL WHERE LEVEL >= start_c CONNECT BY LEVEL <= end_c) c,
     t
WHERE a.n = t.a(+) AND b.n = t.b(+) AND c.n = t.c(+)
GROUP BY a.n, b.n, c.n
ORDER BY a.n, b.n, c.n

（我没有一个方便的Oracle实例来测试它，所以这更像是一种有点教育的猜测，而不是其他任何东西。）

底线是引擎需要知道要包含在最终结果中的内容 - 无论如何。

Answer 3

可能有更好的方法可以做到这一点，但以下内容可以帮助您开始实现目标：

SELECT * FROM 
  (SELECT DISTINCT a FROM T)
JOIN
  (SELECT DISTINCT b, c FROM T)
  ON (1 = 1)
ORDER BY a, b, c

这将为您提供B和C存在的所有组合，以及所有存在的A，类似于

A1  B1  C1
A1  B1  C2
A1  B2  C1
A1  B2  C2
A2  B1  C1
A2  B1  C2
A2  B2  C1
A2  B2  C2

分享并享受。

如何在SQL中生成“空”聚合结果

3 个答案: