我准备给
t1增加索引c
t2增加组合索引b,c
t3增加组合索引b,c
select * from t1 straight_join t2 on(t1.a=t2.a) straight_join t3 on (t2.b=t3.b) where t1.c>=X and t2.c>=Y and t3.c>=Z;

另外我还有个问题，开篇提到的这句sql select * from t1 where a>=1 and a<=100;
a是索引列，如果这句索引有order by a，不使用MRR 优化，查询出来就是按a排序的，使用了mrr优化，是不是要额外排序

老师您好，新年快乐~~

关于三表join有一个疑惑点需要确认：

老师您在评论中说到，三表join不会是前两个表join后得到结果集，再和第三张表join。
针对这句话，我的理解是：
假设我们不考虑BKA，就按照一行行数据来判断的话，流程应该如下（我会将server端和innodb端分的很清楚）：
表是t1 ,t2 ,t3。 t1 straight_join t2 straight_join t3，这样的join顺序。
1. 调用innodb接口，从t1中取一行数据，数据返回到server端。
2. 调用innodb接口，从t2中取满足条件的数据，数据返回到server端。
3. 调用innodb接口，从t3中取满足条件的数据，数据返回到server端。
上面三步之后，驱动表 t1的一条数据就处理完了，接下来重复上述过程。
（如果采用BKA进行优化，可以理解为不是一行行数据的提取，而是一个范围内数据的提取）。

按照我上面的描述，确实没有前两表先join得结果集，然后再join第三张表的过程。
不知道我上面的描述的流程对不对？（我个人觉得，将innodb的处理和server端的处理分隔清晰，对于sql语句的理解，会透彻很多）

刚刚凌乱了的那个问题，经explain验证，explain SELECT a.* FROM sys_xxtx a JOIN baq_ryxx r ON a.ryid = r.ID WHERE a.dwbh = '7E0A13A14101D0A8E0430A0F23BCD0A8' ORDER BY txsj DESC LIMIT 0,20;
使用的索引是txsj ；
explain SELECT a.* FROM sys_xxtx a JOIN baq_ryxx r ON a.ryid = r.ID WHERE a.dwbh = '7E0A13A14101D0A8E0430A0F23BCD0A8' ORDER BY txsj DESC LIMIT 5000,20;使用的索引是dwbh ；
然后回忆起了第10张：MySQL为什么有时候会选错索引？
但是从扫描行数、是否使用排序等来看在 LIMIT 5000,20时候也应该优选txsj ?可是这个时候选择的索引是dwbh, 查询时间也大大缩短

知识点总结
1、翻译嵌套查询过程
Join = 嵌套查询
示例：t1 join t2 on t1.a=t2.a where t1.id>=X and t2.id>=Y
已知：驱动表t1的规模是N，被驱动表t2的规模是M
伪代码：
SNLJ: 扫描次数NxM, 计算次数NxM
for r1 in t1 /* read from ~~disk~~ InnoDB(storage engine) */
  for r2 in t2
    if r1.a=r2.a
      if r1.id>=X and r2.id>=Y
        add r1+r2 into result_set
  end
end


BNLJ: 扫描次数N+KxM，计算次数NxM，K = Nxrow_size/join_buffer_size+1
for r1 in t1
  add r1 into join_buffer
end
for r2 in t2
  for r1 in join_buffer /* read from ~~memory~~ join_buffer which is controlled by Server */
    if r1.a=r2.a
      if r1.id>=X and r2.id>=Y
        add r1+r2 into result_set
  end
end


INLJ: 扫描次数<N+N，计算次数N + Nx2xlnM/ln2
for r1 in t1
  locate r1.a on t2 with index a /* search B+Tree */
  if r1.id>=X and r2.id>=Y
    add r1+r2 into result_set
end



2、Join优化思路
MRR优化思想：回表前，按主键排序，执行读取操作，以保证顺序读。
BKA算法：先按BNLJ的思想批量扫描驱动表数据，再将之按被驱动表上的索引排序，取值。
示例：t1 join t2 on t1.a=t2.b where t1.id>=X and t2.id>=Y
伪代码：
for r1 in t1
  add r1 into join_buffer
