SQL 语句执行顺序

From：http://www.jellythink.com/archives/924

Oracle-SQL语句执行原理和完整过程详解：https://wenku.baidu.com/view/398bc427964bcf84b8d57b00.html

详解一条 SQL 语句的执行过程：http://www.cnblogs.com/cdf-opensource-007/p/6502556.html

步步深入：MySQL架构总览->查询执行流程->SQL解析顺序：http://www.cnblogs.com/annsshadow/p/5037667.html

sql语句查询执行顺序：http://blog.csdn.net/bitcarmanlee/article/details/51004767


准备工作

先来一段伪代码，首先你能看懂么？

SELECT DISTINCT <select_list>
FROM <left_table>
<join_type> JOIN <right_table>
ON <join_condition>
WHERE <where_condition>
GROUP BY <group_by_list>
HAVING <having_condition>
ORDER BY <order_by_condition>
LIMIT <limit_number>

如果你知道每个关键字的意思和作用，并且你还用过的话，那再好不过了。但是，你知道这些语句，它们的执行顺序你清楚么？

下面一切测试操作都是在MySQL数据库上完成，关于MySQL数据库的一些简单操作，请阅读一下文章：

  • 《MySQL扫盲篇》
  • 《MySQL存储引擎介绍》
  • 《MySQL数据类型和属性》
  • 《MySQL处理数据库和表的常用命令》

继续做以下的前期准备工作：

  1. 新建一个测试数据库TestDB； 
      create database TestDB;
  2. 创建测试表table1和table2； 
     CREATE TABLE table1(customer_id VARCHAR(10) NOT NULL,city VARCHAR(10) NOT NULL,PRIMARY KEY(customer_id))ENGINE=INNODB DEFAULT CHARSET=UTF8;CREATE TABLE table2(order_id INT NOT NULL auto_increment,customer_id VARCHAR(10),PRIMARY KEY(order_id))ENGINE=INNODB DEFAULT CHARSET=UTF8;
  3. 插入测试数据； 
     INSERT INTO table1(customer_id,city) VALUES('163','hangzhou');INSERT INTO table1(customer_id,city) VALUES('9you','shanghai');INSERT INTO table1(customer_id,city) VALUES('tx','hangzhou');INSERT INTO table1(customer_id,city) VALUES('baidu','hangzhou');INSERT INTO table2(customer_id) VALUES('163');INSERT INTO table2(customer_id) VALUES('163');INSERT INTO table2(customer_id) VALUES('9you');INSERT INTO table2(customer_id) VALUES('9you');INSERT INTO table2(customer_id) VALUES('9you');INSERT INTO table2(customer_id) VALUES('tx');INSERT INTO table2(customer_id) VALUES(NULL);

    准备工作做完以后，table1和table2看起来应该像下面这样：

     mysql> select * from table1;+-------------+----------+| customer_id | city     |+-------------+----------+| 163         | hangzhou || 9you        | shanghai || baidu       | hangzhou || tx          | hangzhou |+-------------+----------+4 rows in set (0.00 sec)mysql> select * from table2;+----------+-------------+| order_id | customer_id |+----------+-------------+|        1 | 163         ||        2 | 163         ||        3 | 9you        ||        4 | 9you        ||        5 | 9you        ||        6 | tx          ||        7 | NULL        |+----------+-------------+7 rows in set (0.00 sec)
  4. 准备SQL逻辑查询测试语句 
     SELECT a.customer_id, COUNT(b.order_id) as total_ordersFROM table1 AS aLEFT JOIN table2 AS bON a.customer_id = b.customer_idWHERE a.city = 'hangzhou'GROUP BY a.customer_idHAVING count(b.order_id) < 2ORDER BY total_orders DESC;

    使用上述SQL查询语句来获得来自杭州，并且订单数少于2的客户。

好吧，这些测试表和测试数据均来自《MySQL技术内幕：SQL编程》，这应该不算抄袭吧，借鉴借鉴啊。

万事俱备，只欠东风。接下来开始这篇文章最正式的部分吧。

SQL逻辑查询语句执行顺序

还记得上面给出的那一长串的SQL逻辑查询规则么？那么，到底哪个先执行，哪个后执行呢？现在，我先给出一个查询语句的执行顺序：

(7)     SELECT                             /* 处理SELECT列表，产生 VT7 */
(8)     DISTINCT <select_list>             /* 将重复的行从 VT7 中删除，产品 VT8 */
(1)     FROM <left_table>                  /* 对FROM子句中的表执行笛卡尔积(交叉联接)，生成虚拟表 VT1。 */
(3)     <join_type> JOIN <right_table>     /* 如果指定了OUTER JOIN(相对于CROSS JOIN或INNER JOIN)，保留表中未找到匹配的行将作为外部行添加到 VT2，生成 VT3。如果FROM子句包含两个以上的表，则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，直到处理完所有的表位置。   */
(2)     ON <join_condition>                /* 对 VT1 应用 ON 筛选器，只有那些使为真才被插入到 VT2。 */
(4)     WHERE <where_condition>            /* 对 VT3 应用 WHERE 筛选器，只有使为true的行才插入VT4。 */
(5)     GROUP BY <group_by_list>           /* 按 GROUP BY子句中的列列表对 VT4 中的行进行分组，生成 VT5 */
(6)     HAVING <having_condition>          /* 对 VT5 应用 HAVING 筛选器，只有使为true的组插入到 VT6 */
(9)     ORDER BY <order_by_condition>      /* 将 VT8 中的行按 ORDER BY子句中的列列表顺序，生成一个游标(VC10)，生成表TV11，并返回给调用者。 */
(10)    LIMIT <limit_number>

