Nested Loop Join 就是扫描一个表（外表），每读到该表中的一条记录，就去“扫描”另一张表（内表）找到满足条件的数据。这里的“扫描”可以是利用索引快速定位扫描，也可以是全表扫描。通常来说，全表扫描的性能是很差的，所以如果连接条件的列上没有索引，优化器一般就不会选择 Nested Loop Join。在 OceanBase 数据库执行计划中展示了是否能够利用索引快速定位扫描。

如下例所示，第一个计划对于内表的扫描是全表扫描，因为连接条件是 t1.c = t2.c，而 t2 没有在 c 上面的索引。第二个计划对于内表的扫描能够使用索引快速找到匹配的行，主要原因是因为连接条件是 t1.b = t2.b, 而且 t2 选择了创建在 b列上的索引 k1 作为访问路径，这样的话对于 t1 中的每一行的每个 b 值，t2 都可以根据索引快速找到满足条件的匹配行。

Nested Loop Join 可能会对内表进行多次全表扫描，因为每次扫描都需要从存储层重新迭代一次，这个代价相对是比较高的，所以 OceanBase 数据库支持对内表进行一次扫描并把结果物化在内存中，这样的话下次就可以直接在内存中扫描相关的数据，而不需要从存储层进行多次扫描。但是物化在内存中是有代价的，所以 OceanBase 数据库的优化器基于代价去判断是否需要物化内表。

Nested Loop Join 通常在内表行数比较少，而且外表在连接条件的列上有索引的时候会比较好，因为内表中的每一行都可以快速的使用索引定位到相对应的匹配的数据。

同时，OceanBase 数据库也提供了 hint 机制显示的去控制多表连接的时候选择 Nested Loop Join 连接算法，比如下面场景连接算法选择的是 Hash Join，而用户希望通过 Nested Loop Join，则可以使用上述hint 进行控制。

  1. OceanBase(TEST@TEST)>create table t1(c1 int, c2 int);
  2. Query OK, 0 rows affected (0.97 sec)
  4. OceanBase(TEST@TEST)>create table t2(c1 int, c2 int);
  5. Query OK, 0 rows affected (0.29 sec)
  7. OceanBase(TEST@TEST)>explain select * from t1,t2 where t1.c1 = t2.c1;
  8. | ========================================
  9. |ID|OPERATOR   |NAME|EST. ROWS|COST    |
  10. ----------------------------------------
  11. |0 |HASH JOIN  |    |98010000 |66774608|
  12. |1 | TABLE SCAN|T1  |100000   |68478   |
  13. |2 | TABLE SCAN|T2  |100000   |68478   |
  14. ========================================
  16. Outputs & filters: 
  17. -------------------------------------
  18.   0 - output([T1.C1], [T1.C2], [T2.C1], [T2.C2]), filter(nil), 
  19.       equal_conds([T1.C1 = T2.C1]), other_conds(nil)
  20.   1 - output([T1.C1], [T1.C2]), filter(nil), 
  21.       access([T1.C1], [T1.C2]), partitions(p0)
  22.   2 - output([T2.C1], [T2.C2]), filter(nil), 
  23.       access([T2.C1], [T2.C2]), partitions(p0)
  25. OceanBase(TEST@TEST)>explain select /*+use_nl(t1, c2)*/* from t1, t2 where t1.c1 = t2.c1;
  26. | ===============================================
  27. |ID|OPERATOR        |NAME|EST. ROWS|COST      |
  28. -----------------------------------------------
  29. |0 |NESTED-LOOP JOIN|    |98010000 |4595346207|
  30. |1 | TABLE SCAN     |T1  |100000   |68478     |
  31. |2 | MATERIAL       |    |100000   |243044    |
  32. |3 |  TABLE SCAN    |T2  |100000   |68478     |
  33. ===============================================
  35. Outputs & filters: 
  36. -------------------------------------
  37.   0 - output([T1.C1], [T1.C2], [T2.C1], [T2.C2]), filter(nil), 
  38.       conds([T1.C1 = T2.C1]), nl_params_(nil)
  39.   1 - output([T1.C1], [T1.C2]), filter(nil), 
  40.       access([T1.C1], [T1.C2]), partitions(p0)
  41.   2 - output([T2.C1], [T2.C2]), filter(nil)
  42.       access([T2.C1], [T2.C2]), partitions(p0)

Merge Join 首先会按照连接的字段对两个表进行 sort (如果内存空间不够，就需要进行外排)，然后开始扫描两张表进行merge。Merge 的过程会从每个表取一条记录开始匹配，如果符合关联条件，则放入结果集中；否则，将关联字段值较小的记录抛弃，从这条记录对应的表中取下一条记录继续进行匹配，直到整个循环结束。

通常来说，Merge join 比较适合两个输入表已经有序的情况，否则 Hash Join 会更加好。下图展示了两个 Merge join 的计划，其中第一个是需要排序的，第二个是不需要排序的(因为两种表都选择了 k1 这两个索引访问路径，这两个索引本身就是按照 b 排序的)。

