教材：王珊 萨师煊 编著 数据库系统概论（第5版） 高等教育出版社

注：文档高清截图在后
第9章 关系查询处理和查询优化
9.1 关系数据库系统的查询处理
1、RDBMS的查询处理分为四个阶段：

【1】查询分析。

对查询语句进行扫描、词法分析和语法分析，识别SQL关键字、属性名和关系名等语言符号，进行语法检查和分析，即判定查询语句是否合乎语法。若无语法错误，则转入下一步；否则，拒绝执行并报错。

【2】查询检查。

对合法语句进行语义检查，即根据数据字典中有关的模式定义检查语句中的数据库对象，如关系名、属性名是否存在且有效。如果是对视图的操作，则用视图消解方法把对视图的操作转换成对基本表的操作。还要根据数据字典中的用户权限和完整性约束定义对存取权限进行检查。如果用户无相应访问权限或违反完整性约束，就拒绝执行该查询。当然，这时的完整性检查是初步、静态的。检查通过后，SQL查询语句会被转换成等价的关系代数表达式，数据库对象的外部名称也被转换为内部表示。RDBMS一般都用查询树（query tree），也称语法树（syntax tree）来表示扩展的关系代数表达式。

【3】查询优化。

查询优化器通过综合运用各种优化技术，获得最好的查询速度提升效果。

【4】查询执行。

根据优化器得到的执行策略生成查询执行计划，由代码生成器（code generator）生成代码并执行，返回查询结果。
2、选择（select）操作的实现算法主要有：

【1】全表扫描（table scan）。

算法的步骤是：

（1）将一定数量的表的内容读入内存。

（2）检查内存的每个元组，输出满足条件的元组。

（3）如果未读取完毕，重复（1）（2）。

全表扫描算法只需要很少的内存（至少一个块。操作系统为了实现更先进的内存管理，一般都会将内存分成若干个块。物理内存被划分为一小块一小块，每块被称为帧（Frame）。分配内存时，帧是分配时的最小单位，最少也要给一帧。在逻辑内存中，与帧对应的概念就是页（Page）。）对规模小的表，这种算法既简单又有效。但表的元组数量较大且满足条件的元组数量占比较少时，顺序扫描的效率就很低。

【2】索引扫描（index scan）。

如果要求的条件中的属性上建立了索引（如B+树或Hash），可以用索引扫描方法，通过索引先找到满足条件的元组的指针，再通过指针访问基本表中的元组。

一般地，选择率较低时，基于索引的选择算法远远优于全表扫描算法。但在某些极端情形下，例如选择率很高，和/或要查找的元素十分均匀地分布，此时基于索引的选择算法的性能就不一定优于全表扫描。因为除了对表本身的扫描以外，对索引结构的操作和维护是需要额外的时间的。而且，根据索引而进行的访问，在内存空间中一般表现为无序。这种跳跃式的随机内存访问花费的时间显然要比顺序访问多出很多倍。
3、连接（join）操作是查询处理中最常用且最耗时的操作之一。这里简单介绍等值连接（自然连接）常用的几种思想。

【1】嵌套循环（nested loop）。

这是最简单可行的算法。类似于编程语言中的for循环，对若干个表通过这种暴力算法进行连接时，每一层循环查询一个元组时，都要重新检验其内层循环的全部元组是否能够与本层循环正在检验的元组构成符合连接的条件。

【2】排序-合并（归并排序，merge-sort）。

这也是等值连接的常用算法，尤其适合参与连接的各表已经有序的情况。

算法的步骤是：

（1）对参与连接的每一个表，如果未排序，都要将表进行排序。快排可以在O(n log n)的时间复杂度内完成排序。

（2）开始顺序扫描各个表，完成连接。所有参与连接的表都只需要扫描一次。表越大，通过归并排序执行的连接对执行时间的缩短越明显。

【3】索引连接（index join）。

以两张表的等值连接为例，通过索引连接算法进行等值连接，要求第二张表的包含在连接条件中的属性已建立索引。

算法的步骤是：

（1）对第一张表的每一个元组，通过索引查找第二张表中的相应元组。

（2）把这些元组连接起来。

重复执行上述两步，直到第一张表中的元组都处理完毕。

【4】哈希连接（Hash join）。

元组的连接属性被散列函数处理，然后将元组写入哈希表。哈希表采用桶（bucket）结构，相同哈希的元素被放入同一个桶。

算法的步骤是：

（1）划分阶段（building phase）。又称创建阶段。先对包含较少元组的表进行处理，将表的元组分散到哈希表的桶中。

（2）试探阶段（probing phase）。又称连接阶段。对剩余的表进行处理。将元组的连接属性进行哈希，然后找到适当的桶，与桶中匹配的元组连接起来。
9.2 关系数据库系统的查询优化
1、关系系统的查询优化既是关系数据库管理系统实现的关键技术，又是关系系统的优点所在。用户进行查询时，只需提出“干什么”，不必指出“怎么干”。对比一下非关系系统的情况：用户使用过程话的语言表达查询需求。执行何种操作，操作的序列等，这些都必须由用户自己决定。因此用户必须了解存取路径，还要制定存取策略。系统要提供用户选择存取路径的手段。查询效率受到用户水平的极大影响。如果用户做了不当的选择，系统也无法加以改进。

查询优化的优点不仅在于用户不必考虑如何最佳地表达查询以获得尽可能高的效率，而且系统常常可以比用户将查询优化得更好。这是因为：

【1】优化器可以从数据字典获得许多统计信息，例如元组数、属性值的分布、索引情况。优化器会根据这些信息做出正确估算，选择高效的执行计划。用户程序则难以获得这些信息。

【2】如果数据库的物理统计信息改变了，系统可以自动重新优化。在非关系系统中，用户必须重写程序。而将程序大幅度改动甚至推倒重做，在实际应用中往往因为工作量和开发周期等要求而不允许。