上面在每条语句的前面都标明了执行顺序号，不要问我怎么知道这个顺序的。我也是读各种“武林秘籍”才得知的，如果你有功夫，去阅读一下MySQL的源码，也会得出这个结果的。

Oracle SQL语句执行顺序

(8)SELECT (9)DISTINCT  (11)<Top Num> <select list>
(1)FROM [left_table]
(3)<join_type> JOIN <right_table>
(2)ON <join_condition>
(4)WHERE <where_condition>
(5)GROUP BY <group_by_list>
(6)WITH <CUBE | RollUP>
(7)HAVING <having_condition>
(10)ORDER BY <order_by_list>

        以上每个步骤都会产生一个虚拟表，该虚拟表被用作下一个步骤的输入。这些虚拟表对调用者(客户端应用程序或者外部查询)不可用。只有最后一步生成的表才会会给调用者。如果没有在查询中指定某一个子句，将跳过相应的步骤。


逻辑查询处理阶段简介

  1. FROM：对FROM子句中的前两个表执行笛卡尔积（Cartesian product)(交叉联接），生成虚拟表VT1
  2. ON：对VT1应用ON筛选器。只有那些使<join_condition>为真的行才被插入VT2。
  3. OUTER(JOIN)：如 果指定了OUTER JOIN（相对于CROSS JOIN 或(INNER JOIN),保留表（preserved table：左外部联接把左表标记为保留表，右外部联接把右表标记为保留表，完全外部联接把两个表都标记为保留表）中未找到匹配的行将作为外部行添加到 VT2,生成VT3.如果FROM子句包含两个以上的表，则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，直到处理完所有的表为止。
  4. WHERE：对VT3应用WHERE筛选器。只有使<where_condition>为true的行才被插入VT4.
  5. GROUP BY：按GROUP BY子句中的列列表对VT4中的行分组，生成VT5.
  6. CUBE|ROLLUP：把超组(Suppergroups)插入VT5,生成VT6.
  7. HAVING：对VT6应用HAVING筛选器。只有使<having_condition>为true的组才会被插入VT7.
  8. SELECT：处理SELECT列表，产生VT8.
  9. DISTINCT：将重复的行从VT8中移除，产生VT9.
  10. ORDER BY：将VT9中的行按ORDER BY 子句中的列列表排序，生成游标（VC10).
  11. TOP：从VC10的开始处选择指定数量或比例的行，生成表VT11,并返回调用者。

注：步骤10，按ORDER BY子句中的列列表排序上步返回的行，返回游标VC10.这一步是第一步也是唯一 一步可以使用SELECT列表中的列别名的步骤。这一步不同于其它步骤的 是，它不返回有效的表，而是返回一个游标。SQL是基于集合理论的。集合不会预先对它的行排序，它只是成员的逻辑集合，成员的顺序无关紧要。对表进行排序 的查询可以返回一个对象，包含按特定物理顺序组织的行。ANSI把这种对象称为游标。理解这一步是正确理解SQL的基础。

因为这一步不返回表（而是返回游标），使用了ORDER BY子句的查询不能用作表表达式。表表达式包括：视图、内联表值函数、子查询、派生表和共用表达式。它的结果必须返回给期望得到物理记录的客户端应用程序。例如，下面的派生表查询无效，并产生一个错误：

select * 
from(select orderid,customerid from orders order by orderid) 
as d

下面的视图也会产生错误

create view my_view
as
select *
from orders
order by orderid

      在SQL中，表表达式中不允许使用带有ORDER BY子句的查询，而在T—SQL中却有一个例外（应用TOP选项）。

      所以要记住，不要为表中的行假设任何特定的顺序。换句话说，除非你确定要有序行，否则不要指定ORDER BY 子句。排序是需要成本的，SQL Server需要执行有序索引扫描或使用排序运行符。


以上就是一条sql的执行过程，同时我们在书写查询sql的时候应当遵守以下顺序。

SELECT XXX FROM XXX WHERE XXX GROUP BY XXX HAVING XXX ORDER BY XXX LIMIT XXX;

上面标出了各条查询规则的执行先后顺序，那么各条查询语句是如何执行的呢？


执行FROM语句

在这些SQL语句的执行过程中，都会产生一个虚拟表，用来保存SQL语句的执行结果（这是重点），我现在就来跟踪这个虚拟表的变化，得到最终的查询结果的过程，来分析整个SQL逻辑查询的执行顺序和过程。

第一步，执行FROM语句。我们首先需要知道最开始从哪个表开始的，这就是FROM告诉我们的。现在有了<left_table>和<right_table>两个表，我们到底从哪个表开始，还是从两个表进行某种联系以后再开始呢？它们之间如何产生联系呢？——笛卡尔积

