考虑下列sql
select
/*+
leading(t1 t2 t3 t4)
use_hash(t2) use_hash(t3) use_hash(t4)
*/
count(t1.small_vc),
count(t2.small_vc),
count(t3.small_vc),
count(t4.small_vc)
from
t1,
t2,
t3,
t4
where
t2.id2 = t1.id1
and t3.id3 = t2.id2
and t4.id4 = t3.id3;
You have NOT defined a hash join completely until you have specified which rowsource should be used as the build table and which as the probe table – so every time you supplyy the use_hash() hint for a table, you should also supply the swap_join_inputs() hint or the no_swap_join_inputs() hint.Besides SWAP_JOIN_INPUTS hint only work on hash join
SWAP_JOIN_INPUTS 说明 连接当中谁做内建表
NO_SWAP_JOIN_INPUTS 说它做探测表
So my original query is suffering from incomplete hinting. There are three hash joins, so there should be three hints about swapping inputs or not. For example:
/*+
leading(t1 t2 t3 t4)
use_hash(t2) no_swap_join_inputs(t2)
use_hash(t3) no_swap_join_inputs(t3)
use_hash(t4) no_swap_join_inputs(t4)
*/
Since there are two possibilites for the swap/no_swap option, there are 2 x 2 x 2 = 8 possibilities in total for the execution plan – even though only one join order is examined. (If you check the 10053 trace file for this query you will find all the computation for these execution plans under one line that reads: Join order [1], there will not be a Join order[2])
use_hash(t2) no_swap_join_inputs(t2) use_hash(t3) no_swap_join_inputs(t3) use_hash(t4) no_swap_join_inputs(t4) -------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost | -------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | 24 | 11 | | 1 | SORT AGGREGATE | | 1 | 24 | | |* 2 | HASH JOIN | | 70 | 1680 | 11 | |* 3 | HASH JOIN | | 70 | 1260 | 8 | |* 4 | HASH JOIN | | 70 | 840 | 5 | | 5 | TABLE ACCESS FULL| T1 | 70 | 420 | 2 | | 6 | TABLE ACCESS FULL| T2 | 70 | 420 | 2 | | 7 | TABLE ACCESS FULL | T3 | 70 | 420 | 2 | | 8 | TABLE ACCESS FULL | T4 | 70 | 420 | 2 | -------------------------------------------------------------- use_hash(t2) swap_join_inputs(t2) use_hash(t3) no_swap_join_inputs(t3) use_hash(t4) no_swap_join_inputs(t4) -------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost | -------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | 24 | 11 | | 1 | SORT AGGREGATE | | 1 | 24 | | |* 2 | HASH JOIN | | 70 | 1680 | 11 | |* 3 | HASH JOIN | | 70 | 1260 | 8 | |* 4 | HASH JOIN | | 70 | 840 | 5 | | 5 | TABLE ACCESS FULL| T2 | 70 | 420 | 2 | | 6 | TABLE ACCESS FULL| T1 | 70 | 420 | 2 | | 7 | TABLE ACCESS FULL | T3 | 70 | 420 | 2 | | 8 | TABLE ACCESS FULL | T4 | 70 | 420 | 2 | -------------------------------------------------------------- use_hash(t2) no_swap_join_inputs(t2) use_hash(t3) swap_join_inputs(t3) use_hash(t4) no_swap_join_inputs(t4) -------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost | -------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | 24 | 11 | | 1 | SORT AGGREGATE | | 1 | 24 | | |* 2 | HASH JOIN | | 70 | 1680 | 11 | |* 3 | HASH JOIN | | 70 | 1260 | 8 | | 4 | TABLE ACCESS FULL | T3 | 70 | 420 | 2 | |* 5 | HASH JOIN | | 70 | 840 | 5 | | 6 | TABLE ACCESS FULL| T1 | 70 | 420 | 2 | | 7 | TABLE ACCESS FULL| T2 | 70 | 420 | 2 | | 8 | TABLE ACCESS FULL | T4 | 70 | 420 | 2 | -------------------------------------------------------------- use_hash(t2) swap_join_inputs(t2) use_hash(t3) swap_join_inputs(t3) use_hash(t4) no_swap_join_inputs(t4) -------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost | -------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | 24 | 11 | | 1 | SORT AGGREGATE | | 1 | 24 | | |* 2 | HASH JOIN | | 70 | 1680 | 11 | |* 3 | HASH JOIN | | 70 | 1260 | 8 | | 4 | TABLE ACCESS FULL | T3 | 70 | 420 | 2 | |* 5 | HASH JOIN | | 70 | 840 | 5 | | 6 | TABLE ACCESS FULL| T2 | 70 | 420 | 2 | | 7 | TABLE ACCESS FULL| T1 | 70 | 420 | 2 | | 8 | TABLE ACCESS FULL | T4 | 70 | 420 | 2 | -------------------------------------------------------------- use_hash(t2) no_swap_join_inputs(t2) use_hash(t3) no_swap_join_inputs(t3) use_hash(t4) swap_join_inputs(t4) -------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost | -------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | 24 | 11 | | 1 | SORT AGGREGATE | | 1 | 24 | | |* 2 | HASH JOIN | | 70 | 1680 | 11 | | 3 | TABLE ACCESS FULL | T4 | 70 | 420 | 2 | |* 4 | HASH JOIN | | 70 | 1260 | 8 | |* 5 | HASH JOIN | | 70 | 840 | 5 | | 6 | TABLE ACCESS FULL| T1 | 70 | 420 | 2 | | 7 | TABLE ACCESS FULL| T2 | 70 | 420 | 2 | | 8 | TABLE ACCESS FULL | T3 | 70 | 420 | 2 | -------------------------------------------------------------- use_hash(t2) swap_join_inputs(t2) use_hash(t3) no_swap_join_inputs(t3) use_hash(t4) swap_join_inputs(t4) -------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost | -------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | 24 | 11 | | 1 | SORT AGGREGATE | | 1 | 24 | | |* 2 | HASH JOIN | | 70 | 1680 | 11 | | 3 | TABLE ACCESS FULL | T4 | 70 | 420 | 2 | |* 4 | HASH JOIN | | 70 | 1260 | 8 | |* 5 | HASH JOIN | | 70 | 840 | 5 | | 6 | TABLE ACCESS FULL| T2 | 70 | 420 | 2 | | 7 | TABLE ACCESS FULL| T1 | 70 | 420 | 2 | | 8 | TABLE ACCESS FULL | T3 | 70 | 420 | 2 | -------------------------------------------------------------- use_hash(t2) no_swap_join_inputs(t2) use_hash(t3) swap_join_inputs(t3) use_hash(t4) swap_join_inputs(t4) -------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost | -------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | 24 | 11 | | 1 | SORT AGGREGATE | | 1 | 24 | | |* 2 | HASH JOIN | | 70 | 1680 | 11 | | 3 | TABLE ACCESS FULL | T4 | 70 | 420 | 2 | |* 4 | HASH JOIN | | 70 | 1260 | 8 | | 5 | TABLE ACCESS FULL | T3 | 70 | 420 | 2 | |* 6 | HASH JOIN | | 70 | 840 | 5 | | 7 | TABLE ACCESS FULL| T1 | 70 | 420 | 2 | | 8 | TABLE ACCESS FULL| T2 | 70 | 420 | 2 | -------------------------------------------------------------- use_hash(t2) swap_join_inputs(t2) use_hash(t3) swap_join_inputs(t3) use_hash(t4) swap_join_inputs(t4) -------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost | -------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | 24 | 11 | | 1 | SORT AGGREGATE | | 1 | 24 | | |* 2 | HASH JOIN | | 70 | 1680 | 11 | | 3 | TABLE ACCESS FULL | T4 | 70 | 420 | 2 | |* 4 | HASH JOIN | | 70 | 1260 | 8 | | 5 | TABLE ACCESS FULL | T3 | 70 | 420 | 2 | |* 6 | HASH JOIN | | 70 | 840 | 5 | | 7 | TABLE ACCESS FULL| T2 | 70 | 420 | 2 | | 8 | TABLE ACCESS FULL| T1 | 70 | 420 | 2 | --------------------------------------------------------------
Note the extreme change in shape and apparent order of tables in the plan. Despite this the join order really is t1 -> t2 -> t3 -> t4 in every case. I’ll give a quick description of the first and last plans to explain this.
First plan (no_swap all the way):
We build a hash table from t1 and probe it with t2 to create a result set
As this result set is generated we build a new hash table from it
As the result set completes we discard the hash table from t1
We probe the result set with t3 to create a second result set
As the second result set is generated we build a new hash table from it
As the second result set completes we discard the hash table from the first result set
We probe the second result set with t4 to create a third result set
As the third result set is generated we pass the results up to the aggregation step to count the output.
It is very obvious from this description that the tables are being joined in the order we dictated.
Last plan (swap all the way)
We build a hash table from t4
We build a hash table from t3
We build a hash table from t2
We pick a row from t1 and probe the t2 hash,
if the row “survives” we probe the t3 hash
if the row “survives” we probe the t4 hash
if the row “survives” we pass it up to the aggregation step to be counted.
With this description it becomes clear that, once again, the tables are being joined in the order we dictated.
Notice: the number of in-memory hash tables we build in the first case is two and, no matter how many tables are involved in this pattern, the number of in-memory hash tables will always be two.The actual size of the two hash tables is a little unpredictable, though, and, a very crude guideline, you might expect the size to grow as more tables are joined into the result set. In the last case the number of in-memory hash tables we build is “N-1″ (where N is the number of tables joined). We can predict the approximate size of each hash table because it is based on the data we expect to extract from the corresponding “real” table. If you have enough memory to hold all the hash tables in memory at once you will find that this join pattern is likely to be the fastest option you can produce.
Footnote: although a hash join is not fully specified unless you have also supplied an associated “swap/no swap” hint, the no_swap_join_inputs() hint didn’t become available until 10g !
参考至:http://www.cnblogs.com/princessd8251/articles/3535995.html
http://www.cnblogs.com/princessd8251/articles/3535995.html
本文原创，转载请注明出处、作者
如有错误，欢迎指正