Question

我正在寻找一些“推理规则”（类似于设置操作规则或逻辑规则），我可以使用它来减少复杂或大小的SQL查询。有没有这样的东西？任何文件，任何工具？您自己找到的任何等价物？它在某种程度上类似于查询优化，但不是在性能方面。

说明不同：通过JOIN，SUBSELECT，UNIONs（复杂）查询是否可以（或不）通过使用某些转换规则将其减少为更简单的等效SQL语句，从而产生相同的结果？

所以，我正在寻找SQL语句的等效转换，比如大多数SUBSELECT都可以重写为JOIN。

Answer 1

说明不同：通过JOIN，SUBSELECT，UNIONs（复杂）查询是否可以（或不）通过使用某些转换规则将其减少为更简单的等效SQL语句，从而产生相同的结果？

这正是优化者为生活所做的事情（不是我说他们总能这么做）。

由于SQL是一种基于集合的语言，因此通常有多种方法可以将一个查询转换为其他查询。

喜欢这个查询：

SELECT  *
FROM    mytable
WHERE   col1 > @value1 OR col2 < @value2

可以转化为：

SELECT  *
FROM    mytable
WHERE   col1 > @value1
UNION
SELECT  *
FROM    mytable
WHERE   col2 < @value2

或者这个：

SELECT  mo.*
FROM    (
        SELECT  id
        FROM    mytable
        WHERE   col1 > @value1
        UNION
        SELECT  id
        FROM    mytable
        WHERE   col2 < @value2
        ) mi
JOIN    mytable mo
ON      mo.id = mi.id

，看起来更丑陋，但可以产生更好的执行计划。

最常见的事情之一是替换此查询：

SELECT  *
FROM    mytable
WHERE   col IN
        (
        SELECT  othercol
        FROM    othertable
        )

这一个：

SELECT  *
FROM    mytable mo
WHERE   EXISTS
        (
        SELECT  NULL
        FROM    othertable o
        WHERE   o.othercol = mo.col
        )

在某些RDBMS中（PostgreSQL），DISTINCT和GROUP BY使用不同的执行计划，因此有时最好将其替换为另一个：< / p>

SELECT  mo.grouper,
        (
        SELECT  SUM(col)
        FROM    mytable mi
        WHERE   mi.grouper = mo.grouper
        )
FROM    (
        SELECT  DISTINCT grouper
        FROM    mytable
        ) mo

VS

SELECT  mo.grouper, SUM(col)
FROM    mytable
GROUP BY
        mo.grouper

在PostgreSQL，DISTINCT排序和GROUP BY哈希。

MySQL缺少FULL OUTER JOIN，因此可以将其重写为以下内容：

SELECT  t1.col1, t2.col2
FROM    table1 t1
LEFT OUTER JOIN
        table2 t2
ON      t1.id = t2.id

VS

SELECT  t1.col1, t2.col2
FROM    table1 t1
LEFT JOIN
        table2 t2
ON      t1.id = t2.id
UNION ALL
SELECT  NULL, t2.col2
FROM    table1 t1
RIGHT JOIN
        table2 t2
ON      t1.id = t2.id
WHERE   t1.id IS NULL

，但请参阅我的博客中有关如何在MySQL中更有效地执行此操作的文章：

Emulating FULL OUTER JOIN in MySQL

Oracle中的此分层查询：

SELECT  DISTINCT(animal_id) AS animal_id
FROM    animal
START WITH
        animal_id = :id
CONNECT BY
        PRIOR animal_id IN (father, mother)
ORDER BY
        animal_id

可以转换为：

SELECT  DISTINCT(animal_id) AS animal_id
FROM    (
        SELECT  0 AS gender, animal_id, father AS parent
        FROM    animal
        UNION ALL
        SELECT  1, animal_id, mother
        FROM    animal
        )
START WITH
        animal_id = :id
CONNECT BY
        parent = PRIOR animal_id
ORDER BY
        animal_id

，后者更具性能。

请参阅我的博客中有关执行计划详情的文章：

Genealogy query on both parents

要查找与给定范围重叠的所有范围，可以使用以下查询：

SELECT  *
FROM    ranges
WHERE   end_date >= @start
        AND start_date <= @end

，但在SQL Server中，这种更复杂的查询会更快地产生相同的结果：

SELECT  *
FROM    ranges
WHERE   (start_date > @start AND start_date <= @end)
        OR (@start BETWEEN start_date AND end_date)

，不管你信不信，我的博客上也有一篇关于此的文章：

Overlapping ranges: SQL Server

SQL Server也缺乏执行累积聚合的有效方法，因此此查询：