【3】优化器可以考虑大量的执行计划。而程序员一般只能有限地考虑几种可能性。

【4】优化器可以灵活运用多种复杂的优化技术。这些优化技术往往只有最好的程序员才能兼顾。由系统自动优化，相当于所有人都拥有了这些优化技术。
2、目前RDBMS通过数学模型计算各种查询执行策略的执行代价，选取代价最小的方案。集中式数据库中，查询开销主要包括IO代价、CPU代价和内存开销。对分布式数据库，还要计算通信代价。即：

总代价 = IO代价 + CPU代价 + 内存代价 + 通信代价。

如果数据库是采用机械硬盘作为磁盘，由于IO涉及机械动作，需要的时间将比内存操作高几个数量级。计算查询代价时，一般用读写的块数量作为衡量单位。

查询优化的搜索空间非常大，实际上系统的自动优化也不总是给出最优策略。
9.3 代数优化
1、代数优化也称逻辑优化，是指关系代数表达式的优化。代数优化策略是指通过关系代数表达式的等价变换提高查询效率。
2、常用的等价变换规则（证明略）：

【1】连接、笛卡尔积的交换律：

设E1和E2是关系代数表达式，F是连接运算的条件，则：

E1×E2≡E2×E1

E1▷◁E2≡E2▷◁E1

E1▷F◁E2≡E2▷F◁E1

【2】连接、笛卡尔积的结合律：

(E1×E2)×E3≡E1×(E2×E3)

(E1▷◁E2)▷◁E3≡E1▷◁ (E2▷◁E3)

(E1▷F1◁E2)▷F2◁E3≡E1▷F1◁ (E2▷F2◁E3)

【3】投影的串接定律：

ΠA1, A2, …, An(ΠB1, B2, …, Bn (E))≡ΠA1, A2, …, An(E)

E是关系代数表达式，Ai（i = 1，2，……，n），Bj（j = 1，2，……，m）是属性名，且{A1, A2, …, An}是{B1, B2, …, Bm}的子集。

【4】选择的串接定律：

σF1(σF2(E))≡σF1∧F2(E)

E是关系代数表达式，F1、F2是选择的条件。该串接律说明对同一表达式的多个选择提出的要求可以合并，这样就可以一次性检查全部条件。

【5】选择与投影的交换律：

σF(ΠA1, A2, …, An(E))≡ΠA1, A2, …, An(σF(E))

这里要求选择条件F只涉及属性A1, A2, …, An。

如果F中有不属于A1, A2, …, An的属性B1, B2, …, Bn，则有更一般的规则：

ΠA1, A2, …, An(σF(E))≡ΠA1, A2, …, An(σF(ΠA1, A2, …, An, B1, B2, …, Bn(E)))

【6】选择与笛卡尔积的交换律：

如果F中涉及的属性都是E1中的属性，则

σF(E1×E2)≡σF(E1)×E2

如果F = F1∧F2，且F1、F2中涉及的属性分别都只是E1、E2的属性，则由等价变换规则1、4、6可推出

σF(E1×E2)≡σF1(E1)×σF2(E2)

如果F1、F2中涉及的属性分别都只是E1、E1和E2的属性，则仍有

σF(E1×E2)≡σF2(σF1(E1)×(E2))

【7】选择对并的分配律：

设E = E1∪E2，且E1和E2有相同的属性名，则

σF(E1∪E2)≡σF(E1)∪σF(E2)

【8】选择对差的分配律：

设E1和E2有相同的属性名，则

σF(E1 – E2)≡σF(E1) – σF(E2)

【9】选择对自然连接的分配律：

σF(E1▷◁E2)≡σF(E1)▷◁σF(E2)

F只涉及E1和E2的公共属性。

【10】投影对笛卡尔积的分配律：

设E1和E2是两个关系表达式，A1, A2, …, An和B1, B2, …, Bm分别是E1和E2的属性，则

ΠA1, A2, …, An, B1, B2, …, Bm(E1×E2)≡ΠA1, A2, …, An(E1)×ΠA1, A2, …, An, B1, B2, …, Bm(E2)

【11】投影对并的分配律：

设E1和E2有相同的属性名，则

ΠA1, A2, …, An, B1, B2, …, Bm(E1∪E2)≡ΠA1, A2, …, An(E1)∪ΠA1, A2, …, An, B1, B2, …, Bm(E2)

（注意：虽然笛卡尔积不满足交换律，但是关系表的属性是没有顺序的，因此即使交换笛卡尔积的两个操作数，得到的新表也视为同一张表）
3、基于启发式规则（heuristic rules）的代数优化是对关系代数表达式的查询树进行优化的方法。典型的启发式规则有：

【1】选择运算应尽可能先做。在优化策略中这是最重要、最基本的一条。因为先将符合一部分条件的元组单独选出来，从而令后续的操作可以都在这些先选出的符合条件的元组上进行，往往可以将代价节约几个数量级。

【2】投影和选择同时进行。如有若干投影和选择运算，且都对同一关系操作，则可以在扫描此关系的同时完成所有的这些运算，避免在分步进行这些投影和选择时反复扫描关系。

【3】把投影同其前后的双目运算结合起来。没有必要为了去掉某些字段而扫描一遍关系。

【4】把某些选择同在它之前要执行的笛卡尔积结合起来成为一个连接运算。连接（特别是等值连接）运算要比同样关系上的笛卡尔积节省很多时间。

【5】找出公共子表达式。如果某些表达式反复出现，且从外存中读入该关系比多次计算该子表达式的时间少，就应该先计算一次该表达式并将结果写入外存，然后在后续操作中直接引用这个结果而不要再计算该表达式。当查询的是视图时，定义视图的表达式就是公共子表达式的情况。
4、下面给出遵循上述启发式规则，且利用前面的等价变换公式来优化关系表达式的算法。

算法名称：关系表达式的优化。

输入：一个关系表达式的查询树。