同时，OceanBase 数据库也提供了 hint 机制 显示的去控制多表连接的时候选择 Merge Join 连接算法，比如下面场景连接算法选择的是 Hash Join，而用户希望通过 Merge Join，则可以使用上述 hint 进行控制。

  1. OceanBase(TEST@TEST)>create table t1(c1 int, c2 int);
  2. Query OK, 0 rows affected (0.97 sec)
  4. OceanBase(TEST@TEST)>create table t2(c1 int, c2 int);
  5. Query OK, 0 rows affected (0.29 sec)
  7. OceanBase(TEST@TEST)>explain select * from t1,t2 where t1.c1 = t2.c1;
  8. | ========================================
  9. |ID|OPERATOR   |NAME|EST. ROWS|COST    |
  10. ----------------------------------------
  11. |0 |HASH JOIN  |    |98010000 |66774608|
  12. |1 | TABLE SCAN|T1  |100000   |68478   |
  13. |2 | TABLE SCAN|T2  |100000   |68478   |
  14. ========================================
  16. Outputs & filters: 
  17. -------------------------------------
  18.   0 - output([T1.C1], [T1.C2], [T2.C1], [T2.C2]), filter(nil), 
  19.       equal_conds([T1.C1 = T2.C1]), other_conds(nil)
  20.   1 - output([T1.C1], [T1.C2]), filter(nil), 
  21.       access([T1.C1], [T1.C2]), partitions(p0)
  22.   2 - output([T2.C1], [T2.C2]), filter(nil), 
  23.       access([T2.C1], [T2.C2]), partitions(p0)
  25.  OceanBase(TEST@TEST)>explain select /*+use_merge(t1,t2)*/* from t1, t2 where t1.c1 = t2.c1;
  26.  | =========================================
  27. |ID|OPERATOR    |NAME|EST. ROWS|COST    |
  28. -----------------------------------------
  29. |0 |MERGE JOIN  |    |98010000 |67488837|
  30. |1 | SORT       |    |100000   |563680  |
  31. |2 |  TABLE SCAN|T1  |100000   |68478   |
  32. |3 | SORT       |    |100000   |563680  |
  33. |4 |  TABLE SCAN|T2  |100000   |68478   |
  34. =========================================
  36. Outputs & filters: 
  37. -------------------------------------
  38.   0 - output([T1.C1], [T1.C2], [T2.C1], [T2.C2]), filter(nil), 
  39.       equal_conds([T1.C1 = T2.C1]), other_conds(nil)
  40.   1 - output([T1.C1], [T1.C2]), filter(nil), sort_keys([T1.C1, ASC])
  41.   2 - output([T1.C1], [T1.C2]), filter(nil), 
  42.       access([T1.C1], [T1.C2]), partitions(p0)
  44.       access([T2.C1], [T2.C2]), partitions(p0)

Hash Join 就是用两个表中相对较小的表(通常称为 build table )根据连接条件创建 hash table，然后逐行扫描较大的表（通常称为 probe table）并通过探测 hash table 找到匹配的行。 如果 build table 非常大，构建的 hash table 无法在内存中容纳时，OceanBase 会分别将 build table 和 probe table 按照连接条件切分成多个分区（partition），每个 partition都包括一个独立的、成对匹配的 build table 和 probe table，这样就将一个大的 hash join 切分成多个独立、互相不影响的 hash join，每一个分区的 hash join 都能够在内存中完成。在绝大多数情况下，Hash Join 效率比其他 join 方式效率更高。

同时，OcenaBase 数据库也提供了hint 机制/*+ use_hash(table_name_list) */ 显示的去控制多表连接的时候选择 Hash Join 连接算法，比如下面场景连接算法选择的是 Merge Join，而用户希望通过 Hash Join，则可以使用上述 hint 进行控制。

  1. OceanBase(TEST@TEST)>create table t1(c1 int, c2 int, primary key(c1));
  2. Query OK, 0 rows affected (0.31 sec)
  4. OceanBase(TEST@TEST)>create table t2(c1 int, c2 int, primary key(c1));
  5. Query OK, 0 rows affected (0.33 sec)
  7. OceanBase(TEST@TEST)>explain select * from t1, t2 where t1.c1 = t2.c1;
  8. | ======================================
  9. |ID|OPERATOR   |NAME|EST. ROWS|COST  |
  10. --------------------------------------
  11. |0 |MERGE JOIN |    |100001   |219005|
  12. |1 | TABLE SCAN|T1  |100000   |61860 |
  13. |2 | TABLE SCAN|T2  |100000   |61860 |
  14. ======================================
  16. Outputs & filters: 
  17. -------------------------------------
  18.   0 - output([T1.C1], [T1.C2], [T2.C1], [T2.C2]), filter(nil), 
  19.       equal_conds([T1.C1 = T2.C1]), other_conds(nil)
  20.   1 - output([T1.C1], [T1.C2]), filter(nil), 
  21.       access([T1.C1], [T1.C2]), partitions(p0)
  22.   2 - output([T2.C1], [T2.C2]), filter(nil), 
  23.       access([T2.C1], [T2.C2]), partitions(p0)
  25. OceanBase(TEST@TEST)>explain select /*+use_hash(t1, t2)*/ * from t1, t2 where t1.c1 = t2.c1;
  26.   | ======================================
  27. |ID|OPERATOR   |NAME|EST. ROWS|COST  |
  28. --------------------------------------
  29. |0 |HASH JOIN  |    |100001   |495180|
  30. |1 | TABLE SCAN|T1  |100000   |61860 |
  31. |2 | TABLE SCAN|T2  |100000   |61860 |
  32. ======================================
  34. Outputs & filters: 
  35. -------------------------------------
  36.   0 - output([T1.C1], [T1.C2], [T2.C1], [T2.C2]), filter(nil), 
  37.       equal_conds([T1.C1 = T2.C1]), other_conds(nil)
  38.   1 - output([T1.C1], [T1.C2]), filter(nil), 
  39.       access([T1.C1], [T1.C2]), partitions(p0)
  40.   2 - output([T2.C1], [T2.C2]), filter(nil), 
  41.       access([T2.C1], [T2.C2]), partitions(p0)