一个普通的语句select * from t1, t2 where t1.id = t2.id and t1.name = 'a'; 这个语句在什么情况下最高效？
表连接分类：
1. 嵌套循环连接(Nested Loop Join)
2. 排序合并连接(Merge Sort Join)：PGA 中的 SORT_AREA_SIZE 控制
3. 哈希连接(Hash Join)：PGA中的HASH_AREA_SIZE控制
示例(基本均是在sql*plus环境下执行)：
-- 准备脚本
prompt 准备实验环境.....
drop table t1 cascade constraints purge;
drop table t2 cascade constraints purge;
create table t1(
id number not null,
n number,
contents varchar2(4000)
);
create table t2(
id number not null,
t1_id number not null,
n number,
contents varchar2(4000)
);
execute dbms_random.seed(0);
insert into t1
(
id,
n,
contents
)
select rownum,
rownum,
dbms_random.string('a', 50)
from dual
connect by level <= 100
order by dbms_random.random;
insert into t2
(
id,
t1_id,
n,
contents
)
select rownum,
rownum,
rownum,
dbms_random.string('b', 50)
from dual
connect by level <= 100000
order by dbms_random.random;
commit;
-- 修改统计参数为ALL
alter system set statistics_level=all;
-- alter session set statistics_level=all; 会话级修改，偶尔失效
show parameter statistics_level;
set linesize 1000
-- 实验开始
-- NL连接表
-- 1.1 HINT含义 leading(t1)表示强制先访问t1表，也就是t1表作为驱动表；use_nl表示强制用嵌套循环连接方式
select /*+leading(t1) use_nl(t2)*/ * from t1, t2 where t1.id = t2.t1_id;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
starts列是表访问的次数，t1表访问了1次，t2表访问了100次
-- 1.2
select /*+leading(t1) use_nl(t2)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n in (19, 20);
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
t1表访问了1次，t2表访问了2次
-- 1.3
select /*+leading(t1) use_nl(t2)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 19;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
t1表访问了1次，t2表访问了1次
-- 1.4
select /*+leading(t1) use_nl(t2)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 9999999;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
t1表访问了1次，t2表访问了0次
NL表连接访问次数最终结论：t1表的查询返回多少条记录，t2表就访问多少次。也就是，在嵌套循环连接中，驱动表返回多少条记录，被驱动表就访问多少次。
--2. 哈希连接表
-- 2.1
select /*+leading(t1) use_hash(t2)*/ * from t1, t2 where t1.id = t2.t1_id;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
t1 1次, t2 1次
在HASH连接中，驱动表和被驱动表都只会访问1次或0次
-- 2.2
select /*+leading(t1) use_hash(t2)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 9999999;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
t1 1次，t2 0次
-- 2.3
select /*+leading(t1) use_hash(t2)*/ * from t1, t2 where t1.id = t2.t1_id and 1 = 2;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
t1 0次, t2 0次
-- 3. 排序合并连接
select /*+ordered use_merge(t2)*/ * from t1, t2 where t1.id = t2.t1_id;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
t1 1次, t2 1次
假设两张表，A和B，如果A作为驱动表，B作为被驱动表，那么，嵌套循环连接，就是先扫描A表，对A表的每一条记录，都扫描一遍B表；
而排序合并连接是 A表跟B表内的记录同时排序，然后连接; 哈希连接,类似排序合并，建立哈希表来连接。所以当返回少量记录的时候(OLTP系统常用，OLTP多用于电信、金融等系统)，嵌套循环连接更高效，而返回大量记录的时候，排序合并连接跟哈希连接更高效。
各类连接驱动顺序区别
1.嵌套循环连接
select /*+leading(t1) use_nl(t2)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 19;
select /*+leading(t2) use_nl(t1)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 19;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
t1表先访问：BUFFER 1014，t2只访问1次
t2表先访问：BUFFER 701K，t1被访问100000次
所以，嵌套循环连接要特别注意驱动表的顺序，小的结果集先访问，大的结果集后访问
2. 哈希连接
select /*+leading(t1) use_hash(t2)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 19;
select /*+leading(t2) use_hash(t1)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 19;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
t1表先访问：BUFFER 1013，Used_Mem 286K，时间0.04秒
t2表先访问：BUFFER 1013，Used_Mem 11MB，时间0.01秒
在哈希连接中，驱动表顺序也很重要
3.排序合并连接
select /*+leading(t1) use_merge(t2)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 19;
select /*+leading(t2) use_merge(t1)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 19;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
无论先访问t1还是先访问t2，效率都一样，执行时间，BUFFER,USED_MEM都一样，这表明，排序合并连接没有驱动表概念。
综上所述：嵌套循环连接和哈希连接有驱动顺序，驱动表的顺序不同将影响表连接的性能；而排序合并连接没有驱动的概念，无论哪张表在前都无妨。
嵌套循环连接不需要排序；哈希连接并不排序，消耗内存是用于建议HASH表；排序合并连接需要排序。关于哈希连接和排序合并连接，不要取多余的字段参与排序，因为选择的字段越少，消耗内存的尺寸就越小。
select /*+leading(t2) use_merge(t1)*/ * from t1, t2 where t1.id = t2.t1_id and t1.n = 19;
select /*+leading(t2) use_merge(t1)*/ t1.id from t1, t2 where t1.id = t2.t1_id and t1.n = 19;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
可以看出Used_Mem代表的内存消耗差别很大
各类连接限制场景
explain plan for
select /*+leadind(t1) use_hash(t2)*/ *
from t1, t2
where t1.id <> t2.t1_id and t1.n = 19;
select * from table(dbms_xplan.display);
没有按照HINT的提示走HASH连接，而是走了NL连接
同理，可以试验> 、 < 、like，HASH都不支持。
explain plan for
select /*+leadind(t1) use_merge(t2)*/ *
from t1, t2
where t1.id <> t2.t1_id and t1.n = 19;
select * from table(dbms_xplan.display);
排序合并连接不支持<>和Like，但是支持>、<
嵌套循环无限制
表连接与索引
select /*+leading(t1) use_nl(t2)*/ * from t1, t2 where t1.id = t2.t1_id;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
如果不使用HINT提示
select * from t1, t2 where t1.id = t2.t1_id;
select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
会显示走的是HASH连接，因为ORACLE认为HASH连接更合理，但是此时逻辑读,COST值都差不多
create index t1_n on t1(n);
再执行上述语句，看看扫描t1表时BUFFER的差别
create index t2_t1_id on t2(t1_id);
再执行上述语句，看看扫描t2表时BUFFER的差别
最适合NL连接的场景：
1. 两表关联返回的记录不多，最佳情况是驱动结果集仅返回1条或少量几条记录，而被驱动表仅匹配到1条或少量几条记录，这种情况，即便t1和t2表的记录奇大无比，也是非常迅速的。
2. 遇到一些不等值查询导致哈希和排序合并连接被限制使用，不得不使用NL连接。
3.最佳的索引建立位置：驱动表的限制条件所在列有索引，被驱动表的连接条件所在列有索引。原因在于，驱动表的限制条件建立索引是为了缩小扫描驱动表的时 间，如果在驱动表的连接条件建立索引就没有任何意义了，所有列关联到另一个表的所有列，等同于每一条记录都要关联。而驱动表的限制条件建立了索引，只快速 返回1条或几条，然后再等传递给t2表的t1_id列，一般情况下，t2表对应t1表返回的记录并不多，所以t2表的t1_id列建索引是有意义的。
哈希连接与索引
连接条件的索引对哈希连接和排序合并连接起不到传递作用，对于哈希连接和排序合并连接来说，索引的连接条件建立索引起不到快速检索的作用，但是限制条件列如果有适合的索引可以快速检索到少量记录，还是可以提升性能的。
两表关联等值查询，ORACLE一般倾向于走HASH连接，因为HASH连接算法本身比较高效，也比较先进。优化HASH连接可以通过调整PGA中的HASH_AREA_SIZE来优化，如果PGA是自动管理的，那么就增大PGA的大小。
排序合并连接与索引
排序合并连接上的连接条件虽然没有检索作用，但是有消除排序的作用，因此可以提高效率。
SQL>select /*+ordered use_merge(t2)*/
*
from t1, t2
where t1.id = t2.t1_id;
SQL>select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
create index idx_t1 on t1(id);
create index idx_t1_id on t2(t1_id); -- 上面建立过
SQL>select /*+ordered use_merge(t2)*/
*
from t1, t2
where t1.id = t2.t1_id;
SQL>select * from table(dbms_xplan.display_cursor(null, null, 'allstats last'));
建了两个索引，最终只用到了一个，这是ORACLE排序合并连接的BUG，在11G官方文档里有承认。
也可以通过增大PGA，优化排序合并连接