输出：优化的查询树。

步骤：

【1】利用等价变换规则4：选择的串接定律，把形如σF1∧F2∧…∧Fn(E)的表达式变换成σF1(σF2(…(σFn(E))…))。

我们发现，对后者，从内层向外层计算时，每层都只需判定一个条件，而且得到的结果的元组数量总是减少（至少不变，不会增加）的。而变换之前的表达式需要对原有的大量的元组中的每一个元组都要判定n个条件。显然优化以后可以令查询速率大大提高。

【2】对每一个选择，利用等价变换规则4~9：选择的串接定律，选择与投影、笛卡尔积的交换律，选择对并、差、自然连接的分配律，尽可能将其移到叶节点。

【3】对每一个投影，利用等价变换规则3、5、10、11：投影的串接定律，选择与投影的交换律，投影对笛卡尔积和并的分配律，尽可能将其移到叶节点。

【4】利用等价变换规则3~5：投影和选择的串接定律，选择与投影的交换律，把选择和投影的串接合并成单个选择、单个投影，或一个选择后跟一个投影，使得多个选择和投影可以同时执行，或在一次扫描中全部完成。尽管这种变换似乎违背“投影尽可能早做”的原则，但这样做的效率更高。

【5】把上述得到的语法树的内节点分组。每一组双目运算（笛卡尔积、连接、并、差）和它所有的直接祖先（选择、投影）为一组。如果其后代直到树叶全部是单目运算，则也将它们并入该组。但当双目运算是笛卡尔积，而且后面不是与它组成的等值连接的选择时，不能把选择与这个双目运算组成同一组。把这些单目运算单独分一组。
9.4 物理优化
1、代数优化改变了查询语句的操作次序和组合，但不涉及底层操作和存取路径。对一个查询，可以有许多存取方案，它们执行效率不同，可以相差很大。因此仅仅进行代数优化是不够的。物理优化就是要选择高效合理的底层操作和存取路径，求得更优化的查询计划，达到查询优化的目标。
2、常用的优化方法：

【1】基于规则的启发式优化。启发式规则在多数情况下都使用，但不是每种情况下都是最好。

【2】基于代价估算的优化。优化器估算不同执行策略的代价，并选出代价最小的执行计划。

【3】两者结合。优化器通常把这两种技术结合使用。可能的执行策略极多，穷尽所有的策略进行代价估算一般是不可行的，因为会造成优化本身付出的代价大于收益。为此，禅茶和你关系先用启发式规则排除大部分不太优秀的方案，减少代价估算的工作量，再分别计算这些候选方案的执行代价，较快地选取最终的方案。
3、选择操作的启发式规则：

对于小关系，直接使用顺序扫描，即便选择的列上有索引。因为在特殊的数据结构上进行操作需要额外的时间，对规模很小的关系表，建立和维护这些数据结构以及在这些基础上查询所耗费的总时间反而大于直接顺序扫描。

对于大关系，启发式规则有：

【1】对选择条件是“主码 = 值”的查询，结果唯一，根据RDBMS自动为主码建立的索引查询。

【2】对选择条件是“非主属性 = 值”的查询，且选择列上有索引，则估算查询结果的元组数目。如果比例较多，不应使用索引，而是顺序扫描。

【3】对于选择条件是属性上的非等值查询或者范围查询，且选择列上有索引，仍然是估算查询结果的元组数目。如果比例较多，不应使用索引，而是顺序扫描。

【4】对于用AND连接的合取选择条件，如有涉及这些属性的组合索引，则优选组合索引扫描。如果某些属性上有一般索引，则有两种方法使用索引：第一种方法是，对每个属性的索引找出各自的元组指针，求交集，然后再到表中检索，输出结果。第二种方法是，对部分属性的索引找出各自的元组指针，先在表中索引，再检验未通过索引筛选的属性是否符合要求。同样，不应使用索引的情形中，应该全表扫描。

【5】对OR连接的析取选择条件，一般使用全表顺序扫描。
4、连接操作的启发式规则：

【1】如果部分表已经按照连接属性排序，一般应选择排序-合并算法。

【2】如果一个表在连接属性上存在索引，则可以考虑索引连接算法。

【3】如果上面两个规则都不适用，而有的表比其它表小得多，可以选用哈希连接算法。

【4】上述方法都不适用时，采用嵌套循环直接暴力求解。外循环应该选用占用内存的块数较小的表，理由如下：

设连接表R与S占用的块数分别为Br和Bs，连接需要消耗内存的块数为K，分配K – 1块给外表。如果R为外表，则嵌套循环法的存取块数（理论最大值）为：Br + BrBs / (K – 1)。显然应该选块数小的表作为外表。

上面列出的是主要的启发式规则。实际的RDBMS中，拥有的启发式规则的数量要多得多。
5、启发式规则优化是定性选择，比较粗糙，但实现简单且优化本身代价较小，适合解释执行的系统。因为解释执行的系统在读入语句时才当场进行语句的解析和执行，的优化开销包含在查询的总开销之中。在编译执行的系统中，语句先被编译为机器语言，以备日后反复执行。查询优化和查询执行是分开的，且一般而言这类系统执行的时间开销比编译要大得多。因此，可以采用精细复杂一些的基于代价的优化方法：

【1】基于统计信息的优化方法。

在数据字典中，存储了优化器需要的统计信息，包括：

（1）基本表的元组总数N、元组长度l、占用块数B、占用的溢出块数BO；

（2）基本表的每一列的不同的值的个数m、最大值、最小值、索引类型。根据这些信息可以计算出谓词条件的选择率f。如果不同值分布均匀，f = 1 / m；否则，需要计算每个值的选择率f = 具有该值的元组数 / N。

（3）索引的信息。以B+树为例，层数L、不同索引值的个数、索引的选择基数S（有S个元素具有某个索引值）、索引的叶节点数Y。

【2】基于公式的优化方法：