SELECT  mi.id, SUM(mo.value) AS running_sum
FROM    mytable mi
JOIN    mytable mo
ON      mo.id <= mi.id
GROUP BY
        mi.id

可以更有效地重写，主帮助我，游标（你听到我正确：cursors，more efficiently和SQL Server一句话。）

在我的博客中查看有关如何操作的文章：

Flattening timespans: SQL Server

在财务应用程序中通常会遇到某种类型的查询，用于搜索货币的有效汇率，例如Oracle中的这种查询：

SELECT  TO_CHAR(SUM(xac_amount * rte_rate), 'FM999G999G999G999G999G999D999999')
FROM    t_transaction x
JOIN    t_rate r
ON      (rte_currency, rte_date) IN
        (
        SELECT  xac_currency, MAX(rte_date)
        FROM    t_rate
        WHERE   rte_currency = xac_currency
                AND rte_date <= xac_date
        )

可以大量重写此查询以使用允许HASH JOIN代替NESTED LOOPS的相等条件：

WITH v_rate AS
        (
        SELECT  cur_id AS eff_currency, dte_date AS eff_date, rte_rate AS eff_rate
        FROM    (
                SELECT  cur_id, dte_date,
                        (
                        SELECT  MAX(rte_date)
                        FROM    t_rate ri
                        WHERE   rte_currency = cur_id
                                AND rte_date <= dte_date
                        ) AS rte_effdate
                FROM    (
                        SELECT  (
                                SELECT  MAX(rte_date)
                                FROM    t_rate
                                ) - level + 1 AS dte_date
                        FROM    dual
                        CONNECT BY
                                level <=
                                (
                                SELECT  MAX(rte_date) - MIN(rte_date)
                                FROM    t_rate
                                )
                        ) v_date,
                        (
                        SELECT  1 AS cur_id
                        FROM    dual
                        UNION ALL
                        SELECT  2 AS cur_id
                        FROM    dual
                        ) v_currency
                ) v_eff
        LEFT JOIN
                t_rate
        ON      rte_currency = cur_id
                AND rte_date = rte_effdate
        )
SELECT  TO_CHAR(SUM(xac_amount * eff_rate), 'FM999G999G999G999G999G999D999999')
FROM    (
        SELECT  xac_currency, TRUNC(xac_date) AS xac_date, SUM(xac_amount) AS xac_amount, COUNT(*) AS cnt
        FROM    t_transaction x
        GROUP BY
                xac_currency, TRUNC(xac_date)
        )
JOIN    v_rate
ON      eff_currency = xac_currency
        AND eff_date = xac_date

尽管地狱笨重，但后者的查询速度要快6倍。

这里的主要想法是将<=替换为=，这需要构建内存日历表。与JOIN合作。

Converting currencies

Answer 2

这里有一些使用Oracle 8＆amp; 9（当然，有时相反可能会使查询更简单或更快）：

如果不使用括号来覆盖运算符优先级，则可以删除括号。一个简单的例子是当where子句中的所有布尔运算符都相同时：where ((a or b) or c)等同于where a or b or c。

子查询通常（如果不总是）与主查询合并以简化它。根据我的经验，这通常会大大提高性能：

select foo.a,
       bar.a
  from foomatic  foo,
       bartastic bar
 where foo.id = bar.id and
       bar.id = (
         select ban.id
           from bantabulous ban
          where ban.bandana = 42
       )
;

相当于

select foo.a,
       bar.a
  from foomatic    foo,
       bartastic   bar,
       bantabulous ban
 where foo.id = bar.id and
       bar.id = ban.id and
       ban.bandana = 42
;

使用 ANSI连接将很多“代码猴”逻辑与where子句中真正有趣的部分分开：前一个查询相当于

select foo.a,
       bar.a
  from foomatic    foo
  join bartastic   bar on bar.id = foo.id
  join bantabulous ban on ban.id = bar.id
 where ban.bandana = 42
;

如果要检查是否存在行，请不要使用 count（*），而是使用rownum = 1或将查询放入where exists只获取一行而不是全部的子句。

Answer 3

我认为显而易见的是找到任何可以用SQL'Set'操作替换的游标。
接下来在我的列表中，查找可以重写为不相关查询的任何相关子查询
在长存储过程中，将单独的SQL语句分解为它们自己的存储过程。这样他们就可以获得自己的缓存查询计划。
查找可缩短范围的交易。我经常在交易中找到可以安全地在外面的陈述。
子选择通常可以重写为直接连接（现代优化者善于发现简单的连接）