关于什么是笛卡尔积，请自行Google补脑。经过FROM语句对两个表执行笛卡尔积，会得到一个虚拟表，暂且叫VT1（vitual table 1），内容如下：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163         | hangzhou |        1 | 163         |
| 9you        | shanghai |        1 | 163         |
| baidu       | hangzhou |        1 | 163         |
| tx          | hangzhou |        1 | 163         |
| 163         | hangzhou |        2 | 163         |
| 9you        | shanghai |        2 | 163         |
| baidu       | hangzhou |        2 | 163         |
| tx          | hangzhou |        2 | 163         |
| 163         | hangzhou |        3 | 9you        |
| 9you        | shanghai |        3 | 9you        |
| baidu       | hangzhou |        3 | 9you        |
| tx          | hangzhou |        3 | 9you        |
| 163         | hangzhou |        4 | 9you        |
| 9you        | shanghai |        4 | 9you        |
| baidu       | hangzhou |        4 | 9you        |
| tx          | hangzhou |        4 | 9you        |
| 163         | hangzhou |        5 | 9you        |
| 9you        | shanghai |        5 | 9you        |
| baidu       | hangzhou |        5 | 9you        |
| tx          | hangzhou |        5 | 9you        |
| 163         | hangzhou |        6 | tx          |
| 9you        | shanghai |        6 | tx          |
| baidu       | hangzhou |        6 | tx          |
| tx          | hangzhou |        6 | tx          |
| 163         | hangzhou |        7 | NULL        |
| 9you        | shanghai |        7 | NULL        |
| baidu       | hangzhou |        7 | NULL        |
| tx          | hangzhou |        7 | NULL        |
+-------------+----------+----------+-------------+

总共有28（table1的记录条数 * table2的记录条数）条记录。这就是VT1的结果，接下来的操作就在VT1的基础上进行。

执行ON过滤

执行完笛卡尔积以后，接着就进行ON a.customer_id = b.customer_id条件过滤，根据ON中指定的条件，去掉那些不符合条件的数据，得到VT2表，内容如下：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163         | hangzhou |        1 | 163         |
| 163         | hangzhou |        2 | 163         |
| 9you        | shanghai |        3 | 9you        |
| 9you        | shanghai |        4 | 9you        |
| 9you        | shanghai |        5 | 9you        |
| tx          | hangzhou |        6 | tx          |
+-------------+----------+----------+-------------+

VT2就是经过ON条件筛选以后得到的有用数据，而接下来的操作将在VT2的基础上继续进行。

添加外部行

这一步只有在连接类型为OUTER JOIN时才发生，如LEFT OUTER JOIN、RIGHT OUTER JOIN和FULL OUTER JOIN。在大多数的时候，我们都是会省略掉OUTER关键字的，但OUTER表示的就是外部行的概念。

下面从网上找到一张很形象的关于‘SQL JOINS'的解释图


LEFT OUTER JOIN把左表记为保留表，得到的结果为：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163         | hangzhou |        1 | 163         |
| 163         | hangzhou |        2 | 163         |
| 9you        | shanghai |        3 | 9you        |
| 9you        | shanghai |        4 | 9you        |
| 9you        | shanghai |        5 | 9you        |
| tx          | hangzhou |        6 | tx          |
| baidu       | hangzhou |     NULL | NULL        |
+-------------+----------+----------+-------------+

RIGHT OUTER JOIN把右表记为保留表，得到的结果为：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163         | hangzhou |        1 | 163         |
| 163         | hangzhou |        2 | 163         |
| 9you        | shanghai |        3 | 9you        |
| 9you        | shanghai |        4 | 9you        |
| 9you        | shanghai |        5 | 9you        |
| tx          | hangzhou |        6 | tx          |
| NULL        | NULL     |        7 | NULL        |
+-------------+----------+----------+-------------+

FULL OUTER JOIN把左右表都作为保留表，得到的结果为：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163         | hangzhou |        1 | 163         |
| 163         | hangzhou |        2 | 163         |
| 9you        | shanghai |        3 | 9you        |
| 9you        | shanghai |        4 | 9you        |
| 9you        | shanghai |        5 | 9you        |
| tx          | hangzhou |        6 | tx          |
| baidu       | hangzhou |     NULL | NULL        |
| NULL        | NULL     |        7 | NULL        |
+-------------+----------+----------+-------------+

添加外部行的工作就是在VT2表的基础上添加保留表中被过滤条件过滤掉的数据，非保留表中的数据被赋予NULL值，最后生成虚拟表VT3。

由于我在准备的测试SQL查询逻辑语句中使用的是LEFT JOIN，过滤掉了以下这条数据：

| baidu       | hangzhou |     NULL | NULL        |

现在就把这条数据添加到VT2表中，得到的VT3表如下：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163         | hangzhou |        1 | 163         |
| 163         | hangzhou |        2 | 163         |
| 9you        | shanghai |        3 | 9you        |
| 9you        | shanghai |        4 | 9you        |
| 9you        | shanghai |        5 | 9you        |
| tx          | hangzhou |        6 | tx          |
| baidu       | hangzhou |     NULL | NULL        |
+-------------+----------+----------+-------------+