代价估算的常用公式：

（1）全表扫描的代价估算：

如果基本表大小为B块，则代价为B。

如果选择条件是“码 = 值”，平均搜索代价为B / 2。

（2）索引扫描的代价估算：

如果选择条件是“码 = 值”，且索引为B+树，层数为L，需要存取B+树中根节点到叶节点L块，再加上基本表中该元组占的一块，代价为L + 1。

如果选择条件涉及非码属性，若为B+树索引，选择条件是相等比较，S是索引的选择基数（S个元组满足条件）。因为满足条件的元组可能保存在不同的块上，所以最坏情况的代价是L + S。

如果比较条件是 > ，≥ ，< ，≤ ，设有一半元组满足条件，那么就要存取一半的叶节点，并通过索引访问一半的表存储块。所以代价为L + Y / 2 + B / 2。如果可以获得更准确的选择基数，则可以进一步修正Y / 2与B / 2。

（3）嵌套循环的代价估算：

嵌套循环连接算法的代价：Br + BrBs / (K – 1)。如果需要把连接结果写回磁盘，则代价为Br + BrBs / (K – 1) + (FrsNrNs) / Mrs。Frs为连接选择率（join selectivity），表示连接结果元组数的比例。Mrs是存放连接结果的块因子，表示每个块能存放的结果的元组数量。

（4）排序-合并连接算法的代价估算：

如果连接表已经按连接属性排序，则代价为Br + Bs + (FrsNrNs) / Mrs。

如果需要对文件排序，则需要增加排序的代价。对包含B个块的文件的排序代价约为2B + 2B log B。

实际的RDBMS中，代价估算公式要多得多、复杂得多。
6、语义优化，是指根据数据库的语义约束，把原先的查询转换成另一个执行效率更高的查询。

例如：如果根据约束条件检查到没有符合某个语句的查询结果，那么直接跳过该查询。

关注公众号凡花花的小窝，收获更多的考研计算机专业编程相关的资料

第十四讲 关系查询处理

第三章系统篇

讨论数据库管理系统中查询处理和事务管理的基本概念和基础知识

第9章 关系查询处理和查询优化

第10章 数据库恢复技术

第11章 并发控制
关系查询处理和查询优化

本章内容

关系数据库管理系统的查询处理步骤

查询优化的概念

基本方法和技术

查询优化分类

代数优化：指的是关系代数表达式的优化

物理优化：指的是存取路径和底层操作算法的选择
SQL语句处理过程

查询处理的四个阶段

1.查询分析

2.查询检查

3.查询优化

4.查询执行
查询处理步骤



一个例子

SELECT Sname

FROM Student

WHERE Sno='20100017"
1.查询分析

查询分析的任务：对查询语句进行扫描，词法分析和语法分析

词法分析：从查询语句中识别出正确的语法符号

语法分析：进行语法检查
这样和编译器的原理是一样的

词法分析：

保留字：SELECT ,FROM ,WHERE

变量：Sname,Student,Sno

常量：“20100017”

运算符：=

可以发现：拼写错误，命名错误，非法符号等
语法分析

按照SQL语言的句法解释查询语句

例如：下面SQL语句就是语法错误的

SELECT Sname

FROM Student

WHEN Sno=“201000017”
2.查询检查

查询检查的任务

有效性检查

视图转换

安全性检查

完整性初步检查
2.查询检查

有效性检查：检查语句中的数据库对象，比如关系名，属性名是否存在和有效

根据数据字典中有关的模式的定义信息进行检查
视图转换

如果查询是对视图的操作，则要用视图消解法把对视图的操作转换称为对基本表的操作



2.查询检查

安全性检查

根据数据字典中的用户权限对用户的存取权限进行检查

完整性检查

根据数据字典中存储的完整性约束的定义，对句子进行检查

例如：Where Sno=2010100017就是错误的，因为Sno是字符类型Char(8)

语法分析树

检查通过之后，把SQL查询语句转换成为内部表示，一般用语法树来表示



3.查询优化

查询优化是关系数据库成功的关键因素之一，早年的关系数据库由于性能不高备受诟病，正是由于查询优化技术的进步，才能够让关系数据库走向产品

查询优化：选择一个高效执行的查询处理策略
分类：

代数优化/逻辑优化：指的是针对关系代数表达式的优化

物理优化：指的是对存取路径和底层操作算法的选择

查询优化的选择依据

基于规则rule based

基于代价 cost based

基于语义 semantic based
4.查询执行

依据优化器得到的执行策略生成查询执行计划

代码生成器code gengerator生成执行查询计划的代码

两种执行方法

自顶向下

自底向上
关系算子的实现
实现查询操作的算法实例

关系代数是关系数据库的抽象语言，理解如何实现关系代数操作有助于我们理解查询优化的过程。

1.选择操作的实现

2.连接操作的实现
1.选择操作的实现

实现方法

1.全表扫描方法table Scan

对查询的基本表顺序扫描，逐一检查每个元组是否满足选择条件，把满足条件的元组作为结果输出

适合小表，不适合大表

2.索引扫描法Index Scan

适合于选择条件中的属性上有索引（例如B+树索引或者Hash索引）

通过索引先找到满足条件的元组主码或者元组指针，再通过元组指针直接再查询基本表中找到元组
［例1］Select * from student where <条件表达式> ；

考虑<条件表达式>的几种情况：

C1：无条件；

C2：Sno＝’200215121’；

C3：Sage>20；

C4：Sdept＝’CS’ AND Sage>20；

选择操作典型实现方法：

简单的全表扫描方法

对查询的基本表顺序扫描，逐一检查每个元组是否满足选择条件，把满足条件的元组作为结果输出

适合小表，不适合大表
索引(或散列)扫描方法

适合选择条件中的属性上有索引(例如B+树索引或Hash索引)

通过索引先找到满足条件的元组主码或元组指针，再通过元组指针直接在查询的基本表中找到元组