end
sort join_buffer by r1.a
for r1 in sort_buffer
  locate r1.a on t2 with index b /* search B+Tree */
  if r1.id>=X and r2.id>=Y
    add r1+r2 into result_set
end


3、BNLJ转BKA
方案一：在被驱动表的join字段上添加索引，相当于BNLJ先转INLJ再转BKA。
方案二：不适宜添加索引的情况（查询语句使用频率较低），引入临时表。具体操作步骤如下：
   a. 先根据where过滤被驱动表t2，并将结果存入临时表tmp_t；
   b. 在临时表上为join字段b添加索引；
   c. 让驱动表t1连接临时表tmp_t。
（注意，由于步骤b中需要为临时表创建索引，所以此方案当且仅当tmp_t规模远小于t2时才划算！）


4、扩展hash-join
可视为BNLJ进阶，将join_buffer变成Hash表，处理流程如下：

hash-join:
for r1 in t1
  add <key:r1.a,value:r1> into join_buffer
end
for r2.a in t2
  locate r2.a in t1 with hash index /* read from join_buffer */
  if r1.id>=X and r2.id>=Y
    add r1+r2 into result_set
end


分析：
   a. 驱动表在内环，以降低内存占用率。
   b. 如果t1的尺寸大于join_buffer，那么我们就不得不多次全表扫描t2了。因为过滤条件的逻辑运算符号是and，所以还有优化的余地，可将驱动表的过滤提前，来降低t1的大小。
for r1 in t1
  if r1.id>=X
    add <key:r1.a,value:r1> into join_buffer
end
for r2.a in t2
  locate r2.a in t1 with hash index /* read from join_buffer */
  if r2.id>=Y
    add r1+r2 into result_set
end

前提假设：t1.c>=X可以让t1成为小表。同时打开BKA和MRR。
1、t1表加（c,a)索引。理由：A、t1.c>=X可以使用索引；B、加上a的联合索引，join buffer里放入的是索引（c,a）而不是去主键表取整行，用于与表t2的t1.a = t2.a的join查询，不过返回SELECT * 最终还是需要回表。
2、t2表加(a,b,c)索引。理由：A、加上a避免与t1表join查询的BNL；B、理由同【1-B】；C、加上c不用回表判断t2.c>=Y的筛选条件
3、t3表加（b,c）索引。理由：A、避免与t2表join查询的BNL;C、理由同【2-C】

问题：
1、【1-B】和【2-B】由于select *要返回所有列数据，不敢肯定join buffer里是回表的整行数据还是索引（c,a)的数据，需要老师解答一下；不过值得警惕的是，返回的数据列对sql的执行策略有非常大的影响。
2、在有join查询时，被驱动表是先做join连接查询，还是先筛选数据再从筛选后的临时表做join连接？这将影响上述的理由【2-C】和【3-C】

使用straight_join强制指定驱动表，我会改写成这样:select * from t2 STRAIGHT_JOIN t1 on(t1.a=t2.a) STRAIGHT_JOIN t3 on (t2.b=t3.b) where t1.c>=X and t2.c>=Y and t3.c>=Z;
考虑因素包括：
1、驱动表使用过滤条件筛选后的数据量，使其成为小表，上面的改写也是基于t2是小表
2、因为t2是跟t1,t3都有关联查询的，这样的话我猜测对t1,t3的查询是不是可以并行执行，而如果使用t1,t3作为主表的话，是否会先跟t2生成中间表，是个串行的过程？
3、需要给t1加（a,c)索引，给t2加（c,a,b）索引。

老师你好，今天在回顾这篇文章做总结的时候，突然有一个疑惑：

我们假设t2的b上面有索引，该语句是左连接

select * from t1 left join t2 on (t1.b=t2.b) where t2.b>=1 and t2.b<=2000;

和

select * from t1 left join t2 on (t1.b=t2.b) and t2.b>=1 and t2.b<=2000;

到底在内部执行流程上到底有什么区别？？
因为实际工作中左连接用得挺多的。
（这篇文章都是直连，所以使用on和where最后的结果都一样，但是左连接就不是了）