接下来的操作都会在该VT3表上进行。

执行WHERE过滤

对添加外部行得到的VT3进行WHERE过滤，只有符合<where_condition>的记录才会输出到虚拟表VT4中。当我们执行WHERE a.city = 'hangzhou'的时候，就会得到以下内容，并存在虚拟表VT4中：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163         | hangzhou |        1 | 163         |
| 163         | hangzhou |        2 | 163         |
| tx          | hangzhou |        6 | tx          |
| baidu       | hangzhou |     NULL | NULL        |
+-------------+----------+----------+-------------+

但是在使用WHERE子句时，需要注意以下两点：

  1. 由于数据还没有分组，因此现在还不能在WHERE过滤器中使用where_condition=MIN(col)这类对分组统计的过滤；
  2. 由于还没有进行列的选取操作，因此在SELECT中使用列的别名也是不被允许的，如：SELECT city as c FROM t WHERE c='shanghai';是不允许出现的。

执行GROUP BY分组

GROU BY子句主要是对使用WHERE子句得到的虚拟表进行分组操作。我们执行测试语句中的GROUP BY a.customer_id，就会得到以下内容：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163         | hangzhou |        1 | 163         |
| baidu       | hangzhou |     NULL | NULL        |
| tx          | hangzhou |        6 | tx          |
+-------------+----------+----------+-------------+

得到的内容会存入虚拟表VT5中，此时，我们就得到了一个VT5虚拟表，接下来的操作都会在该表上完成。

执行HAVING过滤

HAVING子句主要和GROUP BY子句配合使用，对分组得到的VT5虚拟表进行条件过滤。当我执行测试语句中的HAVING count(b.order_id) < 2时，将得到以下内容：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| baidu       | hangzhou |     NULL | NULL        |
| tx          | hangzhou |        6 | tx          |
+-------------+----------+----------+-------------+

这就是虚拟表VT6。

SELECT列表

现在才会执行到SELECT子句，不要以为SELECT子句被写在第一行，就是第一个被执行的。

我们执行测试语句中的SELECT a.customer_id, COUNT(b.order_id) as total_orders，从虚拟表VT6中选择出我们需要的内容。我们将得到以下内容：

+-------------+--------------+
| customer_id | total_orders |
+-------------+--------------+
| baidu       |            0 |
| tx          |            1 |
+-------------+--------------+

不，还没有完，这只是虚拟表VT7。

执行DISTINCT子句

如果在查询中指定了DISTINCT子句，则会创建一张内存临时表（如果内存放不下，就需要存放在硬盘了）。这张临时表的表结构和上一步产生的虚拟表VT7是一样的，不同的是对进行DISTINCT操作的列增加了一个唯一索引，以此来除重复数据。

由于我的测试SQL语句中并没有使用DISTINCT，所以，在该查询中，这一步不会生成一个虚拟表。

执行ORDER BY子句

对虚拟表中的内容按照指定的列进行排序，然后返回一个新的虚拟表，我们执行测试SQL语句中的ORDER BY total_orders DESC，就会得到以下内容：

+-------------+--------------+
| customer_id | total_orders |
+-------------+--------------+
| tx          |            1 |
| baidu       |            0 |
+-------------+--------------+

可以看到这是对total_orders列进行降序排列的。上述结果会存储在VT8中。

执行LIMIT子句

LIMIT子句从上一步得到的VT8虚拟表中选出从指定位置开始的指定行数据。对于没有应用ORDER BY的LIMIT子句，得到的结果同样是无序的，所以，很多时候，我们都会看到LIMIT子句会和ORDER BY子句一起使用。

MySQL数据库的LIMIT支持如下形式的选择：

LIMIT n, m

表示从第n条记录开始选择m条记录。而很多开发人员喜欢使用该语句来解决分页问题。对于小数据，使用LIMIT子句没有任何问题，当数据量非常大的时候，使用LIMIT n, m是非常低效的。因为LIMIT的机制是每次都是从头开始扫描，如果需要从第60万行开始，读取3条数据，就需要先扫描定位到60万行，然后再进行读取，而扫描的过程是一个非常低效的过程。所以，对于大数据处理时，是非常有必要在应用层建立一定的缓存机制（貌似现在的大数据处理，都有缓存哦）。各位，请期待我的缓存方面的文章哦。


至此SQL的解析之旅就结束了，上图总结一下：



习惯养成

了解了 SQL 执行顺序，那么我们就接下来进一步养成日常 sql好习惯，也就是在实现功能同时有考虑性能的思想，数据库是能进行集合运算的工具，我们应该尽量的利用这个工具，所谓集合运算实际就是批量运算，就是尽量减少在客户端进行大数据量的循环操作，而用SQL语句或者存储过程代替。


只返回需要的数据

返回数据到客户端至少需要数据库提取数据、网络传输数据、客户端接收数据以及客户端处理数据等环节。
如果返回不需要的数据，就会增加服务器、网络和客户端的无效劳动，其害处是显而易见的，避免这类事件需要注意：