正如@Quassnoi所说，Optimiser经常做得很好。帮助它的一种方法是确保索引和统计信息是最新的，并且查询工作负载存在合适的索引。

Answer 4

我喜欢通过连接查询替换所有类型的子选择。

这一点很明显：

SELECT  *
FROM    mytable mo
WHERE   EXISTS
        (
          SELECT  *
          FROM    othertable o
          WHERE   o.othercol = mo.col
        )

通过

SELECT  mo.*
FROM    mytable mo inner join othertable o on o.othercol = mo.col

这个是低估的：

SELECT  *
FROM    mytable mo
WHERE   NOT EXISTS
        (
          SELECT  *
          FROM    othertable o
          WHERE   o.othercol = mo.col
        )

通过

SELECT  mo.*
FROM    mytable mo left outer join othertable o on o.othercol = mo.col
WHERE   o.othercol is null

它可以帮助DBMS在一个大请求中选择好的执行计划。

Answer 5

我希望团队中的每个人都遵循一套标准，使代码可读，可维护，易懂，可清洗等。::）

每个人都使用相同的别名
没有游标。没有循环
为什么在你可以出现时想到IN
INDENT
编码风格的一致性

此处还有更多内容What are some of your most useful database standards?

Answer 6

鉴于SQL的本质，您必须了解任何重构的性能影响。 Refactoring SQL Applications是一个很好的重构资源，重点强调性能（见第5章）。

Answer 7

虽然简化可能与优化不同，但简化在编写可读的SQL代码时非常重要，这对于能够检查SQL代码的概念正确性（而不是语法正确性，您的开发环境应该为您检查）至关重要。在我看来，在一个理想的世界中，我们会编写最简单，可读的SQL代码，然后优化器会重写SQL代码以任何形式（可能更详细）运行最快。

我发现将SQL语句视为基于集合逻辑是非常有用的，特别是如果我需要组合where子句或找出where子句的复杂否定。在这种情况下我使用laws of boolean algebra。

简化where子句最重要的可能是DeMorgan的定律（注意“·”是“AND”而“+”是“OR”）：

NOT（x·y）= NOT x + NOT y
NOT（x + y）= NOT x·NOT y

这在SQL中转换为：

NOT (expr1 AND expr2) -> NOT expr1 OR NOT expr2
NOT (expr1 OR expr2) -> NOT expr1 AND NOT expr2

这些法律在简化包含大量嵌套AND和OR部分的where子句时非常有用。

记住field1 IN (value1, value2, ...)语句等同于field1 = value1 OR field1 = value2 OR ...也很有用。这允许您否定IN ()两种方式中的一种：

NOT field1 IN (value1, value2)  -- for longer lists
NOT field1 = value1 AND NOT field1 = value2  -- for shorter lists

也可以这样考虑子查询。例如，这否定了where子句：

NOT (table1.field1 = value1 AND EXISTS (SELECT * FROM table2 WHERE table1.field1 = table2.field2))

可以改写为：

NOT table1.field1 = value1 OR NOT EXISTS (SELECT * FROM table2 WHERE table1.field1 = table2.field2))

这些法律没有告诉您如何使用连接将使用子查询的SQL查询转换为一个，但布尔逻辑可以帮助您了解连接类型以及您的查询应返回的内容。例如，对于表A和B，INNER JOIN与A AND B类似，LEFT OUTER JOIN与(A AND NOT B) OR (A AND B)类似，简化为{{1} } {} A OR (A AND B)为FULL OUTER JOIN，简化为A OR (A AND B) OR B。

Answer 8

我的方法是学习一般的关系理论和特别是关系代数。然后学会发现SQL中使用的构造来实现关系代数中的运算符（例如通用量化a.k.a.degision）和微积分（例如存在量化）。问题是SQL具有在关系模型中找不到的功能，例如nulls，无论如何都可能是最好的重构。推荐阅读：SQL and Relational Theory: How to Write Accurate SQL Code By C. J. Date。

在这种情况下，我不相信“大多数SUBSELECT可以重写为JOIN这一事实”代表了一种简化。

以此查询为例：

SELECT c 
  FROM T1 
 WHERE c NOT IN ( SELECT c FROM T2 );

使用JOIN重写

SELECT DISTINCT T1.c 
  FROM T1 NATURAL LEFT OUTER JOIN T2 
 WHERE T2.c IS NULL;

加入更详细！

或者，认识到构造在c的投影上实现反连接，例如伪algrbra

T1 { c } antijoin T2 { c }

使用关系运算符简化：

SELECT c FROM T1 EXCEPT SELECT c FROM T2;

简化SQL语句的一般规则

8 个答案: