7

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

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

现在，假设 B 和 C 列是一些已定义的常量字符串，例如， B 可以是'B1'or 'B2'， C 可以是'C1'or '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) 值的辅助表，然后使用该辅助表进行 RIGHT OUTER JOIN。但我正在寻找一种更清洁的方法......

谢谢你们。

4

3 回答 3

2

辅助表不必是真实的表，它可以是通用的表表达式——至少如果您可以从表本身获取所有可能的值（或所有您感兴趣的值）。使用@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;

但是你必须加入一些知道“缺失”值的东西。如果其他地方需要相同的逻辑，并且您有固定值，那么永久表可能会更干净——当然，无论哪种方式都可能需要维护。您还可以考虑使用流水线函数充当代理表，但可能取决于卷。

于 2012-05-10T14:48:05.780 回答
1

问题是，如果您的数据库中没有特定组合，引擎如何知道将该组合包含到结果中？为了在结果中包含所有组合，您需要提供所有组合 - 无论是在主表中还是在用于引用的其他表中。例如，您可以使用如下数据创建另一个表 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 实例来测试这个，所以这更像是一个有根据的猜测，而不是其他任何东西。）

底线是引擎需要知道最终结果中包含的内容 - 一种或另一种方式。

于 2012-05-10T12:58:26.667 回答
0

可能有更漂亮的方法可以做到这一点，但以下内容应该可以让您开始实现您想要的：

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

分享和享受。

于 2012-05-10T13:00:35.550 回答