1. 横向来看：

不要写SELECT * 的语句，而是选择你需要的字段。

当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上。这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误。

如有表table1（ID,col1）和table2 （ID,col2）

Select A.ID, A.col1, B.col2
-- Select A.ID, col1, col2     –不要这么写，不利于将来程序扩展
from table1 A inner join table2 B on A.ID=B.ID Where …

2. 纵向来看

合理写WHERE子句，不要写没有WHERE的SQL语句。SELECT TOP N * --没有WHERE条件的用此替代
尽量少做重复的工作。控制同一语句的多次执行，特别是一些基础数据的多次执行是很多程序员很少注意的。
减少多次的数据转换，也许需要数据转换是设计的问题，但是减少次数是程序员可以做到的。
杜绝不必要的子查询和连接表，子查询在执行计划一般解释成外连接，多余的连接表带来额外的开销。
合并对同一表同一条件的多次UPDATE，比如：

UPDATE EMPLOYEE SET FNAME='HAIWER'
WHERE EMP_ID=' VPA30890F' UPDATE EMPLOYEE SET LNAME='YANG'
WHERE EMP_ID=' VPA30890F'
-- 这两个语句应该合并成以下一个语句
UPDATE EMPLOYEE SET FNAME='HAIWER',LNAME='YANG'  WHERE EMP_ID=' VPA30890F'

UPDATE操作不要拆成DELETE操作+INSERT操作的形式，虽然功能相同，但是性能差别是很大的。


注意 临时表 和 表变量 的用法

在复杂系统中，临时表和表变量很难避免，关于临时表和表变量的用法，需要注意：
如果语句很复杂，连接太多，可以考虑用临时表和表变量分步完成。
如果需要多次用到一个大表的同一部分数据，考虑用临时表和表变量暂存这部分数据。
如果需要综合多个表的数据，形成一个结果，可以考虑用临时表和表变量分步汇总这多个表的数据。
其他情况下，应该控制临时表和表变量的使用。

关于临时表和表变量的选择，很多说法是表变量在内存，速度快，应该首选表变量，

但是在实际使用中发现，主要考虑需要放在临时表的数据量，在数据量较多的情况下，临时表的速度反而更快。执行时间段与预计执行时间(多长)。
关于临时表产生使用SELECT INTO 和 CREATE TABLE + INSERT INTO 的选择。
一般情况下，SELECT INTO会比CREATE TABLE + INSERT INTO的方法快很多，
但是SELECT INTO会锁定TEMPDB的系统表SYSOBJECTS、SYSINDEXES、SYSCOLUMNS，
在多用户并发环境下，容易阻塞其他进程，
所以我的建议是，在并发系统中，尽量使用CREATE TABLE + INSERT INTO，而大数据量的单个语句使用中，使用SELECT INTO。


子查询的用法

子查询是一个 SELECT 查询，它嵌套在 SELECT、INSERT、UPDATE、DELETE 语句或其它子查询中。
任何允许使用表达式的地方都可以使用子查询，子查询可以使我们的编程灵活多样，可以用来实现一些特殊的功能。
但是在性能上，往往一个不合适的子查询用法会形成一个性能瓶颈。
如果子查询的条件中使用了其外层的表的字段，这种子查询就叫作相关子查询。
相关子查询可以用IN、NOT IN、EXISTS、NOT EXISTS引入。

关于相关子查询，应该注意：

1. NOT IN、NOT EXISTS的相关子查询可以改用LEFT JOIN代替写法。

比如：SELECT PUB_NAME FROM PUBLISHERS WHERE PUB_ID NOT IN (SELECT PUB_ID FROM TITLES WHERE TYPE = 'BUSINESS')
可以改写成：SELECT A.PUB_NAME FROM PUBLISHERS A LEFT JOIN TITLES B ON B.TYPE = 'BUSINESS' AND A.PUB_ID=B. PUB_ID WHERE B.PUB_ID IS NULL
又比如：SELECT TITLE FROM TITLESWHERE NOT EXISTS(SELECT TITLE_ID FROM SALESWHERE TITLE_ID = TITLES.TITLE_ID)
可以改写成：SELECT TITLEFROM TITLES LEFT JOIN SALESON SALES.TITLE_ID = TITLES.TITLE_IDWHERE SALES.TITLE_ID IS NULL

2. 如果保证子查询没有重复 ，IN、EXISTS的相关子查询可以用INNER JOIN 代替。

比如：

    SELECT PUB_NAMEFROM PUBLISHERSWHERE PUB_ID IN(SELECT PUB_IDFROM TITLESWHERE TYPE = 'BUSINESS')
可以改写成：SELECT A.PUB_NAME --SELECT DISTINCT A.PUB_NAMEFROM PUBLISHERS A INNER JOIN TITLES BON        B.TYPE = 'BUSINESS' ANDA.PUB_ID=B. PUB_ID

3. IN的相关子查询用EXISTS代替

比如

    SELECT PUB_NAME FROM PUBLISHERSWHERE PUB_ID IN(SELECT PUB_ID FROM TITLES WHERE TYPE = 'BUSINESS')