［例1-C2］  以C2为例，Sno＝‘200215121’，并且Sno上有索引(或Sno是散列码)

使用索引(或散列)得到Sno为‘200215121’ 元组的指针

通过元组指针在student表中检索到该学生

［例1-C3］  以C3为例，Sage>20，并且Sage 上有B+树索引

使用B+树索引找到Sage＝20的索引项，以此为入口点在B+树的顺序集上得到Sage>20的所有元组指针

通过这些元组指针到student表中检索到所有年龄大于20的学生。 ［例1-C4］  以C4为例，Sdept＝‘CS’ AND Sage>20，如果Sdept和Sage上都有索引：

算法一：分别用上面两种方法分别找到Sdept＝‘CS’的一组元组指针和Sage>20的另一组元组指针

求这2组指针的交集

到student表中检索

得到计算机系年龄大于20的学生
算法二：找到Sdept＝‘CS’的一组元组指针，

通过这些元组指针到student表中检索

对得到的元组检查另一些选择条件(如Sage>20)是否满足

把满足条件的元组作为结果输出。


2.连接操作的实现

连接操作是查询处理中最耗时的操作之一

本节只讨论等值连接或者自然连接最常用的实现算法

eg9.2 SELECT *

FROM Student,SC

WHERE Student.Sno=SC.Sno;
二、 连接操作的实现

连接操作是查询处理中最耗时的操作之一

本节只讨论等值连接(或自然连接)最常用的实现算法
［例2］   SELECT * FROM Student，SC 		

WHERE Student.Sno=SC.Sno；


嵌套循环方法(nested loop)


排序-合并方法(sort-merge join 或merge join)


索引连接(index join)方法


1.Hash Join方法

Hash Join方法，Index Join方法 sort-merge或者merge join  嵌套循环方法nested loop

嵌套循环方法(nested loop)

对外层循环(Student)的每一个元组(s)，检索内层循环(SC)中的每一个元组(sc)

检查这两个元组在连接属性(sno)上是否相等

如果满足连接条件，则串接后作为结果输出，直到外层循环表中的元组处理完为止

排序-合并方法(sort-merge join 或merge join)

适合连接的诸表已经排好序的情况

排序－合并连接方法的步骤：

如果连接的表没有排好序，先对Student表和SC表按连接属性Sno排序

取Student表中第一个Sno，依次扫描SC表中具有相同Sno的元组



排序－合并连接方法的步骤（续）：

当扫描到Sno不相同的第一个SC元组时，返回Student表扫描它的下一个元组，再扫描SC表中具有相同Sno的元组，把它们连接起来

重复上述步骤直到Student 表扫描完

Student表和SC表都只要扫描一遍

如果2个表原来无序，执行时间要加上对两个表的排序时间

对于2个大表，先排序后使用sort-merge join方法执行连接，总的时间一般仍会大大减少


索引连接(index join)方法

步骤：

① 在SC表上建立属性Sno的索引，如果原来没有该索引

② 对Student中每一个元组，由Sno值通过SC的索引查找相应的SC元组

③ 把这些SC元组和Student元组连接起来

循环执行②③，直到Student表中的元组处理完为止


Hash Join方法

把连接属性作为hash码，用同一个hash函数把R和S中的元组散列到同一个hash文件中

步骤：

划分阶段(partitioning phase)：

对包含较少元组的表(比如R)进行一遍处理

把它的元组按hash函数分散到hash表的桶中

试探阶段(probing phase)：也称为连接阶段(join phase)

对另一个表(S)进行一遍处理

把S的元组散列到适当的hash桶中

把元组与桶中所有来自R并与之相匹配的元组连接起来

上面hash join算法前提：假设两个表中较小的表在第一阶段后可以完全放入内存的hash桶中


以上的算法思想可以推广到更加一般的多个表的连接算法上
9.2 关系数据库系统的查询优化

第15讲 关系查询的优化

查询优化的重要性

9.2.1查询优化的概述

查询优化的优点

是关系数据库管理系统实现的关键技术又是关系系统的优点所在

减轻了用户对于系统底层选择存取路径的负担

用户就可以关注查询的正确表达上，而不需要考虑查询的执行效率如何
系统优化后的程序通常可以比用户程序做的更好

1.优化器可以从数据字典中获取许多统计信息，而用户程序则难以获得这些信息

2.如果数据库的物理统计信息改变了，系统可以自动对查询重新优化来选择相适应的执行计划，在非关系系统中必须重写程序，这个在实际中往往是不可行的

3.优化器可以考虑数百种不同的执行计划，程序员一般只能考虑优先的几种可能性

4.优化器中包括了很多复杂的优化技术，这些优化技术往往只有最好的程序员才能掌握，系统的自动优化相当于使得所有人都拥有这些优化技术

关系数据库管理系统通过某种代价模型计算出各种查询执行策略的执行代价，然后选取代价最小的执行方案

集中式数据库

执行开销主要包括

磁盘存取块数（I/O代价）

处理机时间（CPU代价）

内存空间开销

I/O代价是最重要的

分布式数据库

总代价=O/代价+CPU代价+内存代价+通信代价

查询优化的总目标

选择有效的策略

求得给定关系表达式的值

使得查询代价最小（实际上是较小的）

9.2.1  查询优化概述

关系系统的查询优化

非关系系统
[例3] 求选修了2号课程的学生姓名。用SQL表达：

SELECT  Student.Sname

FROM  Student，SC

WHERE  Student.Sno=SC.Sno AND 				 SC.Cno=‘2’；
假定学生-课程数据库中有1000个学生记录，10000个选课记录

其中选修2号课程的选课记录为50个








一、第一种情况

Q1=πSname(σStudent.Sno=SC.Sno∧Sc.Cno=‘2’ Student×SC))


计算广义笛卡尔积

把Student和SC的每个元组连接起来的做法：