可以用下面语句代替：SELECT PUB_NAME FROM PUBLISHERS WHERE EXISTS(SELECT 1 FROM TITLES WHERE TYPE = 'BUSINESS' ANDPUB_ID= PUBLISHERS.PUB_ID)

4. 不要用COUNT(*)的子查询判断是否存在记录，最好用LEFT JOIN或者EXISTS

比如有人写这样的语句：SELECT JOB_DESC FROM JOBSWHERE (SELECT COUNT(*) FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)=0
应该写成：SELECT JOBS.JOB_DESC FROM JOBS LEFT JOIN EMPLOYEE ON EMPLOYEE.JOB_ID=JOBS.JOB_IDWHERE EMPLOYEE.EMP_ID IS NULL
还有SELECT JOB_DESC FROM JOBSWHERE (SELECT COUNT(*) FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)<>0
应该写成：SELECT JOB_DESC FROM JOBSWHERE EXISTS (SELECT 1 FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)


尽量使用索引

建立索引后，并不是每个查询都会使用索引，在使用索引的情况下，索引的使用效率也会有很大的差别。只要我们在查询语句中没有强制指定索引，索引的选择和使用方法是SQLSERVER的优化器自动作的选择，而它选择的根据是查询语句的条件以及相关表的统计信息，这就要求我们在写SQL语句的时候尽量使得优化器可以使用索引。为了使得优化器能高效使用索引，写语句的时候应该注意：

不要对索引字段进行运算，而要想办法做变换

    SELECT ID FROM T WHERE NUM/2=100应改为:SELECT ID FROM T WHERE NUM=100*2SELECT ID FROM T WHERE NUM/2=NUM1如果NUM有索引应改为:SELECT ID FROM T WHERE NUM=NUM1*2如果NUM1有索引则不应该改。发现过这样的语句：SELECT 年,月,金额 FROM 结余表  WHERE 100*年+月=2010*100+10应该改为：SELECT 年,月,金额 FROM 结余表 WHERE 年=2010 AND月=10

不要对索引字段进行格式转换

    日期字段的例子：WHERE CONVERT(VARCHAR(10), 日期字段,120)='2010-07-15'应该改为WHERE日期字段〉='2010-07-15'   AND   日期字段<'2010-07-16'ISNULL转换的例子：WHERE ISNULL(字段,'')<>''应改为:WHERE字段<>''WHERE ISNULL(字段,'')=''不应修改WHERE ISNULL(字段,'F') ='T'应改为: WHERE字段='T'WHERE ISNULL(字段,'F')<>'T'不应修改

不要对索引字段使用函数

    WHERE LEFT(NAME, 3)='ABC' 或者WHERE SUBSTRING(NAME,1, 3)='ABC'应改为: WHERE NAME LIKE 'ABC%'日期查询的例子：WHERE DATEDIFF(DAY, 日期,'2010-06-30')=0应改为:WHERE 日期>='2010-06-30' AND 日期 <'2010-07-01'WHERE DATEDIFF(DAY, 日期,'2010-06-30')>0应改为:WHERE 日期 <'2010-06-30'WHERE DATEDIFF(DAY, 日期,'2010-06-30')>=0应改为:WHERE 日期 <'2010-07-01'WHERE DATEDIFF(DAY, 日期,'2010-06-30')<0应改为:WHERE 日期>='2010-07-01'WHERE DATEDIFF(DAY, 日期,'2010-06-30')<=0应改为:WHERE 日期>='2010-06-30'

不要对索引字段进行多字段连接

    比如：WHERE FAME+ '. '+LNAME='HAIWEI.YANG'应改为:WHERE FNAME='HAIWEI' AND LNAME='YANG'


多表连接的连接条件

多表连接的连接条件对索引的选择有着重要的意义，所以我们在写连接条件的时候需要特别注意。
多表连接的时候，连接条件必须写全，宁可重复，不要缺漏。
连接条件尽量使用聚集索引

注意ON、WHERE和HAVING部分条件的区别

ON是最先执行， WHERE次之，HAVING最后。因为ON是先把不符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，
WHERE也应该比 HAVING快点的，因为它过滤数据后才进行SUM，在两个表联接时才用ON的，所以在一个表的时候，就剩下WHERE跟HAVING比较了


考虑联接优先顺序

INNER JOIN
LEFT JOIN (注：RIGHT JOIN 用 LEFT JOIN 替代)
CROSS JOIN

其它注意和了解的地方有
在IN后面值的列表中，将出现最频繁的值放在最前面，出现得最少的放在最后面，减少判断的次数

注意UNION和UNION ALL的区别。--允许重复数据用UNION ALL好
注意使用DISTINCT，在没有必要时不要用


TRUNCATE TABLE 与 DELETE 区别