在内存中尽可能多地装入某个表(如Student表)的若干块，留出一块存放另一个表(如SC表)的元组。

把SC中的每个元组和Student中每个元组连接，连接后的元组装满一块后就写到中间文件上

从SC中读入一块和内存中的Student元组连接，直到SC表处理完。

再读入若干块Student元组，读入一块SC元组

重复上述处理过程，直到把Student表处理完

设一个块能装10个Student元组或100个SC元组，在内存中存放5块Student元组和1块SC元组，则读取总块数为
              ＋                            =100+20×100=2100块


其中，读Student表100块。读SC表20遍，每遍100块。若每秒读写20块，则总计要花105s

连接后的元组数为103×104=107。设每块能装10个元组，则写出这些块要用106/20=5×104s

2. 作选择操作

依次读入连接后的元组，按照选择条件选取满足要求的记录

假定内存处理时间忽略。读取中间文件花费的时间(同写中间文件一样)需5×104s

满足条件的元组假设仅50个，均可放在内存

3. 作投影操作

把第2步的结果在Sname上作投影输出，得到最终结果

第一种情况下执行查询的总时间≈105+2×5×104≈105s

所有内存处理时间均忽略不计
二、 第二种情况

Q2=πSname(σSc.Cno=‘2’ (Student     SC))

计算自然连接

执行自然连接，读取Student和SC表的策略不变，总的读取块数仍为2100块花费105 s

自然连接的结果比第一种情况大大减少，为104个

写出这些元组时间为104/10/20=50s，为第一种情况的千分之一
读取中间文件块，执行选择运算，花费时间也为50s。
把第2步结果投影输出。

第二种情况总的执行时间≈105+50+50≈205s

三、 第三种情况

Q3=πSname(Student      σSc.Cno=‘2’(SC))
先对SC表作选择运算，只需读一遍SC表，存取100块花费时间为5s，因为满足条件的元组仅50个，不必使用中间文件。
读取Student表，把读入的Student元组和内存中的SC元组作连接。也只需读一遍Student表共100块，花费时间为5s。
把连接结果投影输出

第三种情况总的执行时间≈5+5≈10s

假如SC表的Cno字段上有索引

第一步就不必读取所有的SC元组而只需读取Cno=‘2’的那些元组(50个)

存取的索引块和SC中满足条件的数据块大约总共3～4块

若Student表在Sno上也有索引

第二步也不必读取所有的Student元组

因为满足条件的SC记录仅50个，涉及最多50个Student记录

读取Student表的块数也可大大减少
总的存取时间将进一步减少到数秒

把代数表达式Q1变换为Q2、 Q3，

即有选择和连接操作时，先做选择操作，这样参加连接的元组就可以大大减少，这是代数优化

在Q3中

SC表的选择操作算法有全表扫描和索引扫描2种方法，经过初步估算，索引扫描方法较优

对于Student和SC表的连接，利用Student表上的索引，采用index join代价也较小，这就是物理优化

代数优化策略：通过对关系代数表达式的等价变换来提高查询效率
关系代数表达式的等价：指用相同的关系代替两个表达式中相应的关系所得到的结果是相同的
两个关系表达式E1和E2是等价的，可记为E1≡E2





























典型的启发式规则：

选择运算应尽可能先做。在优化策略中这是最重要、最基本的一条
把投影运算和选择运算同时进行

如有若干投影和选择运算，并且它们都对同一个关系操作，则可以在扫描此关系的同时完成所有的这些运算以避免重复扫描关系
把投影同其前或其后的双目运算结合起来
把某些选择同在它前面要执行的笛卡尔积结合起来成为一个连接运算
找出公共子表达式

如果这种重复出现的子表达式的结果不是很大的关系并且从外存中读入这个关系比计算该子表达式的时间少得多，则先计算一次公共子表达式并把结果写入中间文件是合算的

当查询的是视图时，定义视图的表达式就是公共子表达式的情况

遵循这些启发式规则，应用9.3.1的等价变换公式来优化关系表达式的算法。

算法：关系表达式的优化

输入：一个关系表达式的查询树

输出：优化的查询树

方法：

(1) 利用等价变换规则4把形如σF1∧F2∧…∧Fn(E)变换为σF1(σF2(…(σFn(E))…))。

(2) 对每一个选择，利用等价变换规则4～9尽可能把它移到树的叶端。

(3) 对每一个投影利用等价变换规则3，5，10，11中的一般形式尽可能把它移向树的叶端。

注意：

等价变换规则3使一些投影消失

规则5把一个投影分裂为两个，其中一个有可能被移向树的叶端

(4) 利用等价变换规则3～5把选择和投影的串接合并成单个选择、单个投影或一个选择后跟一个投影。使多个选择或投影能同时执行，或在一次扫描中全部完成