减少访问数据库的次数
还有就是我们写存储过程，如果比较长的话，最后用标记符标开，因为这样可读性很好，即使语句写的不怎么样但是语句工整，C# 有region，sql我比较喜欢用的就是：
--startof 查询在职人数
sql语句
--end of
正式机器上我们一般不能随便调试程序，但是很多时候程序在我们本机上没问题，
但是进正式系统就有问题，但是我们又不能随便在正式机器上操作，那么怎么办呢？
我们可以用回滚来调试我们的存储过程或者是sql语句，从而排错。
BEGIN TRAN
UPDATE a SET 字段=''
ROLLBACK
作业存储过程我一般会加上下面这段，这样检查错误可以放在存储过程，如果执行错误回滚操作。
但是如果程序里面已经有了事务回滚，那么存储过程就不要写事务了，这样会导致事务回滚嵌套降低执行效率，
但是我们很多时候可以把检查放在存储过程里，这样有利于我们解读这个存储过程，和排错。

BEGIN TRANSACTION
--事务回滚开始
--检查报错
IF ( @@ERROR > 0 )
BEGIN
--回滚操作
ROLLBACK TRANSACTION
RAISERROR('删除工作报告错误', 16, 3)
RETURN
END
--结束事务

COMMIT TRANSACTION 



本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/496451.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

无人车巨头每天都在做相同的事情：不惜血本做高精地图是为何？

无人车巨头每天都在做相同的事情：不惜血本做高精地图是为何？

来源&#xff1a;腾讯科技摘要&#xff1a;很多人都关注无人车的发展&#xff0c;殊不知无人车技术中&#xff0c;有十分重要的一环&#xff0c;是无人车的高精地图。高精地图成为无人车竞赛中的关键一环目前&#xff0c;很多家无人驾驶公司都在做着同样的事情&#xff1a;绘制…
阅读更多...
phaser java_死磕 java同步系列之Phaser源码解析

phaser java_死磕 java同步系列之Phaser源码解析

问题(1)Phaser是什么&#xff1f;(2)Phaser具有哪些特性&#xff1f;(3)Phaser相对于CyclicBarrier和CountDownLatch的优势&#xff1f;简介Phaser&#xff0c;翻译为阶段&#xff0c;它适用于这样一种场景&#xff0c;一个大任务可以分为多个阶段完成&#xff0c;且每个阶段的…
阅读更多...
人工智能将为传统制造业带来什么？

人工智能将为传统制造业带来什么？

来源 &#xff1a;数据科学与人工智能“物理世界”&#xff08;以制造业设备所代表&#xff09;和“数字世界”&#xff08;由人工智能、传感器等技术代表&#xff09;的碰撞催生了制造业的巨大的转变。两个世界的融合将为下一轮经济发展注入新的动能。以人工智能为代表的新技术…
阅读更多...
网络模拟器 eNSP、EVE-NG、GNS3、Packet Tracert

网络模拟器 eNSP、EVE-NG、GNS3、Packet Tracert

工欲善其事必先利其器&#xff0c;学习网络不可能都有真实的网络环境可以使用&#xff0c;这时就需要使用网络模拟软件&#xff0c;模拟一些网络环境&#xff0c;构建一些网络拓扑&#xff0c;然后学习研究网络技术 初学时不要在模拟器的选择上纠结&#xff0c;PT、GNS3 就足够…
阅读更多...
信息技术守护人类文明DNA

信息技术守护人类文明DNA

来源&#xff1a;中国青年报 作者&#xff1a;胡春艳21世纪最时髦的技术&#xff0c;改变的不仅是未来&#xff0c;在被称为“最古老的研究”的文物与博物馆界&#xff0c;感受到的变化可能更加显著。天津大学文化遗产保护与传承信息技术研究中心主任张加万团队历时10年&…
阅读更多...
java 单例方法_Java-单例模式 - 惊觉

java 单例方法_Java-单例模式 - 惊觉

单例模式单例(Singleton)模式是设计模式之一&#xff0c;最显著的特点就是一个类在一个JVM中只有一个实例&#xff0c;避免繁琐的创建销毁实例。简单例子先看简单的单例模式实现完整代码&#xff1a;Singleton_Test类使用单例模式 &#xff0c;采用饿汉式方法。public class Si…
阅读更多...
DIY协同办公平台（C/S）系列4之通讯录篇

DIY协同办公平台（C/S）系列4之通讯录篇

通讯录分为企业通讯录和员工个人通讯录。企业通讯录与企业员工资料相连接&#xff0c;读取其资料。而员工个人通讯录主要是员工的自己业务往来和个人的通讯资料保存。 1.主体toolbar 用于快捷掉出与员工相关的功能&#xff0c;打算支持自定义和本地化&#xff0c;通过对文本的…
阅读更多...
iRank: 基于互联网类脑架构的阿尔法鹰眼发展趋势评估

iRank: 基于互联网类脑架构的阿尔法鹰眼发展趋势评估

前言&#xff1a;iRank是人工智能学家基于科学院研究团队“互联网类脑智能巨系统架构”和”AI 智商评估模型”等研究成果&#xff0c;对智能产业优秀企业、产品和技术进行评估、发掘和推荐的项目。iRank目前拥有互联网、人工智能、机器人&#xff0c;大数据、通讯技术、芯片、脑…
阅读更多...
Java加密与解密的艺术~AES-GCM-NoPadding实现

Java加密与解密的艺术~AES-GCM-NoPadding实现

来源&#xff1a;Java AES加密和解密_一名可爱的技术搬运工-CSDN博客 高级加密标准 &#xff08;AES&#xff0c;Rijndael&#xff09;是一种分组密码加密和解密算法&#xff0c;是全球使用最广泛的加密算法。 AES使用128、192或256位的密钥来处理128位的块。 本文向您展示了一…
阅读更多...
STL bitset用法总结

STL bitset用法总结

c bitset类用法&#xff1a;http://blog.csdn.net/qll125596718/article/details/6901935 C 参考&#xff1a;http://www.cplusplus.com/reference/bitset/bitset/ http://happyboy200032.blog.163.com/blog/static/46903113201291252033712/ http://blog.csdn.net/e68948…
阅读更多...
全球智能制造发展现状及前景预测 工业机器人引领行业发展

全球智能制造发展现状及前景预测 工业机器人引领行业发展

来源&#xff1a;前瞻产业研究院全球智能制造发展历程智能制造是伴随信息技术的不断普及而逐步发展起来的。1988年&#xff0c;美国纽约大学的怀特教授&#xff08;P&#xff0e;K&#xff0e;Wright&#xff09;和卡内基梅隆大学的布恩教授&#xff08;D&#xff0e;A&#xf…
阅读更多...
vb整合多个excel表格到一张_VB合并工作表下载

vb整合多个excel表格到一张_VB合并工作表下载

VB合并工作表最新版是一款功能强大且界面简洁美观的excel表格合并工具&#xff0c;VB合并工作表最新版操作简便且易上手可以运行稳定&#xff0c;能够为大家解决合成打开卡顿等问题&#xff0c;实现多薄多表合并&#xff0c;VB合并工作表官方版还可以有效轻松提升工作效率。软件…
阅读更多...
sql server 模糊查询

sql server 模糊查询

模糊查询——like select * from 表名where id like %2%select * from 表名where id like d%% escape d 查询时&#xff0c;字段中的内容并不一定与查询内容完全匹配&#xff0c;只要字段中含有这些内容 模糊查询&#xff0d;&#xff0d;is null select * from 表名 where na…
阅读更多...
java.security.InvalidKeyException: Illegal key size

java.security.InvalidKeyException: Illegal key size

来源&#xff1a;https://blog.csdn.net/dling8/article/details/84061948 今天在使用idea打包maven项目时&#xff0c;出现这个错误&#xff1a;java.security.InvalidKeyException: Illegal key size。&#xff08;测试也可能会出现这个问题&#xff09;貌似是因为加密出现了…
阅读更多...
NAT 详解

NAT 详解

NAT技术(一、二、三、四、五) 系列&#xff1a;https://blog.51cto.com/wwwcisco/category1.html CCNA学习笔记之NAT&#xff1a;http://sweetpotato.blog.51cto.com/533893/1392884 网络地址转换NAT原理及应用&#xff1a;http://blog.csdn.net/xiaofei0859/article/details/…
阅读更多...
趋势|人工智能疯狂洗脑，最聪明的钱已转向这16项技术

趋势|人工智能疯狂洗脑，最聪明的钱已转向这16项技术

来源&#xff1a;21世纪商业评论 摘要&#xff1a;Gartner今年发布的技术成熟曲线中&#xff0c;出现了16个处于上升阶段的新兴技术&#xff0c;这些正在崛起的技术&#xff0c;或将成为企业未来几年战略性技术趋势的热点。不久前&#xff0c;信息技术研究公司Gartner发布了201…
阅读更多...
OSI七层协议模型和TCP/IP四层模型

OSI七层协议模型和TCP/IP四层模型

TCP/IP 协议栈及 OSI 参考模型详解&#xff1a;https://blog.csdn.net/guobing19871024/article/details/79415846 OSI七层网络模型&#xff0c;TCP/IP四层网络模型与网络协议解析&#xff1a;http://www.360doc.com/content/13/1123/17/7267612_331579105.shtml [网络必学]TCP…
阅读更多...
基于java处理ofd格式文件

基于java处理ofd格式文件

一、ofd格式介绍 国家发布过一份关于ofd编码格式的资料&#xff0c;本来我想传上去的发现资源重复了&#xff0c;你们可以找找看&#xff0c;没有的话留个邮箱&#xff0c;我看到会发给你们的 ofd本质上其实是一个压缩文件&#xff0c;咱们把他当做一个压缩包来处理就好了&…
阅读更多...
一文带你读懂深度学习：AI 认识世界的方式如同小孩

一文带你读懂深度学习：AI 认识世界的方式如同小孩

来源&#xff1a;36氪摘要&#xff1a;搞清楚儿童的大脑究竟是如何运转的&#xff0c;然后设计出一个电子版本能够同样有效地运转&#xff0c;可能需要计算机科学家们几十年的努力。如果你经常花时间和小孩子待在一起的话&#xff0c;你会不由得思考小孩子怎么能够学习得如此之…
阅读更多...
微信支付PKIX path building failed

微信支付PKIX path building failed

异常信息 javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification p ath to requested targetat sun.security.ssl…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023