(5) 把上述得到的语法树的内节点分组。每一双目运算(×，  ，∪，-)和它所有的直接祖先为一组(这些直接祖先是(σ，π运算)。

如果其后代直到叶子全是单目运算，则也将它们并入该组

但当双目运算是笛卡尔积(×)，而且后面不是与它组成等值连接的选择时，则不能把选择与这个双目运算组成同一组，把这些单目运算单独分为一组  

关系查询优化是影响RDBMS性能的关键因素 

 


v查询优化的总目标：

    选择有效的策略

    求得给定关系表达式的值

    使得查询代价最小(实际上是较小) 



集中式数据库

      Ø执行开销主要包括：

                磁盘存取块数(I/O代价)

                处理机时间(CPU代价)

                查询的内存开销 

      ØI/O代价是最主要的 

分布式数据库

      Ø总代价=I/O代价+CPU代价+内存代价＋通信代价 


例题：

例1：求选修了2号课程的学生姓名。用SQL表达：

      SELECT  Student.Sname

     FROM  Student，SC

     WHERE  Student.Sno=SC.Sno AND    SC.Cno=‘2’；

 

系统可以用多种等价的关系代数表达式来完成这一查询

1.     Q1=πSname(σStudent.Sno=SC.Sno∧Sc.Cno='2' (Student×SC))

        1. 计算广义笛卡尔积 

        2. 作选择操作 

        3. 作投影操作 

2.     Q2=πSname(σSc.Cno='2' (Student     SC))

       1. 计算自然连接 

       2. 读取中间文件块，执行选择运算

       3. 把第2步结果投影输出。

3.     Q3=πSname(Student      σSc.Cno='2'(SC))

       1. 先对SC表作选择运算，只需读一遍SC表

       2. 读取Student表，把读入的Student元组和内存中的SC元组作连接

       3. 把连接结果投影输出  

4.

v假如SC表的Cno字段上有索引

     第一步就不必读取所有的SC元组而只需读取Cno=‘2’的那些元组(50个)

v若Student表在Sno上也有索引

     第二步也不必读取所有的Student元组

     因为满足条件的SC记录仅50个，涉及最多50个Student记录

     读取Student表的块数也可大大减少

查询优化

在关系数据库系统中有着非常重要的地位  

关系查询优化是影响RDBMS性能的关键因素  

由于关系表达式的语义级别很高，使关系系统可以从关系表达式中分析查询语义，提供了执行查询优化的可能性  

查询优化的优点不仅在于用户不必考虑如何最好地表达查询以获得较好的效率，而且在于系统可以比用户程序的“优化”做得更好  

(1) 优化器可以从数据字典中获取许多统计信息，而用户程序则难以获得这些信息 

(2)如果数据库的物理统计信息改变了，系统可以自动对查询重新优化以选择相适应的执行计划。在非关系系统中必须重写程序，而重写程序在实际应用中往往是不太可能的。 

(3)优化器可以考虑数百种不同的执行计划，程序员一般只能考虑有限的几种可能性。 

(4)优化器中包括了很多复杂的优化技术，这些优化技术往往只有最好的程序员才能掌握。系统的自动优化相当于使得所有人都拥有这些优化技术

RDBMS通过某种代价模型计算出各种查询执行策略的执行代价，然后选取代价最小的执行方案 

集中式数据库 

执行开销主要包括： 

磁盘存取块数(I/O代价) 

处理机时间(CPU代价) 

查询的内存开销  

I/O代价是最主要的 

分布式数据库 

总代价=I/O代价+CPU代价+内存代价＋通信代价 



查询优化的总目标：
选择有效的策略
求得给定关系表达式的值
使得查询代价最小(实际上是较小) 

[例3] 求选修了2号课程的学生姓名。用SQL表达：
      SELECT  Student.Sname
       FROM  Student，SC
       WHERE  Student.Sno=SC.Sno AND                 SC.Cno=‘2’； 

假定学生-课程数据库中有1000个学生记录，10000个选课记录
其中选修2号课程的选课记录为50个 




系统可以用多种等价的关系代数表达式来完成这一查询
Q1=πSname(σStudent.Sno=SC.Sno∧Sc.Cno='2' (Student×SC))
Q2=πSname(σSc.Cno='2' (Student     SC))
Q3=πSname(Student      σSc.Cno='2'(SC))


一、第一种情况 

 Q1=πSname(σStudent.Sno=SC.Sno∧Sc.Cno=’2’ (Student×SC)) 

1. 计算广义笛卡尔积  

把Student和SC的每个元组连接起来的做法： 

在内存中尽可能多地装入某个表(如Student表)的若干块，留出一块存放另一个表(如SC表)的元组。 

把SC中的每个元组和Student中每个元组连接，连接后的元组装满一块后就写到中间文件上 

从SC中读入一块和内存中的Student元组连接，直到SC表处理完。 

再读入若干块Student元组，读入一块SC元组 

重复上述处理过程，直到把Student表处理完 

2. 作选择操作  

依次读入连接后的元组，按照选择条件选取满足要求的记录  

假定内存处理时间忽略。读取中间文件花费的时间(同写中间文件一样)需5×104s  

满足条件的元组假设仅50个，均可放在内存  

3. 作投影操作  

把第2步的结果在Sname上作投影输出，得到最终结果  

第一种情况下执行查询的总时间≈105+2×5×104≈105s 

所有内存处理时间均忽略不计 

二、 第二种情况  

    Q2=πSname(σSc.Cno=’2’ (Student     SC)) 

1. 计算自然连接  

执行自然连接，读取Student和SC表的策略不变，总的读取块数仍为2100块花费105 s  

自然连接的结果比第一种情况大大减少，为104个  

写出这些元组时间为104/10/20=50s，为第一种情况的千分之一  

2. 读取中间文件块，执行选择运算，花费时间也为50s。 

3. 把第2步结果投影输出。 

    第二种情况总的执行时间≈105+50+50≈205s 

三、 第三种情况 

    Q3=πSname(Student      σSc.Cno=’2’(SC)) 

1. 先对SC表作选择运算，只需读一遍SC表，存取100块花费时间为5s，因为满足条件的元组仅50个，不必使用中间文件。 

2. 读取Student表，把读入的Student元组和内存中的SC元组作连接。也只需读一遍Student表共100块，花费时间为5s。 

3. 把连接结果投影输出 

    第三种情况总的执行时间≈5+5≈10s 

假如SC表的Cno字段上有索引 

第一步就不必读取所有的SC元组而只需读取Cno=‘2’的那些元组(50个) 

存取的索引块和SC中满足条件的数据块大约总共3～4块

若Student表在Sno上也有索引 

第二步也不必读取所有的Student元组 

因为满足条件的SC记录仅50个，涉及最多50个Student记录 

读取Student表的块数也可大大减少 

总的存取时间将进一步减少到数秒 

把代数表达式Q1变换为Q2、 Q3， 

即有选择和连接操作时，先做选择操作，这样参加连接的元组就可以大大减少，这是代数优化 

在Q3中 

SC表的选择操作算法有全表扫描和索引扫描2种方法，经过初步估算，索引扫描方法较优  

对于Student和SC表的连接，利用Student表上的索引，采用index join代价也较小，这就是物理优化 



代数优化策略

：通过对关系代数表达式的等价变换来提高查询效率 

关系代数表达式的等价：指用相同的关系代替两个表达式中相应的关系所得到的结果是相同的

两个关系表达式E1和E2是等价的，可记为E1≡E2  



常用的等价变换规则：
1.  连接、笛卡尔积交换律
   设E1和E2是关系代数表达式，F是连接运算的条件，则有
    E1  × E2≡E2  × E1
    E1      E2≡E2      E1
    E1      E2≡E2      E1
2. 连接、笛卡尔积的结合律
   设E1，E2，E3是关系代数表达式，F1和F2是连接运算的条件，则有
    (E1  × E2) × E3≡E1 × (E2 × E3)
    (E1      E2)      E3≡E1      (E2      E3)
    (E1     E2)      E3≡E1     (E2      E3) 
3. 投影的串接定律
                 (            (E))≡            (E)
    这里，E是关系代数表达式，Ai(i=1，2，…，n)，Bj(j=1，2，…，m)是属性名且{A1，A2，…，An}构成{B1，B2，…，Bm}的子集。
4. 选择的串接定律
           (     (E))≡           (E)
    这里，E是关系代数表达式，F1、F2是选择条件。
    选择的串接律说明选择条件可以合并。这样一次就可检查全部条件
5. 选择与投影操作的交换律
    σF(          (E))≡            (σF(E))
    选择条件F只涉及属性A1，…，An。
    若F中有不属于A1，…，An的属性B1，…，Bm则有更一般的规则：
                (σF(E))≡          (σF(                       (E)))

6. 选择与笛卡尔积的交换律
    如果F中涉及的属性都是E1中的属性，则
         (E1×E2)≡     (E1)×E2
    如果F=F1∧F2，并且F1只涉及E1中的属性，F2只涉及E2中的属性，则由上面的等价变换规则1，4，6可推出：
         (E1×E2)≡     (E1)×     (E2)
    若F1只涉及E1中的属性，F2涉及E1和E2两者的属性，则仍有
        (E1×E2)≡      (     (E1)×E2)
    它使部分选择在笛卡尔积前先做。 

7. 选择与并的分配律
    设E=E1∪E2，E1，E2有相同的属性名，则
    σF(E1∪E2)≡σF(E1)∪σF(E2)
8. 选择与差运算的分配律
    若E1与E2有相同的属性名，则
    σF(E1-E2)≡σF(E1)-σF(E2)
9. 选择对自然连接的分配律
    σF(E1    E2)≡σF(E1)      σF(E2)
    F只涉及E1与E2的公共属性 
10. 投影与笛卡尔积的分配律
    设E1和E2是两个关系表达式，A1，…，An是E1的属性，B1，…，Bm是E2的属性，则
                        (E1×E2)≡            (E1)×            (E2)
11. 投影与并的分配律
    设E1和E2有相同的属性名，则
                  (E1∪E2)≡            (E1)∪            (E2)


查询树的启发式优化

典型的启发式规则： 

1. 选择运算应尽可能先做。在优化策略中这是最重要、最基本的一条 

2. 把投影运算和选择运算同时进行（pipelining技术） 

如有若干投影和选择运算，并且它们都对同一个关系操作，则可以在扫描此关系的同时完成所有的这些运算以避免重复扫描关系，也避免存储中间关系 

3. 把投影同其前或其后的双目运算结合起来执行（pipelining技术） 

4. 把某些选择同在它前面要执行的笛卡尔积结合起来成为一个连接运算 

5. 找出公共子表达式 

如果这种重复出现的子表达式的结果不是很大的关系并且从外存中读入这个关系比计算该子表达式的时间少得多，则先计算一次公共子表达式并把结果写入中间文件是合算的 

当查询的是视图时，定义视图的表达式就是公共子表达式的情况 

遵循这些启发式规则，应用9.3.1的等价变换公式来优化关系表达式的算法。 

    算法：关系表达式的优化 

    输入：一个关系表达式的查询树 

    输出：优化的查询树 

    方法： 

    (1) 利用等价变换规则4把形如σF1∧F2∧…∧Fn(E)变换为σF1(σF2(…(σFn(E))…))。 

    (2) 对每一个选择，利用等价变换规则4～9尽可能把它移到树的叶端。 

    (3) 对每一个投影利用等价变换规则3，5，10，11中的一般形式尽可能把它移向树的叶端。 

注意：  

等价变换规则3使一些投影消失 

规则5把一个投影分裂为两个，其中一个有可能被移向树的叶端  

    (4) 利用等价变换规则3～5把选择和投影的串接合并成单个选择、单个投影或一个选择后跟一个投影。使多个选择或投影能同时执行，或在一次扫描中全部完成 

    (5) 把上述得到的语法树的内节点分组。每一双目运算(×，  ，∪，-)和它所有的直接祖先为一组(这些直接祖先是(σ，π运算)。 

如果其后代直到叶子全是单目运算，则也将它们并入该组 

但当双目运算是笛卡尔积(×)，而且后面不是与它组成等值连接的选择时，则不能把选择与这个双目运算组成同一组，把这些单目运算单独分为一组  



例[5] 查询语句：检索学习课程名为MATH的女学生学号和姓名。
该查询语句的关系代数表达式如下：
   πS#，SNAME(σCNAME=’MATH’∧SEX=’F’(C   SC   S))
上式中， 符号用π、σ、×操作表示，可得下式
 πS#，SNAME(σCNAME=’MATH’∧SEX=’F’(πL
          (σC.C# = SC.C#∧SC.S# = S.S#(C×SC×S))))
此处L是C、SC、S中全部属性,去除重复属性。