hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity
Files
b5ac0c7bf60eba1d57b767cbbd650f7dbc514a31
oceanbase/unittest/sql/optimizer/test_optimizer_outline.result
wangzelin.wzl 93a1074b0c patch 4.0
2022-10-24 17:57:12 +08:00

3987 lines
161 KiB
Plaintext
Raw Blame History

*************** Case 1 ***************
SQL: select * from t4 where c1 in (select c1 from t1);
==========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------------
|0 |PX COORDINATOR | |90 |697 |
|1 | EXCHANGE OUT DISTR |:EX10001|90 |682 |
|2 | HASH JOIN | |90 |649 |
|3 | EXCHANGE IN DISTR | |100 |118 |
|4 | EXCHANGE OUT DISTR (PKEY)|:EX10000|100 |105 |
|5 | TABLE SCAN |t4 |100 |78 |
|6 | PX PARTITION ITERATOR | |500 |387 |
|7 | TABLE SCAN |t1 |500 |387 |
==========================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t4.c1, t4.c2, t4.c3)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t4.c1, t4.c2, t4.c3)]), filter(nil), dop=1
2 - output([t4.c1], [t4.c2], [t4.c3]), filter(nil),
equal_conds([t4.c1 = t1.c1]), other_conds(nil)
3 - output([t4.c1], [t4.c2], [t4.c3]), filter(nil)
4 - (#keys=1, [t4.c1]), output([t4.c1], [t4.c2], [t4.c3]), filter(nil), is_single, dop=1
5 - output([t4.c1], [t4.c2], [t4.c3]), filter(nil),
access([t4.c1], [t4.c2], [t4.c3]), partitions(p0)
6 - output([t1.c1]), filter(nil)
7 - output([t1.c1]), filter(nil),
access([t1.c1]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$FE336D0E" ("opt"."t4"@"SEL$1" "opt"."t1"@"SEL$2"))
USE_HASH(@"SEL$FE336D0E" "opt"."t1"@"SEL$2")
PQ_DISTRIBUTE(@"SEL$FE336D0E" "opt"."t1"@"SEL$2" PARTITION NONE)
FULL(@"SEL$FE336D0E" "opt"."t4"@"SEL$1")
FULL(@"SEL$FE336D0E" "opt"."t1"@"SEL$2")
UNNEST(@"SEL$2")
SEMI_TO_INNER(@"SEL$6FCAE2AA" "VIEW1")
MERGE(@"SEL$2" > "SEL$E5385516")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t4"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_HASH(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) PARTITION NONE)
FULL(@"SEL$1" "opt"."t4"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 1(end) **************
*************** Case 2 ***************
SQL: select /*+INDEX(@"SEL$2" "opt.t4"@"SEL$2" "idx_t4_c3")*/* from t1 where c1 in (select c1 from t4);
===============================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
---------------------------------------------------------------
|0 |PX COORDINATOR | |10 |176 |
|1 | EXCHANGE OUT DISTR |:EX10001 |10 |175 |
|2 | NESTED-LOOP JOIN | |10 |172 |
|3 | EXCHANGE IN DISTR | |10 |106 |
|4 | EXCHANGE OUT DISTR (PKEY)|:EX10000 |10 |105 |
|5 | SUBPLAN SCAN |VIEW2 |10 |104 |
|6 | HASH DISTINCT | |10 |104 |
|7 | TABLE SCAN |t4(idx_t4_c3)|100 |78 |
|8 | PX PARTITION ITERATOR | |1 |29 |
|9 | TABLE GET |t1 |1 |29 |
===============================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil),
conds(nil), nl_params_([VIEW2.VIEW1.c1])
3 - output([PARTITION_ID], [VIEW2.VIEW1.c1]), filter(nil)
4 - (#keys=1, [VIEW2.VIEW1.c1]), output([PARTITION_ID], [VIEW2.VIEW1.c1]), filter(nil), is_single, dop=1
5 - output([VIEW2.VIEW1.c1]), filter(nil),
access([VIEW2.VIEW1.c1])
6 - output([t4.c1]), filter(nil),
distinct([t4.c1])
7 - output([t4.c1]), filter(nil),
access([t4.c1]), partitions(p0)
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$E5385516" ("VIEW2"@"SEL$6FCAE2AA" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$E5385516" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$E5385516" "opt"."t1"@"SEL$1" PARTITION NONE)
USE_HASH_DISTINCT(@"SEL$8A1445BC")
INDEX(@"SEL$8A1445BC" "opt"."t4"@"SEL$2" "idx_t4_c3")
FULL(@"SEL$E5385516" "opt"."t1"@"SEL$1")
UNNEST(@"SEL$2")
SEMI_TO_INNER(@"SEL$6FCAE2AA" "VIEW1")
MERGE(@"SEL$2" < "SEL$7BD09C5F")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("VIEW2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) PARTITION NONE)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
INDEX(@"SEL$2" "opt"."t4"@"SEL$2" "idx_t4_c3")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 2(end) **************
*************** Case 3 ***************
SQL: select * from t1 where c1 in (select c1 from t4);
==========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------------
|0 |PX COORDINATOR | |10 |154 |
|1 | EXCHANGE OUT DISTR |:EX10001|10 |153 |
|2 | NESTED-LOOP JOIN | |10 |150 |
|3 | EXCHANGE IN DISTR | |10 |84 |
|4 | EXCHANGE OUT DISTR (PKEY)|:EX10000|10 |83 |
|5 | SUBPLAN SCAN |VIEW2 |10 |82 |
|6 | MERGE DISTINCT | |10 |82 |
|7 | TABLE SCAN |t4 |100 |78 |
|8 | PX PARTITION ITERATOR | |1 |29 |
|9 | TABLE GET |t1 |1 |29 |
==========================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil),
conds(nil), nl_params_([VIEW2.VIEW1.c1])
3 - output([PARTITION_ID], [VIEW2.VIEW1.c1]), filter(nil)
4 - (#keys=1, [VIEW2.VIEW1.c1]), output([PARTITION_ID], [VIEW2.VIEW1.c1]), filter(nil), is_single, dop=1
5 - output([VIEW2.VIEW1.c1]), filter(nil),
access([VIEW2.VIEW1.c1])
6 - output([t4.c1]), filter(nil),
distinct([t4.c1])
7 - output([t4.c1]), filter(nil),
access([t4.c1]), partitions(p0)
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$E5385516" ("VIEW2"@"SEL$6FCAE2AA" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$E5385516" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$E5385516" "opt"."t1"@"SEL$1" PARTITION NONE)
FULL(@"SEL$8A1445BC" "opt"."t4"@"SEL$2")
FULL(@"SEL$E5385516" "opt"."t1"@"SEL$1")
UNNEST(@"SEL$2")
SEMI_TO_INNER(@"SEL$6FCAE2AA" "VIEW1")
MERGE(@"SEL$2" < "SEL$7BD09C5F")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("VIEW2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) PARTITION NONE)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$2" "opt"."t4"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 3(end) **************
*************** Case 4 ***************
SQL: select /*+ BEGIN_OUTLINE_DATA INDEX(@"SEL$1" "opt.t4"@"SEL$1" "idx_t4_c2_c3") INDEX(@"SEL$2" "opt.t1"@"SEL$2" "idx_t1_c2") END_OUTLINE_DATA */* from t4 where c1 in (select max(c1) from t1);
====================================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------------------------------
|0 |NESTED-LOOP JOIN | |9 |482 |
|1 | SUBPLAN SCAN |VIEW1 |1 |397 |
|2 | SCALAR GROUP BY | |1 |397 |
|3 | SUBPLAN SCAN |VIEW2 |1 |397 |
|4 | LIMIT | |1 |397 |
|5 | PX COORDINATOR MERGE SORT | |1 |397 |
|6 | EXCHANGE OUT DISTR |:EX10000 |1 |397 |
|7 | TOP-N SORT | |1 |397 |
|8 | PX PARTITION ITERATOR | |500 |387 |
|9 | TABLE SCAN |t1(idx_t1_c2) |500 |387 |
|10| TABLE SCAN |t4(idx_t4_c2_c3)|100 |78 |
====================================================================
Outputs & filters:
-------------------------------------
0 - output([t4.c1], [t4.c2], [t4.c3]), filter(nil),
conds([t4.c1 = VIEW1.max(c1)]), nl_params_(nil)
1 - output([VIEW1.max(c1)]), filter(nil),
access([VIEW1.max(c1)])
2 - output([T_FUN_MAX(VIEW2.t1.c1)]), filter(nil),
group(nil), agg_func([T_FUN_MAX(VIEW2.t1.c1)])
3 - output([VIEW2.t1.c1]), filter(nil),
access([VIEW2.t1.c1])
4 - output([t1.c1]), filter(nil), limit(1), offset(nil)
5 - output([t1.c1]), filter(nil), sort_keys([t1.c1, DESC])
6 - output([t1.c1]), filter(nil), dop=1
7 - output([t1.c1]), filter(nil), sort_keys([t1.c1, DESC]), topn(1)
8 - output([t1.c1]), filter(nil)
9 - output([t1.c1]), filter(nil),
access([t1.c1]), partitions(p[0-4])
10 - output([t4.c1], [t4.c2], [t4.c3]), filter(nil),
access([t4.c1], [t4.c2], [t4.c3]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$E5385516" ("VIEW1"@"SEL$1" "opt"."t4"@"SEL$1"))
USE_NL(@"SEL$E5385516" "opt"."t4"@"SEL$1")
INDEX(@"SEL$7E047C3E" "opt"."t1"@"SEL$2" "idx_t1_c2")
INDEX(@"SEL$E5385516" "opt"."t4"@"SEL$1" "idx_t4_c2_c3")
UNNEST(@"SEL$2")
SEMI_TO_INNER(@"SEL$6FCAE2AA" "VIEW1")
FAST_MINMAX(@"SEL$2")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("VIEW1"@"SEL$1" "opt.t4"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t4"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t4"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t4"@"SEL$1" ))
INDEX(@"SEL$3" "opt"."t1"@"SEL$3" "idx_t1_c2")
INDEX(@"SEL$1" "opt"."t4"@"SEL$1" "idx_t4_c2_c3")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 4(end) **************
*************** Case 5 ***************
SQL: select * from t4 where c1 in (select max(c1) from t1);
===============================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
---------------------------------------------------------------
|0 |NESTED-LOOP JOIN | |9 |235 |
|1 | SUBPLAN SCAN |VIEW1 |1 |228 |
|2 | SCALAR GROUP BY | |1 |228 |
|3 | SUBPLAN SCAN |VIEW2 |1 |228 |
|4 | LIMIT | |1 |228 |
|5 | PX COORDINATOR MERGE SORT | |1 |228 |
|6 | EXCHANGE OUT DISTR |:EX10000 |1 |228 |
|7 | TOP-N SORT | |1 |227 |
|8 | PX PARTITION ITERATOR | |1 |227 |
|9 | TABLE SCAN |t1(Reverse)|1 |227 |
|10| TABLE SCAN |t4 |9 |5 |
===============================================================
Outputs & filters:
-------------------------------------
0 - output([t4.c1], [t4.c2], [t4.c3]), filter(nil),
conds(nil), nl_params_([VIEW1.max(c1)])
1 - output([VIEW1.max(c1)]), filter(nil),
access([VIEW1.max(c1)])
2 - output([T_FUN_MAX(VIEW2.t1.c1)]), filter(nil),
group(nil), agg_func([T_FUN_MAX(VIEW2.t1.c1)])
3 - output([VIEW2.t1.c1]), filter(nil),
access([VIEW2.t1.c1])
4 - output([t1.c1]), filter(nil), limit(1), offset(nil)
5 - output([t1.c1]), filter(nil), sort_keys([t1.c1, DESC])
6 - output([t1.c1]), filter(nil), dop=1
7 - output([t1.c1]), filter(nil), sort_keys([t1.c1, DESC]), topn(1), local merge sort
8 - output([t1.c1]), filter(nil)
9 - output([t1.c1]), filter(nil),
access([t1.c1]), partitions(p[0-4]),
limit(1), offset(nil)
10 - output([t4.c1], [t4.c2], [t4.c3]), filter(nil),
access([t4.c1], [t4.c2], [t4.c3]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$E5385516" ("VIEW1"@"SEL$1" "opt"."t4"@"SEL$1"))
USE_NL(@"SEL$E5385516" "opt"."t4"@"SEL$1")
FULL(@"SEL$7E047C3E" "opt"."t1"@"SEL$2")
FULL(@"SEL$E5385516" "opt"."t4"@"SEL$1")
UNNEST(@"SEL$2")
SEMI_TO_INNER(@"SEL$6FCAE2AA" "VIEW1")
FAST_MINMAX(@"SEL$2")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("VIEW1"@"SEL$1" "opt.t4"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t4"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t4"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t4"@"SEL$1" ))
FULL(@"SEL$3" "opt"."t1"@"SEL$3")
FULL(@"SEL$1" "opt"."t4"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 5(end) **************
*************** Case 6 ***************
SQL: select /*+ BEGIN_OUTLINE_DATA USE_NL(@"SEL$3" "opt.t2"@"SEL$3") LEADING(@"SEL$3" "opt.t1"@"SEL$3" "opt.t2"@"SEL$3") END_OUTLINE_DATA */* from t1 where c1 in (select * from (select max(t1.c1) from t1, t2) as tt);
===============================================================
|ID|OPERATOR |NAME |EST. ROWS|COST |
---------------------------------------------------------------
|0 |PX COORDINATOR | |1 |18958|
|1 | EXCHANGE OUT DISTR |:EX10003|1 |18958|
|2 | NESTED-LOOP JOIN | |1 |18958|
|3 | EXCHANGE IN DISTR | |1 |18951|
|4 | EXCHANGE OUT DISTR (PKEY) |:EX10002|1 |18951|
|5 | SUBPLAN SCAN |VIEW1 |1 |18951|
|6 | SCALAR GROUP BY | |1 |18951|
|7 | NESTED-LOOP JOIN CARTESIAN| |150000 |13640|
|8 | EXCHANGE IN DISTR | |500 |466 |
|9 | EXCHANGE OUT DISTR |:EX10000|500 |439 |
|10| PX PARTITION ITERATOR | |500 |387 |
|11| TABLE SCAN |t1 |500 |387 |
|12| MATERIAL | |300 |281 |
|13| EXCHANGE IN DISTR | |300 |280 |
|14| EXCHANGE OUT DISTR |:EX10001|300 |263 |
|15| PX PARTITION ITERATOR | |300 |233 |
|16| TABLE SCAN |t2 |300 |233 |
|17| PX PARTITION ITERATOR | |1 |29 |
|18| TABLE GET |t1 |1 |29 |
===============================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil),
conds(nil), nl_params_([VIEW1.max(t1.c1)])
3 - output([PARTITION_ID], [VIEW1.max(t1.c1)]), filter(nil)
4 - (#keys=1, [VIEW1.max(t1.c1)]), output([PARTITION_ID], [VIEW1.max(t1.c1)]), filter(nil), is_single, dop=1
5 - output([VIEW1.max(t1.c1)]), filter(nil),
access([VIEW1.max(t1.c1)])
6 - output([T_FUN_MAX(t1.c1)]), filter(nil),
group(nil), agg_func([T_FUN_MAX(t1.c1)])
7 - output([t1.c1]), filter(nil),
conds(nil), nl_params_(nil)
8 - output([t1.c1]), filter(nil)
9 - output([t1.c1]), filter(nil), dop=1
10 - output([t1.c1]), filter(nil)
11 - output([t1.c1]), filter(nil),
access([t1.c1]), partitions(p[0-4])
12 - output(nil), filter(nil)
13 - output(nil), filter(nil)
14 - output(nil), filter(nil), dop=1
15 - output(nil), filter(nil)
16 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
17 - output([t1.c1], [t1.c2]), filter(nil)
18 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$E5385516" ("VIEW1"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$E5385516" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$E5385516" "opt"."t1"@"SEL$1" PARTITION NONE)
LEADING(@"SEL$1AE1580B" ("opt"."t1"@"SEL$3" "opt"."t2"@"SEL$3"))
USE_NL(@"SEL$1AE1580B" "opt"."t2"@"SEL$3")
PQ_DISTRIBUTE(@"SEL$1AE1580B" "opt"."t2"@"SEL$3" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1AE1580B" "opt"."t2"@"SEL$3")
FULL(@"SEL$1AE1580B" "opt"."t1"@"SEL$3")
FULL(@"SEL$1AE1580B" "opt"."t2"@"SEL$3")
FULL(@"SEL$E5385516" "opt"."t1"@"SEL$1")
UNNEST(@"SEL$2")
SEMI_TO_INNER(@"SEL$6FCAE2AA" "VIEW1")
MERGE(@"SEL$3" < "SEL$2")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("VIEW1"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) PARTITION NONE)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
LEADING(@"SEL$3" ("opt.t1"@"SEL$3" "opt.t2"@"SEL$3" ))
USE_NL(@"SEL$3" ("opt.t2"@"SEL$3" ))
PQ_DISTRIBUTE(@"SEL$3" ("opt.t2"@"SEL$3" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$3" ("opt.t2"@"SEL$3" ))
FULL(@"SEL$3" "opt"."t1"@"SEL$3")
FULL(@"SEL$3" "opt"."t2"@"SEL$3")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 6(end) **************
*************** Case 7 ***************
SQL: select /*+index(t4 idx_t4_c3)*/ * from t4 where c1 = 1;
============================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------
|0 |TABLE SCAN|t4(idx_t4_c3)|9 |79 |
============================================
Outputs & filters:
-------------------------------------
0 - output([t4.c1], [t4.c2], [t4.c3]), filter([t4.c1 = ?]),
access([t4.c1], [t4.c2], [t4.c3]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
INDEX(@"SEL$1" "opt"."t4"@"SEL$1" "idx_t4_c3")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 7(end) **************
*************** Case 8 ***************
SQL: select /*+ BEGIN_OUTLINE_DATA INDEX(@"SEL$1" "opt.t4"@"SEL$1" "idx_t4_c3") END_OUTLINE_DATA */ * from t4 where c1 = 1;
============================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------
|0 |TABLE SCAN|t4(idx_t4_c3)|9 |79 |
============================================
Outputs & filters:
-------------------------------------
0 - output([t4.c1], [t4.c2], [t4.c3]), filter([t4.c1 = ?]),
access([t4.c1], [t4.c2], [t4.c3]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
INDEX(@"SEL$1" "opt"."t4"@"SEL$1" "idx_t4_c3")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 8(end) **************
*************** Case 9 ***************
SQL: select /*+full(t4)*/ * from t4 where c2 = 1;
===================================
|ID|OPERATOR |NAME|EST. ROWS|COST|
-----------------------------------
|0 |TABLE SCAN|t4 |9 |79 |
===================================
Outputs & filters:
-------------------------------------
0 - output([t4.c1], [t4.c2], [t4.c3]), filter([t4.c2 = ?]),
access([t4.c1], [t4.c2], [t4.c3]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t4"@"SEL$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 9(end) **************
*************** Case 10 ***************
SQL: select /*+ BEGIN_OUTLINE_DATA FULL(@"SEL$1" "opt.t4"@"SEL$1") END_OUTLINE_DATA */ * from t4 where c2 = 1;
===================================
|ID|OPERATOR |NAME|EST. ROWS|COST|
-----------------------------------
|0 |TABLE SCAN|t4 |9 |79 |
===================================
Outputs & filters:
-------------------------------------
0 - output([t4.c1], [t4.c2], [t4.c3]), filter([t4.c2 = ?]),
access([t4.c1], [t4.c2], [t4.c3]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t4"@"SEL$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 10(end) **************
*************** Case 11 ***************
SQL: select * from t1,t2;
=======================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN| |150000 |8729|
|1 | PX COORDINATOR | |300 |464 |
|2 | EXCHANGE OUT DISTR |:EX10000|300 |391 |
|3 | PX PARTITION ITERATOR | |300 |233 |
|4 | TABLE SCAN |t2 |300 |233 |
|5 | MATERIAL | |500 |531 |
|6 | PX COORDINATOR | |500 |528 |
|7 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|8 | PX PARTITION ITERATOR | |500 |387 |
|9 | TABLE SCAN |t1 |500 |387 |
=======================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
2 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
5 - output([t1.c1], [t1.c2]), filter(nil)
6 - output([t1.c1], [t1.c2]), filter(nil)
7 - output([t1.c1], [t1.c2]), filter(nil), dop=1
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 11(end) **************
*************** Case 12 ***************
SQL: select * from t1,t2 where t1.c1=t2.c1;
==========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------------
|0 |PX COORDINATOR | |300 |1260|
|1 | EXCHANGE OUT DISTR |:EX10001|300 |1164|
|2 | HASH JOIN | |300 |954 |
|3 | EXCHANGE IN DISTR | |500 |528 |
|4 | EXCHANGE OUT DISTR (PKEY)|:EX10000|500 |481 |
|5 | PX PARTITION ITERATOR | |500 |387 |
|6 | TABLE SCAN |t1 |500 |387 |
|7 | PX PARTITION ITERATOR | |300 |233 |
|8 | TABLE SCAN |t2 |300 |233 |
==========================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2, t2.c1, t2.c2, t2.c3)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2, t2.c1, t2.c2, t2.c3)]), filter(nil), dop=1
2 - output([t1.c1], [t2.c1], [t1.c2], [t2.c2], [t2.c3]), filter(nil),
equal_conds([t1.c1 = t2.c1]), other_conds(nil)
3 - output([t1.c1], [t1.c2]), filter(nil)
4 - (#keys=1, [t1.c1]), output([t1.c1], [t1.c2]), filter(nil), dop=1
5 - output([t1.c1], [t1.c2]), filter(nil)
6 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
7 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
8 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("opt"."t1"@"SEL$1" "opt"."t2"@"SEL$1"))
USE_HASH(@"SEL$1" "opt"."t2"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t2"@"SEL$1" PARTITION NONE)
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_HASH(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) NONE PARTITION)
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 12(end) **************
*************** Case 13 ***************
SQL: select * from t1,(select count(*) from t2) as tt;
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |500 |533 |
|1 | SUBPLAN SCAN |tt |1 |244 |
|2 | SCALAR GROUP BY | |1 |244 |
|3 | PX COORDINATOR | |1 |243 |
|4 | EXCHANGE OUT DISTR |:EX10000|1 |243 |
|5 | MERGE GROUP BY | |1 |243 |
|6 | PX PARTITION ITERATOR| |300 |233 |
|7 | TABLE SCAN |t2 |300 |233 |
|8 | PX COORDINATOR | |500 |528 |
|9 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|10| PX PARTITION ITERATOR | |500 |387 |
|11| TABLE SCAN |t1 |500 |387 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [tt.count(*)]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([tt.count(*)]), filter(nil),
access([tt.count(*)])
2 - output([T_FUN_COUNT_SUM(T_FUN_COUNT(*))]), filter(nil),
group(nil), agg_func([T_FUN_COUNT_SUM(T_FUN_COUNT(*))])
3 - output([T_FUN_COUNT(*)]), filter(nil)
4 - output([T_FUN_COUNT(*)]), filter(nil), dop=1
5 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
6 - output(nil), filter(nil)
7 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil), dop=1
10 - output([t1.c1], [t1.c2]), filter(nil)
11 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
GBY_PUSHDOWN(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
NO_USE_HASH_AGGREGATION(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 13(end) **************
*************** Case 14 ***************
SQL: select * from (select count(*) from t2) as tt,t1,t9 where t9.c1=t1.c1;
===========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-----------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |100 |492 |
|1 | SUBPLAN SCAN |tt |1 |244 |
|2 | SCALAR GROUP BY | |1 |244 |
|3 | PX COORDINATOR | |1 |243 |
|4 | EXCHANGE OUT DISTR |:EX10000|1 |243 |
|5 | MERGE GROUP BY | |1 |243 |
|6 | PX PARTITION ITERATOR | |300 |233 |
|7 | TABLE SCAN |t2 |300 |233 |
|8 | PX COORDINATOR | |100 |714 |
|9 | EXCHANGE OUT DISTR |:EX20001|100 |694 |
|10| HASH JOIN | |100 |649 |
|11| EXCHANGE IN DISTR | |100 |118 |
|12| EXCHANGE OUT DISTR (PKEY)|:EX20000|100 |105 |
|13| TABLE SCAN |t9 |100 |78 |
|14| PX PARTITION ITERATOR | |500 |387 |
|15| TABLE SCAN |t1 |500 |387 |
===========================================================
Outputs & filters:
-------------------------------------
0 - output([tt.count(*)], [t1.c1], [t1.c2], [t9.c1], [t9.c2], [t9.c3]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([tt.count(*)]), filter(nil),
access([tt.count(*)])
2 - output([T_FUN_COUNT_SUM(T_FUN_COUNT(*))]), filter(nil),
group(nil), agg_func([T_FUN_COUNT_SUM(T_FUN_COUNT(*))])
3 - output([T_FUN_COUNT(*)]), filter(nil)
4 - output([T_FUN_COUNT(*)]), filter(nil), dop=1
5 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
6 - output(nil), filter(nil)
7 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
8 - output([t1.c1], [t1.c2], [t9.c1], [t9.c2], [t9.c3]), filter(nil)
9 - output([t1.c1], [t1.c2], [t9.c1], [t9.c2], [t9.c3]), filter(nil), dop=1
10 - output([t1.c1], [t1.c2], [t9.c1], [t9.c2], [t9.c3]), filter(nil),
equal_conds([t9.c1 = t1.c1]), other_conds(nil)
11 - output([t9.c1], [t9.c2], [t9.c3]), filter(nil)
12 - (#keys=1, [t9.c1]), output([t9.c1], [t9.c2], [t9.c3]), filter(nil), is_single, dop=1
13 - output([t9.c1], [t9.c2], [t9.c3]), filter(nil),
access([t9.c1], [t9.c2], [t9.c3]), partitions(p0)
14 - output([t1.c1], [t1.c2]), filter(nil)
15 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("tt"@"SEL$1" ("opt"."t9"@"SEL$1" "opt"."t1"@"SEL$1")))
USE_NL(@"SEL$1" ("opt"."t1"@"SEL$1" "opt"."t9"@"SEL$1"))
PQ_DISTRIBUTE(@"SEL$1" ("opt"."t1"@"SEL$1" "opt"."t9"@"SEL$1") LOCAL LOCAL)
GBY_PUSHDOWN(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
USE_HASH(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" PARTITION NONE)
FULL(@"SEL$1" "opt"."t9"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("tt"@"SEL$1" ("opt.t9"@"SEL$1" "opt.t1"@"SEL$1" )))
USE_NL(@"SEL$1" ("opt.t9"@"SEL$1" "opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t9"@"SEL$1" "opt.t1"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t9"@"SEL$1" "opt.t1"@"SEL$1" ))
NO_USE_HASH_AGGREGATION(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
USE_HASH(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) PARTITION NONE)
FULL(@"SEL$1" "opt"."t9"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 14(end) **************
*************** Case 15 ***************
SQL: select * from (select count(*) from t2, t10) as tt,t1,t9 where t9.c1=t1.c1;
===========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-----------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |100 |7998|
|1 | SUBPLAN SCAN |tt |1 |7750|
|2 | SCALAR GROUP BY | |1 |7750|
|3 | NESTED-LOOP JOIN CARTESIAN | |60000 |5625|
|4 | PX COORDINATOR | |200 |187 |
|5 | EXCHANGE OUT DISTR |:EX10000|200 |176 |
|6 | PX PARTITION ITERATOR | |200 |155 |
|7 | TABLE SCAN |t10 |200 |155 |
|8 | MATERIAL | |300 |281 |
|9 | PX COORDINATOR | |300 |280 |
|10| EXCHANGE OUT DISTR |:EX20000|300 |263 |
|11| PX PARTITION ITERATOR | |300 |233 |
|12| TABLE SCAN |t2 |300 |233 |
|13| PX COORDINATOR | |100 |714 |
|14| EXCHANGE OUT DISTR |:EX30001|100 |694 |
|15| HASH JOIN | |100 |649 |
|16| EXCHANGE IN DISTR | |100 |118 |
|17| EXCHANGE OUT DISTR (PKEY)|:EX30000|100 |105 |
|18| TABLE SCAN |t9 |100 |78 |
|19| PX PARTITION ITERATOR | |500 |387 |
|20| TABLE SCAN |t1 |500 |387 |
===========================================================
Outputs & filters:
-------------------------------------
0 - output([tt.count(*)], [t1.c1], [t1.c2], [t9.c1], [t9.c2], [t9.c3]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([tt.count(*)]), filter(nil),
access([tt.count(*)])
2 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
3 - output(nil), filter(nil),
conds(nil), nl_params_(nil)
4 - output(nil), filter(nil)
5 - output(nil), filter(nil), dop=1
6 - output(nil), filter(nil)
7 - output(nil), filter(nil),
access([t10.c1]), partitions(p[0-1])
8 - output(nil), filter(nil)
9 - output(nil), filter(nil)
10 - output(nil), filter(nil), dop=1
11 - output(nil), filter(nil)
12 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
13 - output([t1.c1], [t1.c2], [t9.c1], [t9.c2], [t9.c3]), filter(nil)
14 - output([t1.c1], [t1.c2], [t9.c1], [t9.c2], [t9.c3]), filter(nil), dop=1
15 - output([t1.c1], [t1.c2], [t9.c1], [t9.c2], [t9.c3]), filter(nil),
equal_conds([t9.c1 = t1.c1]), other_conds(nil)
16 - output([t9.c1], [t9.c2], [t9.c3]), filter(nil)
17 - (#keys=1, [t9.c1]), output([t9.c1], [t9.c2], [t9.c3]), filter(nil), is_single, dop=1
18 - output([t9.c1], [t9.c2], [t9.c3]), filter(nil),
access([t9.c1], [t9.c2], [t9.c3]), partitions(p0)
19 - output([t1.c1], [t1.c2]), filter(nil)
20 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("tt"@"SEL$1" ("opt"."t9"@"SEL$1" "opt"."t1"@"SEL$1")))
USE_NL(@"SEL$1" ("opt"."t1"@"SEL$1" "opt"."t9"@"SEL$1"))
PQ_DISTRIBUTE(@"SEL$1" ("opt"."t1"@"SEL$1" "opt"."t9"@"SEL$1") LOCAL LOCAL)
LEADING(@"SEL$2" ("opt"."t10"@"SEL$2" "opt"."t2"@"SEL$2"))
USE_NL(@"SEL$2" "opt"."t2"@"SEL$2")
PQ_DISTRIBUTE(@"SEL$2" "opt"."t2"@"SEL$2" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$2" "opt"."t10"@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
USE_HASH(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" PARTITION NONE)
FULL(@"SEL$1" "opt"."t9"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("tt"@"SEL$1" ("opt.t9"@"SEL$1" "opt.t1"@"SEL$1" )))
USE_NL(@"SEL$1" ("opt.t9"@"SEL$1" "opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t9"@"SEL$1" "opt.t1"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t9"@"SEL$1" "opt.t1"@"SEL$1" ))
LEADING(@"SEL$2" ("opt.t10"@"SEL$2" "opt.t2"@"SEL$2" ))
USE_NL(@"SEL$2" ("opt.t2"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("opt.t2"@"SEL$2" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" ("opt.t2"@"SEL$2" ))
FULL(@"SEL$2" "opt"."t10"@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
USE_HASH(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) PARTITION NONE)
FULL(@"SEL$1" "opt"."t9"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 15(end) **************
*************** Case 16 ***************
SQL: select * from t1,t2,t9;
==========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST |
----------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |15000000 |777165|
|1 | NESTED-LOOP JOIN CARTESIAN| |30000 |3124 |
|2 | TABLE SCAN |t9 |100 |78 |
|3 | MATERIAL | |300 |471 |
|4 | PX COORDINATOR | |300 |464 |
|5 | EXCHANGE OUT DISTR |:EX10000|300 |391 |
|6 | PX PARTITION ITERATOR | |300 |233 |
|7 | TABLE SCAN |t2 |300 |233 |
|8 | MATERIAL | |500 |531 |
|9 | PX COORDINATOR | |500 |528 |
|10| EXCHANGE OUT DISTR |:EX20000|500 |481 |
|11| PX PARTITION ITERATOR | |500 |387 |
|12| TABLE SCAN |t1 |500 |387 |
==========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3], [t9.c1], [t9.c2], [t9.c3]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t2.c1], [t2.c2], [t2.c3], [t9.c1], [t9.c2], [t9.c3]), filter(nil),
conds(nil), nl_params_(nil)
2 - output([t9.c1], [t9.c2], [t9.c3]), filter(nil),
access([t9.c1], [t9.c2], [t9.c3]), partitions(p0)
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
5 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
6 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
7 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil)
10 - output([t1.c1], [t1.c2]), filter(nil), dop=1
11 - output([t1.c1], [t1.c2]), filter(nil)
12 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" (("opt"."t9"@"SEL$1" "opt"."t2"@"SEL$1") "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" "opt"."t1"@"SEL$1")
USE_NL(@"SEL$1" "opt"."t2"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t2"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t9"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" (("opt.t9"@"SEL$1" "opt.t2"@"SEL$1" )"opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t2"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t2"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t2"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t9"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 16(end) **************
*************** Case 17 ***************
SQL: select * from t1,t2 where (t1.c1 + t2.c1) in (select t9.c1 from t9, t10);
==========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST |
----------------------------------------------------------
|0 |HASH RIGHT SEMI JOIN | |1500 |53950|
|1 | SUBPLAN SCAN |VIEW1 |20000 |3195 |
|2 | NESTED-LOOP JOIN CARTESIAN| |20000 |2845 |
|3 | TABLE SCAN |t9 |100 |78 |
|4 | MATERIAL | |200 |188 |
|5 | PX COORDINATOR | |200 |187 |
|6 | EXCHANGE OUT DISTR |:EX10000|200 |176 |
|7 | PX PARTITION ITERATOR | |200 |155 |
|8 | TABLE SCAN |t10 |200 |155 |
|9 | NESTED-LOOP JOIN CARTESIAN | |150000 |8729 |
|10| PX COORDINATOR | |300 |464 |
|11| EXCHANGE OUT DISTR |:EX20000|300 |391 |
|12| PX PARTITION ITERATOR | |300 |233 |
|13| TABLE SCAN |t2 |300 |233 |
|14| MATERIAL | |500 |531 |
|15| PX COORDINATOR | |500 |528 |
|16| EXCHANGE OUT DISTR |:EX30000|500 |481 |
|17| PX PARTITION ITERATOR | |500 |387 |
|18| TABLE SCAN |t1 |500 |387 |
==========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
equal_conds([t1.c1 + t2.c1 = VIEW1.c1]), other_conds(nil)
1 - output([VIEW1.c1]), filter(nil),
access([VIEW1.c1])
2 - output([t9.c1]), filter(nil),
conds(nil), nl_params_(nil)
3 - output([t9.c1]), filter(nil),
access([t9.c1]), partitions(p0)
4 - output(nil), filter(nil)
5 - output(nil), filter(nil)
6 - output(nil), filter(nil), dop=1
7 - output(nil), filter(nil)
8 - output(nil), filter(nil),
access([t10.c1]), partitions(p[0-1])
9 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds(nil), nl_params_(nil)
10 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
11 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
12 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
13 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
14 - output([t1.c1], [t1.c2]), filter(nil)
15 - output([t1.c1], [t1.c2]), filter(nil)
16 - output([t1.c1], [t1.c2]), filter(nil), dop=1
17 - output([t1.c1], [t1.c2]), filter(nil)
18 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$6FCAE2AA" ("VIEW1"@"SEL$1" ("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1")))
USE_HASH(@"SEL$6FCAE2AA" ("opt"."t1"@"SEL$1" "opt"."t2"@"SEL$1"))
LEADING(@"SEL$2" ("opt"."t9"@"SEL$2" "opt"."t10"@"SEL$2"))
USE_NL(@"SEL$2" "opt"."t10"@"SEL$2")
PQ_DISTRIBUTE(@"SEL$2" "opt"."t10"@"SEL$2" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" "opt"."t10"@"SEL$2")
FULL(@"SEL$2" "opt"."t9"@"SEL$2")
FULL(@"SEL$2" "opt"."t10"@"SEL$2")
USE_NL(@"SEL$6FCAE2AA" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$6FCAE2AA" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$6FCAE2AA" "opt"."t1"@"SEL$1")
FULL(@"SEL$6FCAE2AA" "opt"."t2"@"SEL$1")
FULL(@"SEL$6FCAE2AA" "opt"."t1"@"SEL$1")
UNNEST(@"SEL$2")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("VIEW1"@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" )))
USE_HASH(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ) LOCAL LOCAL)
LEADING(@"SEL$2" ("opt.t9"@"SEL$2" "opt.t10"@"SEL$2" ))
USE_NL(@"SEL$2" ("opt.t10"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("opt.t10"@"SEL$2" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" ("opt.t10"@"SEL$2" ))
FULL(@"SEL$2" "opt"."t9"@"SEL$2")
FULL(@"SEL$2" "opt"."t10"@"SEL$2")
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 17(end) **************
*************** Case 18 ***************
SQL: select * from t1,t2 where (t1.c1 + t2.c1) in (select max(t9.c1) from t9, t10);
============================================================
|ID|OPERATOR |NAME |EST. ROWS|COST |
------------------------------------------------------------
|0 |NESTED-LOOP JOIN | |150000 |12562|
|1 | NESTED-LOOP JOIN CARTESIAN | |300 |3934 |
|2 | SUBPLAN SCAN |VIEW1 |1 |3553 |
|3 | SCALAR GROUP BY | |1 |3553 |
|4 | NESTED-LOOP JOIN CARTESIAN| |20000 |2845 |
|5 | TABLE SCAN |t9 |100 |78 |
|6 | MATERIAL | |200 |188 |
|7 | PX COORDINATOR | |200 |187 |
|8 | EXCHANGE OUT DISTR |:EX10000|200 |176 |
|9 | PX PARTITION ITERATOR | |200 |155 |
|10| TABLE SCAN |t10 |200 |155 |
|11| PX COORDINATOR | |300 |464 |
|12| EXCHANGE OUT DISTR |:EX20000|300 |391 |
|13| PX PARTITION ITERATOR | |300 |233 |
|14| TABLE SCAN |t2 |300 |233 |
|15| MATERIAL | |500 |531 |
|16| PX COORDINATOR | |500 |528 |
|17| EXCHANGE OUT DISTR |:EX30000|500 |481 |
|18| PX PARTITION ITERATOR | |500 |387 |
|19| TABLE SCAN |t1 |500 |387 |
============================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds([t1.c1 + t2.c1 = VIEW1.max(t9.c1)]), nl_params_(nil)
1 - output([t2.c1], [t2.c2], [t2.c3], [VIEW1.max(t9.c1)]), filter(nil),
conds(nil), nl_params_(nil)
2 - output([VIEW1.max(t9.c1)]), filter(nil),
access([VIEW1.max(t9.c1)])
3 - output([T_FUN_MAX(t9.c1)]), filter(nil),
group(nil), agg_func([T_FUN_MAX(t9.c1)])
4 - output([t9.c1]), filter(nil),
conds(nil), nl_params_(nil)
5 - output([t9.c1]), filter(nil),
access([t9.c1]), partitions(p0)
6 - output(nil), filter(nil)
7 - output(nil), filter(nil)
8 - output(nil), filter(nil), dop=1
9 - output(nil), filter(nil)
10 - output(nil), filter(nil),
access([t10.c1]), partitions(p[0-1])
11 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
12 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
13 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
14 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
15 - output([t1.c1], [t1.c2]), filter(nil)
16 - output([t1.c1], [t1.c2]), filter(nil)
17 - output([t1.c1], [t1.c2]), filter(nil), dop=1
18 - output([t1.c1], [t1.c2]), filter(nil)
19 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$E5385516" (("VIEW1"@"SEL$1" "opt"."t2"@"SEL$1") "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$E5385516" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$E5385516" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$E5385516" "opt"."t1"@"SEL$1")
USE_NL(@"SEL$E5385516" "opt"."t2"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$E5385516" "opt"."t2"@"SEL$1" LOCAL LOCAL)
LEADING(@"SEL$2" ("opt"."t9"@"SEL$2" "opt"."t10"@"SEL$2"))
USE_NL(@"SEL$2" "opt"."t10"@"SEL$2")
PQ_DISTRIBUTE(@"SEL$2" "opt"."t10"@"SEL$2" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" "opt"."t10"@"SEL$2")
FULL(@"SEL$2" "opt"."t9"@"SEL$2")
FULL(@"SEL$2" "opt"."t10"@"SEL$2")
FULL(@"SEL$E5385516" "opt"."t2"@"SEL$1")
FULL(@"SEL$E5385516" "opt"."t1"@"SEL$1")
UNNEST(@"SEL$2")
SEMI_TO_INNER(@"SEL$6FCAE2AA" "VIEW1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" (("VIEW1"@"SEL$1" "opt.t2"@"SEL$1" )"opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t2"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t2"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t2"@"SEL$1" ))
LEADING(@"SEL$2" ("opt.t9"@"SEL$2" "opt.t10"@"SEL$2" ))
USE_NL(@"SEL$2" ("opt.t10"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("opt.t10"@"SEL$2" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" ("opt.t10"@"SEL$2" ))
FULL(@"SEL$2" "opt"."t9"@"SEL$2")
FULL(@"SEL$2" "opt"."t10"@"SEL$2")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 18(end) **************
*************** Case 19 ***************
SQL: select * from t8, (select count(*) from t1 where t1.c1 > any (select t2.c1 from t2)) as tt;
=========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST |
---------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |100 |28283|
|1 | SUBPLAN SCAN |tt |1 |28183|
|2 | SCALAR GROUP BY | |1 |28183|
|3 | NESTED-LOOP SEMI JOIN | |167 |28177|
|4 | PX COORDINATOR | |500 |466 |
|5 | EXCHANGE OUT DISTR |:EX10000|500 |439 |
|6 | PX PARTITION ITERATOR| |500 |387 |
|7 | TABLE SCAN |t1 |500 |387 |
|8 | PX COORDINATOR | |1 |18 |
|9 | EXCHANGE OUT DISTR |:EX20000|1 |18 |
|10| PX PARTITION ITERATOR| |1 |18 |
|11| TABLE SCAN |t2 |1 |18 |
|12| TABLE SCAN |t8 |100 |78 |
=========================================================
Outputs & filters:
-------------------------------------
0 - output([t8.c1], [t8.c2], [tt.count(*)]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([tt.count(*)]), filter(nil),
access([tt.count(*)])
2 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
3 - output(nil), filter(nil),
conds(nil), nl_params_([t1.c1])
4 - output([t1.c1]), filter(nil)
5 - output([t1.c1]), filter(nil), dop=1
6 - output([t1.c1]), filter(nil)
7 - output([t1.c1]), filter(nil),
access([t1.c1]), partitions(p[0-4])
8 - output(nil), filter(nil)
9 - output(nil), filter(nil), dop=1
10 - output(nil), filter(nil)
11 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
12 - output([t8.c1], [t8.c2]), filter(nil),
access([t8.c1], [t8.c2]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt"."t8"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t8"@"SEL$1")
LEADING(@"SEL$119A0069" ("opt"."t1"@"SEL$2" "opt"."t2"@"SEL$3"))
USE_NL(@"SEL$119A0069" "opt"."t2"@"SEL$3")
PQ_DISTRIBUTE(@"SEL$119A0069" "opt"."t2"@"SEL$3" LOCAL LOCAL)
FULL(@"SEL$119A0069" "opt"."t1"@"SEL$2")
FULL(@"SEL$119A0069" "opt"."t2"@"SEL$3")
FULL(@"SEL$1" "opt"."t8"@"SEL$1")
UNNEST(@"SEL$3")
MERGE(@"SEL$3" > "SEL$19FECD1D")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt.t8"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t8"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t8"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t8"@"SEL$1" ))
LEADING(@"SEL$2" ("VIEW1"@"SEL$2" "opt.t1"@"SEL$2" ))
USE_NL(@"SEL$2" ("opt.t1"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("opt.t1"@"SEL$2" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$2" ("opt.t1"@"SEL$2" ))
FULL(@"SEL$4" "opt"."t2"@"SEL$4")
FULL(@"SEL$2" "opt"."t1"@"SEL$2")
FULL(@"SEL$1" "opt"."t8"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 19(end) **************
*************** Case 20 ***************
SQL: select /*+ BEGIN_OUTLINE_DATA USE_MERGE(@"SEL$1" "opt.t2"@"SEL$1") LEADING(@"SEL$1" "opt.t1"@"SEL$1" "opt.t2"@"SEL$1") FULL(@"SEL$1" "opt.t1"@"SEL$1") FULL(@"SEL$1" "opt.t2"@"SEL$1") END_OUTLINE_DATA */* from t1,t2 where t1.c1=t2.c1;
============================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
------------------------------------------------------------
|0 |PX COORDINATOR | |300 |1304|
|1 | EXCHANGE OUT DISTR |:EX10001|300 |1208|
|2 | MERGE JOIN | |300 |998 |
|3 | EXCHANGE IN MERGE SORT DISTR| |500 |528 |
|4 | EXCHANGE OUT DISTR (PKEY) |:EX10000|500 |481 |
|5 | PX PARTITION ITERATOR | |500 |387 |
|6 | TABLE SCAN |t1 |500 |387 |
|7 | SORT | |300 |299 |
|8 | PX PARTITION ITERATOR | |300 |233 |
|9 | TABLE SCAN |t2 |300 |233 |
============================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2, t2.c1, t2.c2, t2.c3)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2, t2.c1, t2.c2, t2.c3)]), filter(nil), dop=1
2 - output([t1.c1], [t2.c1], [t1.c2], [t2.c2], [t2.c3]), filter(nil),
equal_conds([t1.c1 = t2.c1]), other_conds(nil)
3 - output([t1.c1], [t1.c2]), filter(nil), sort_keys([t1.c1, ASC]), Local Order
4 - (#keys=1, [t1.c1]), output([t1.c1], [t1.c2]), filter(nil), dop=1
5 - output([t1.c1], [t1.c2]), filter(nil)
6 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
7 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), sort_keys([t2.c1, ASC]), local merge sort
8 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
9 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("opt"."t1"@"SEL$1" "opt"."t2"@"SEL$1"))
USE_MERGE(@"SEL$1" "opt"."t2"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t2"@"SEL$1" PARTITION NONE)
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t1"@"SEL$1" "opt.t2"@"SEL$1" ))
USE_MERGE(@"SEL$1" ("opt.t2"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t2"@"SEL$1" ) PARTITION NONE)
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 20(end) **************
*************** Case 21 ***************
SQL: select /*+ BEGIN_OUTLINE_DATA USE_MERGE(@"SEL$1" "opt.t1"@"SEL$1") LEADING(@"SEL$1" "opt.t2"@"SEL$1" "opt.t1"@"SEL$1") FULL(@"SEL$1" "opt.t2"@"SEL$1") FULL(@"SEL$1" "opt.t1"@"SEL$1") END_OUTLINE_DATA */* from t1,t2 where t1.c1=t2.c1;
============================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
------------------------------------------------------------
|0 |PX COORDINATOR | |300 |1301|
|1 | EXCHANGE OUT DISTR |:EX10001|300 |1205|
|2 | MERGE JOIN | |300 |995 |
|3 | SORT | |300 |299 |
|4 | PX PARTITION ITERATOR | |300 |233 |
|5 | TABLE SCAN |t2 |300 |233 |
|6 | EXCHANGE IN MERGE SORT DISTR| |500 |528 |
|7 | EXCHANGE OUT DISTR (PKEY) |:EX10000|500 |481 |
|8 | PX PARTITION ITERATOR | |500 |387 |
|9 | TABLE SCAN |t1 |500 |387 |
============================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2, t2.c1, t2.c2, t2.c3)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2, t2.c1, t2.c2, t2.c3)]), filter(nil), dop=1
2 - output([t1.c1], [t2.c1], [t2.c2], [t2.c3], [t1.c2]), filter(nil),
equal_conds([t1.c1 = t2.c1]), other_conds(nil)
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), sort_keys([t2.c1, ASC]), local merge sort
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
5 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
6 - output([t1.c1], [t1.c2]), filter(nil), sort_keys([t1.c1, ASC]), Local Order
7 - (#keys=1, [t1.c1]), output([t1.c1], [t1.c2]), filter(nil), dop=1
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_MERGE(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" NONE PARTITION)
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_MERGE(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) NONE PARTITION)
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 21(end) **************
*************** Case 22 ***************
SQL: select /*+ BEGIN_OUTLINE_DATA USE_NL(@"SEL$1" "opt.tt2"@"SEL$1") LEADING(@"SEL$1" "opt.tt1"@"SEL$1" "opt.tt2"@"SEL$1") FULL(@"SEL$1" "opt.tt1"@"SEL$1") FULL(@"SEL$1" "opt.tt2"@"SEL$1") END_OUTLINE_DATA */* from t1 as tt1,t2 as tt2 where tt1.c1=tt2.c1;
==========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------------
|0 |PX COORDINATOR | |300 |4167|
|1 | EXCHANGE OUT DISTR |:EX10001|300 |4071|
|2 | NESTED-LOOP JOIN | |300 |3861|
|3 | EXCHANGE IN DISTR | |500 |528 |
|4 | EXCHANGE OUT DISTR (PKEY)|:EX10000|500 |481 |
|5 | PX PARTITION ITERATOR | |500 |387 |
|6 | TABLE SCAN |tt1 |500 |387 |
|7 | PX PARTITION ITERATOR | |1 |18 |
|8 | TABLE GET |tt2 |1 |18 |
==========================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(tt1.c1, tt1.c2, tt2.c1, tt2.c2, tt2.c3)]), filter(nil)
1 - output([INTERNAL_FUNCTION(tt1.c1, tt1.c2, tt2.c1, tt2.c2, tt2.c3)]), filter(nil), dop=1
2 - output([tt1.c1], [tt1.c2], [tt2.c1], [tt2.c2], [tt2.c3]), filter(nil),
conds(nil), nl_params_([tt1.c1])
3 - output([tt1.c1], [PARTITION_ID], [tt1.c2]), filter(nil)
4 - (#keys=1, [tt1.c1]), output([tt1.c1], [PARTITION_ID], [tt1.c2]), filter(nil), dop=1
5 - output([tt1.c1], [tt1.c2]), filter(nil)
6 - output([tt1.c1], [tt1.c2]), filter(nil),
access([tt1.c1], [tt1.c2]), partitions(p[0-4])
7 - output([tt2.c1], [tt2.c2], [tt2.c3]), filter(nil)
8 - output([tt2.c1], [tt2.c2], [tt2.c3]), filter(nil),
access([tt2.c1], [tt2.c2], [tt2.c3]), partitions(p[0-2])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("opt"."tt1"@"SEL$1" "opt"."tt2"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."tt2"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."tt2"@"SEL$1" PARTITION NONE)
FULL(@"SEL$1" "opt"."tt1"@"SEL$1")
FULL(@"SEL$1" "opt"."tt2"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.tt1"@"SEL$1" "opt.tt2"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.tt2"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.tt2"@"SEL$1" ) PARTITION NONE)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.tt2"@"SEL$1" ))
FULL(@"SEL$1" "opt"."tt1"@"SEL$1")
FULL(@"SEL$1" "opt"."tt2"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 22(end) **************
*************** Case 23 ***************
SQL: select /*+read_consistency("weak")*/* from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
<<<<<<< HEAD
READ_CONSISTENCY( WEAK )
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
READ_CONSISTENCY("WEAK")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 23(end) **************
*************** Case 24 ***************
SQL: select /*+hotspot*/* from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 24(end) **************
*************** Case 25 ***************
SQL: select /*+topk(1 100)*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 25(end) **************
*************** Case 26 ***************
SQL: select /*+query_timeout(100)*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
QUERY_TIMEOUT(100)
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
END_OUTLINE_DATA
*/
*************** Case 26(end) **************
*************** Case 27 ***************
SQL: select /*+frozen_version(1)*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FROZEN_VERSION(1)
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
END_OUTLINE_DATA
*/
*************** Case 27(end) **************
*************** Case 28 ***************
SQL: select /*+use_plan_cache(none)*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
<<<<<<< HEAD
USE_PLAN_CACHE( NONE )
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
USE_PLAN_CACHE("NONE")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 28(end) **************
*************** Case 29 ***************
SQL: select /*+use_plan_cache(default)*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
<<<<<<< HEAD
USE_PLAN_CACHE( DEFAULT )
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
USE_PLAN_CACHE("DEFAULT")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 29(end) **************
*************** Case 30 ***************
SQL: select /*+use_plan_cache(nothing)*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 30(end) **************
*************** Case 31 ***************
SQL: select /*+activate_buried_point(1,FIX_MODE,1,1)*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 31(end) **************
*************** Case 32 ***************
SQL: select /*+no_rewrite*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
NO_REWRITE
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 32(end) **************
*************** Case 33 ***************
SQL: select * from t1 where c1 > any (select /*+no_rewrite*/ count(*) from t2);
=======================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-------------------------------------------------------
|0 |SUBPLAN FILTER | |167 |523 |
|1 | PX COORDINATOR | |167 |277 |
|2 | EXCHANGE OUT DISTR |:EX10000|167 |261 |
|3 | PX PARTITION ITERATOR | |167 |230 |
|4 | TABLE SCAN |t1 |167 |230 |
|5 | SCALAR GROUP BY | |1 |244 |
|6 | PX COORDINATOR | |1 |243 |
|7 | EXCHANGE OUT DISTR |:EX20000|1 |243 |
|8 | MERGE GROUP BY | |1 |243 |
|9 | PX PARTITION ITERATOR| |300 |233 |
|10| TABLE SCAN |t2 |300 |233 |
=======================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2]), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)]), init_plan_idxs_(nil)
1 - output([t1.c1], [t1.c2]), filter(nil)
2 - output([t1.c1], [t1.c2]), filter(nil), dop=1
3 - output([t1.c1], [t1.c2]), filter(nil)
4 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
5 - output([T_FUN_COUNT_SUM(T_FUN_COUNT(*))]), filter(nil),
group(nil), agg_func([T_FUN_COUNT_SUM(T_FUN_COUNT(*))])
6 - output([T_FUN_COUNT(*)]), filter(nil)
7 - output([T_FUN_COUNT(*)]), filter(nil), dop=1
8 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
9 - output(nil), filter(nil)
10 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
FULL(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
GBY_PUSHDOWN(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
SIMPLIFY_SUBQUERY(@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("VIEW1"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
NO_USE_HASH_AGGREGATION(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 33(end) **************
*************** Case 34 ***************
SQL: select /*+trace_log*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
TRACE_LOG
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
END_OUTLINE_DATA
*/
*************** Case 34(end) **************
*************** Case 35 ***************
SQL: select /*+log_level('INFO')*/ * from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
<<<<<<< HEAD
LOG_LEVEL("INFO")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LOG_LEVEL('info')
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 35(end) **************
*************** Case 36 ***************
SQL: select * from t1,(select /*+log_level('INFO')*/ count(*) from t2) as tt;
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |500 |533 |
|1 | SUBPLAN SCAN |tt |1 |244 |
|2 | SCALAR GROUP BY | |1 |244 |
|3 | PX COORDINATOR | |1 |243 |
|4 | EXCHANGE OUT DISTR |:EX10000|1 |243 |
|5 | MERGE GROUP BY | |1 |243 |
|6 | PX PARTITION ITERATOR| |300 |233 |
|7 | TABLE SCAN |t2 |300 |233 |
|8 | PX COORDINATOR | |500 |528 |
|9 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|10| PX PARTITION ITERATOR | |500 |387 |
|11| TABLE SCAN |t1 |500 |387 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [tt.count(*)]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([tt.count(*)]), filter(nil),
access([tt.count(*)])
2 - output([T_FUN_COUNT_SUM(T_FUN_COUNT(*))]), filter(nil),
group(nil), agg_func([T_FUN_COUNT_SUM(T_FUN_COUNT(*))])
3 - output([T_FUN_COUNT(*)]), filter(nil)
4 - output([T_FUN_COUNT(*)]), filter(nil), dop=1
5 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
6 - output(nil), filter(nil)
7 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil), dop=1
10 - output([t1.c1], [t1.c2]), filter(nil)
11 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
GBY_PUSHDOWN(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
LOG_LEVEL("INFO")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
NO_USE_HASH_AGGREGATION(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
LOG_LEVEL('info')
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 36(end) **************
*************** Case 37 ***************
SQL: select * from t1,(select /*+trace_log*/ count(*) from t2) as tt;
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |500 |533 |
|1 | SUBPLAN SCAN |tt |1 |244 |
|2 | SCALAR GROUP BY | |1 |244 |
|3 | PX COORDINATOR | |1 |243 |
|4 | EXCHANGE OUT DISTR |:EX10000|1 |243 |
|5 | MERGE GROUP BY | |1 |243 |
|6 | PX PARTITION ITERATOR| |300 |233 |
|7 | TABLE SCAN |t2 |300 |233 |
|8 | PX COORDINATOR | |500 |528 |
|9 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|10| PX PARTITION ITERATOR | |500 |387 |
|11| TABLE SCAN |t1 |500 |387 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [tt.count(*)]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([tt.count(*)]), filter(nil),
access([tt.count(*)])
2 - output([T_FUN_COUNT_SUM(T_FUN_COUNT(*))]), filter(nil),
group(nil), agg_func([T_FUN_COUNT_SUM(T_FUN_COUNT(*))])
3 - output([T_FUN_COUNT(*)]), filter(nil)
4 - output([T_FUN_COUNT(*)]), filter(nil), dop=1
5 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
6 - output(nil), filter(nil)
7 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil), dop=1
10 - output([t1.c1], [t1.c2]), filter(nil)
11 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
GBY_PUSHDOWN(@"SEL$2")
=======
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
NO_USE_HASH_AGGREGATION(@"SEL$2")
>>>>>>> implement spm part1
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
TRACE_LOG
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
END_OUTLINE_DATA
*/
*************** Case 37(end) **************
*************** Case 38 ***************
SQL: select * from t1,(select /*+use_plan_cache(none)*/ count(*) from t2) as tt;
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |500 |533 |
|1 | SUBPLAN SCAN |tt |1 |244 |
|2 | SCALAR GROUP BY | |1 |244 |
|3 | PX COORDINATOR | |1 |243 |
|4 | EXCHANGE OUT DISTR |:EX10000|1 |243 |
|5 | MERGE GROUP BY | |1 |243 |
|6 | PX PARTITION ITERATOR| |300 |233 |
|7 | TABLE SCAN |t2 |300 |233 |
|8 | PX COORDINATOR | |500 |528 |
|9 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|10| PX PARTITION ITERATOR | |500 |387 |
|11| TABLE SCAN |t1 |500 |387 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [tt.count(*)]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([tt.count(*)]), filter(nil),
access([tt.count(*)])
2 - output([T_FUN_COUNT_SUM(T_FUN_COUNT(*))]), filter(nil),
group(nil), agg_func([T_FUN_COUNT_SUM(T_FUN_COUNT(*))])
3 - output([T_FUN_COUNT(*)]), filter(nil)
4 - output([T_FUN_COUNT(*)]), filter(nil), dop=1
5 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
6 - output(nil), filter(nil)
7 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil), dop=1
10 - output([t1.c1], [t1.c2]), filter(nil)
11 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
GBY_PUSHDOWN(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
USE_PLAN_CACHE( NONE )
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
NO_USE_HASH_AGGREGATION(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
USE_PLAN_CACHE("NONE")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 38(end) **************
*************** Case 39 ***************
SQL: select * from t1,(select /*+use_plan_cache(default)*/ count(*) from t2) as tt;
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |500 |533 |
|1 | SUBPLAN SCAN |tt |1 |244 |
|2 | SCALAR GROUP BY | |1 |244 |
|3 | PX COORDINATOR | |1 |243 |
|4 | EXCHANGE OUT DISTR |:EX10000|1 |243 |
|5 | MERGE GROUP BY | |1 |243 |
|6 | PX PARTITION ITERATOR| |300 |233 |
|7 | TABLE SCAN |t2 |300 |233 |
|8 | PX COORDINATOR | |500 |528 |
|9 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|10| PX PARTITION ITERATOR | |500 |387 |
|11| TABLE SCAN |t1 |500 |387 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [tt.count(*)]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([tt.count(*)]), filter(nil),
access([tt.count(*)])
2 - output([T_FUN_COUNT_SUM(T_FUN_COUNT(*))]), filter(nil),
group(nil), agg_func([T_FUN_COUNT_SUM(T_FUN_COUNT(*))])
3 - output([T_FUN_COUNT(*)]), filter(nil)
4 - output([T_FUN_COUNT(*)]), filter(nil), dop=1
5 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
6 - output(nil), filter(nil)
7 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil), dop=1
10 - output([t1.c1], [t1.c2]), filter(nil)
11 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
GBY_PUSHDOWN(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
USE_PLAN_CACHE( DEFAULT )
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
NO_USE_HASH_AGGREGATION(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
USE_PLAN_CACHE("DEFAULT")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 39(end) **************
*************** Case 40 ***************
SQL: select * from t1,(select /*+use_plan_cache(nothing)*/ count(*) from t2) as tt;
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |500 |533 |
|1 | SUBPLAN SCAN |tt |1 |244 |
|2 | SCALAR GROUP BY | |1 |244 |
|3 | PX COORDINATOR | |1 |243 |
|4 | EXCHANGE OUT DISTR |:EX10000|1 |243 |
|5 | MERGE GROUP BY | |1 |243 |
|6 | PX PARTITION ITERATOR| |300 |233 |
|7 | TABLE SCAN |t2 |300 |233 |
|8 | PX COORDINATOR | |500 |528 |
|9 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|10| PX PARTITION ITERATOR | |500 |387 |
|11| TABLE SCAN |t1 |500 |387 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [tt.count(*)]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([tt.count(*)]), filter(nil),
access([tt.count(*)])
2 - output([T_FUN_COUNT_SUM(T_FUN_COUNT(*))]), filter(nil),
group(nil), agg_func([T_FUN_COUNT_SUM(T_FUN_COUNT(*))])
3 - output([T_FUN_COUNT(*)]), filter(nil)
4 - output([T_FUN_COUNT(*)]), filter(nil), dop=1
5 - output([T_FUN_COUNT(*)]), filter(nil),
group(nil), agg_func([T_FUN_COUNT(*)])
6 - output(nil), filter(nil)
7 - output(nil), filter(nil),
access([t2.c1]), partitions(p[0-2])
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil), dop=1
10 - output([t1.c1], [t1.c2]), filter(nil)
11 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
GBY_PUSHDOWN(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("tt"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
NO_USE_HASH_AGGREGATION(@"SEL$2")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 40(end) **************
*************** Case 41 ***************
SQL: select /*+ BEGIN_OUTLINE_DATA FULL(@"SEL$1" "t1"@"SEL$1") READ_CONSISTENCY("WEAK") HOTSPOT TOPK(1 100) QUERY_TIMEOUT(100) FROZEN_VERSION(1) USE_PLAN_CACHE("EXACT") NO_REWRITE TRACE_LOG LOG_LEVEL('info') END_OUTLINE_DATA */* from t1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |528 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1, t1.c2)]), filter(nil), dop=1
2 - output([t1.c1], [t1.c2]), filter(nil)
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FROZEN_VERSION(1)
QUERY_TIMEOUT(100)
TRACE_LOG
LOG_LEVEL("info")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
END_OUTLINE_DATA
*/
*************** Case 41(end) **************
*************** Case 42 ***************
SQL: select max(c1) from t1 group by c1;
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |PX COORDINATOR | |500 |466 |
|1 | EXCHANGE OUT DISTR |:EX10000|500 |439 |
|2 | PX PARTITION ITERATOR| |500 |387 |
|3 | TABLE SCAN |t1 |500 |387 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(t1.c1)]), filter(nil)
1 - output([INTERNAL_FUNCTION(t1.c1)]), filter(nil), dop=1
2 - output([t1.c1]), filter(nil)
3 - output([t1.c1]), filter(nil),
access([t1.c1]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
FULL(@"SEL$EA493D33" "opt"."t1"@"SEL$1")
SIMPLIFY_GROUP_BY(@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 42(end) **************
*************** Case 43 ***************
SQL: select min(c2) from t1 group by c2;
=================================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-----------------------------------------------------------------
|0 |PX COORDINATOR | |100 |493 |
|1 | EXCHANGE OUT DISTR |:EX10001 |100 |480 |
|2 | MERGE GROUP BY | |100 |453 |
|3 | EXCHANGE IN MERGE SORT DISTR| |100 |446 |
|4 | EXCHANGE OUT DISTR (HASH) |:EX10000 |100 |437 |
|5 | PX PARTITION ITERATOR | |100 |418 |
|6 | MERGE GROUP BY | |100 |418 |
|7 | TABLE SCAN |t1(idx_t1_c2)|500 |387 |
=================================================================
Outputs & filters:
-------------------------------------
0 - output([INTERNAL_FUNCTION(T_FUN_MIN(T_FUN_MIN(t1.c2)))]), filter(nil)
1 - output([INTERNAL_FUNCTION(T_FUN_MIN(T_FUN_MIN(t1.c2)))]), filter(nil), dop=1
2 - output([T_FUN_MIN(T_FUN_MIN(t1.c2))]), filter(nil),
group([t1.c2]), agg_func([T_FUN_MIN(T_FUN_MIN(t1.c2))])
3 - output([t1.c2], [T_FUN_MIN(t1.c2)]), filter(nil), sort_keys([t1.c2, ASC]), Local Order
4 - (#keys=1, [t1.c2]), output([t1.c2], [T_FUN_MIN(t1.c2)]), filter(nil), dop=1
5 - output([t1.c2], [T_FUN_MIN(t1.c2)]), filter(nil)
6 - output([t1.c2], [T_FUN_MIN(t1.c2)]), filter(nil),
group([t1.c2]), agg_func([T_FUN_MIN(t1.c2)])
7 - output([t1.c2]), filter(nil),
access([t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
INDEX(@"SEL$1" "opt"."t1"@"SEL$1" "idx_t1_c2")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
NO_USE_HASH_AGGREGATION(@"SEL$1")
NO_USE_HASH_AGGREGATION(@"SEL$1")
INDEX(@"SEL$1" "opt"."t1"@"SEL$1" "idx_t1_c2")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 43(end) **************
*************** Case 44 ***************
SQL: insert into t1 (c1) values(1);
=============================================
|ID|OPERATOR |NAME|EST. ROWS|COST|
---------------------------------------------
|0 |EXCHANGE IN REMOTE | |1 |13 |
|1 | EXCHANGE OUT REMOTE| |1 |13 |
|2 | INSERT | |1 |13 |
|3 | EXPRESSION | |1 |1 |
=============================================
Outputs & filters:
-------------------------------------
0 - output(nil), filter(nil)
1 - output(nil), filter(nil)
2 - output(nil), filter(nil),
columns([{t1: ({t1: (t1.c1, t1.c2)})}]), partitions(p1),
column_values([column_conv(INT,PS:(11,0),NOT NULL,__values.c1)], [?])
3 - output([__values.c1]), filter(nil)
values({?})
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
END_OUTLINE_DATA
*/
*************** Case 44(end) **************
*************** Case 45 ***************
SQL: update t7 set c1=100 where c1=1;
===================================
|ID|OPERATOR |NAME|EST. ROWS|COST|
-----------------------------------
|0 |UPDATE | |1 |77 |
|1 | TABLE GET|t7 |1 |46 |
===================================
Outputs & filters:
-------------------------------------
0 - output(nil), filter(nil), table_columns([{t7: ({t7: (t7.c1, t7.c2)})}]),
update([t7.c1=?])
1 - output([t7.c1], [t7.c2]), filter(nil),
access([t7.c1], [t7.c2]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"UPD$1" "opt"."t7"@"UPD$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 45(end) **************
*************** Case 46 ***************
SQL: delete from t1 where c1=1;
=============================================
|ID|OPERATOR |NAME|EST. ROWS|COST|
---------------------------------------------
|0 |EXCHANGE IN REMOTE | |1 |58 |
|1 | EXCHANGE OUT REMOTE| |1 |58 |
|2 | DELETE | |1 |57 |
|3 | TABLE GET |t1 |1 |46 |
=============================================
Outputs & filters:
-------------------------------------
0 - output(nil), filter(nil)
1 - output(nil), filter(nil)
2 - output(nil), filter(nil), table_columns([{t1: ({t1: (t1.c1, t1.c2)})}])
3 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p1)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"DEL$1" "opt"."t1"@"DEL$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 46(end) **************
*************** Case 47 ***************
SQL: select /*+index(t_normal_idx idx)*/* from t_normal_idx order by c3 limit 1;
=======================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-------------------------------------------------------
|0 |NESTED-LOOP JOIN| |1 |111 |
|1 | TOP-N SORT | |1 |80 |
|2 | TABLE SCAN |t_normal_idx(idx) |100 |78 |
|3 | TABLE GET |t_normal_idx_alias|1 |31 |
=======================================================
Outputs & filters:
-------------------------------------
0 - output([t_normal_idx.c1], [t_normal_idx_alias.c2], [t_normal_idx.c3], [t_normal_idx_alias.c4], [t_normal_idx_alias.c5], [t_normal_idx_alias.c6], [t_normal_idx_alias.c7], [t_normal_idx_alias.c8], [t_normal_idx_alias.c9], [t_normal_idx_alias.c10]), filter(nil),
conds(nil), nl_params_([t_normal_idx.c1])
1 - output([t_normal_idx.c1], [t_normal_idx.c3]), filter(nil), sort_keys([t_normal_idx.c3, ASC]), topn(1)
2 - output([t_normal_idx.c1], [t_normal_idx.c3]), filter(nil),
access([t_normal_idx.c1], [t_normal_idx.c3]), partitions(p0)
3 - output([t_normal_idx_alias.c2], [t_normal_idx_alias.c4], [t_normal_idx_alias.c5], [t_normal_idx_alias.c6], [t_normal_idx_alias.c7], [t_normal_idx_alias.c8], [t_normal_idx_alias.c9], [t_normal_idx_alias.c10]), filter(nil),
access([t_normal_idx_alias.c2], [t_normal_idx_alias.c4], [t_normal_idx_alias.c5], [t_normal_idx_alias.c6], [t_normal_idx_alias.c7], [t_normal_idx_alias.c8], [t_normal_idx_alias.c9], [t_normal_idx_alias.c10]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
USE_LATE_MATERIALIZATION(@"SEL$1")
INDEX(@"SEL$1" "opt"."t_normal_idx"@"SEL$1" "idx")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t_normal_idx"@"SEL$1" "opt.t_normal_idx_alias"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t_normal_idx_alias"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t_normal_idx_alias"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t_normal_idx_alias"@"SEL$1" ))
INDEX(@"SEL$1" "opt"."t_normal_idx"@"SEL$1" "idx")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 47(end) **************
*************** Case 48 ***************
SQL: select /*+no_use_late_materialization index(t_normal_idx idx)*/* from t_normal_idx where c2=1 order by c4 limit 1;
=================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-------------------------------------------------
|0 |TOP-N SORT | |1 |137 |
|1 | TABLE SCAN|t_normal_idx(idx)|100 |134 |
=================================================
Outputs & filters:
-------------------------------------
0 - output([t_normal_idx.c1], [t_normal_idx.c2], [t_normal_idx.c3], [t_normal_idx.c4], [t_normal_idx.c5], [t_normal_idx.c6], [t_normal_idx.c7], [t_normal_idx.c8], [t_normal_idx.c9], [t_normal_idx.c10]), filter(nil), sort_keys([t_normal_idx.c4, ASC]), topn(1)
1 - output([t_normal_idx.c1], [t_normal_idx.c2], [t_normal_idx.c3], [t_normal_idx.c4], [t_normal_idx.c5], [t_normal_idx.c6], [t_normal_idx.c7], [t_normal_idx.c8], [t_normal_idx.c9], [t_normal_idx.c10]), filter(nil),
access([t_normal_idx.c1], [t_normal_idx.c2], [t_normal_idx.c3], [t_normal_idx.c4], [t_normal_idx.c5], [t_normal_idx.c6], [t_normal_idx.c7], [t_normal_idx.c8], [t_normal_idx.c9], [t_normal_idx.c10]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
INDEX(@"SEL$1" "opt"."t_normal_idx"@"SEL$1" "idx")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 48(end) **************
*************** Case 49 ***************
SQL: select * from t1 where t1.c1 > (select c1 from t2);
=====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-----------------------------------------------------
|0 |SUBPLAN FILTER | |167 |559 |
|1 | PX COORDINATOR | |167 |277 |
|2 | EXCHANGE OUT DISTR |:EX10000|167 |261 |
|3 | PX PARTITION ITERATOR| |167 |230 |
|4 | TABLE SCAN |t1 |167 |230 |
|5 | PX COORDINATOR | |300 |280 |
|6 | EXCHANGE OUT DISTR |:EX20000|300 |263 |
|7 | PX PARTITION ITERATOR| |300 |233 |
|8 | TABLE SCAN |t2 |300 |233 |
=====================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2]), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)]), init_plan_idxs_(nil)
1 - output([t1.c1], [t1.c2]), filter(nil)
2 - output([t1.c1], [t1.c2]), filter(nil), dop=1
3 - output([t1.c1], [t1.c2]), filter(nil)
4 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
5 - output([t2.c1]), filter(nil)
6 - output([t2.c1]), filter(nil), dop=1
7 - output([t2.c1]), filter(nil)
8 - output([t2.c1]), filter(nil),
access([t2.c1]), partitions(p[0-2])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 49(end) **************
*************** Case 50 ***************
SQL: select * from t1,t2 where (t1.c1 + t2.c1) > (select c1 from t3);
=======================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-------------------------------------------------------
|0 |SUBPLAN FILTER | |50000 |6092|
|1 | NESTED-LOOP JOIN | |50000 |5029|
|2 | PX COORDINATOR | |300 |464 |
|3 | EXCHANGE OUT DISTR |:EX10000|300 |391 |
|4 | PX PARTITION ITERATOR | |300 |233 |
|5 | TABLE SCAN |t2 |300 |233 |
|6 | MATERIAL | |500 |531 |
|7 | PX COORDINATOR | |500 |528 |
|8 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|9 | PX PARTITION ITERATOR| |500 |387 |
|10| TABLE SCAN |t1 |500 |387 |
|11| PX COORDINATOR | |200 |187 |
|12| EXCHANGE OUT DISTR |:EX30000|200 |176 |
|13| PX PARTITION ITERATOR | |200 |155 |
|14| TABLE SCAN |t3 |200 |155 |
=======================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)]), init_plan_idxs_(nil)
1 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds([t1.c1 + t2.c1 > ?]), nl_params_(nil)
2 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
5 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
6 - output([t1.c1], [t1.c2]), filter(nil)
7 - output([t1.c1], [t1.c2]), filter(nil)
8 - output([t1.c1], [t1.c2]), filter(nil), dop=1
9 - output([t1.c1], [t1.c2]), filter(nil)
10 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
11 - output([t3.c1]), filter(nil)
12 - output([t3.c1]), filter(nil), dop=1
13 - output([t3.c1]), filter(nil)
14 - output([t3.c1]), filter(nil),
access([t3.c1]), partitions(p[0-1])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 50(end) **************
*************** Case 51 ***************
SQL: select * from t1,t2 where (t1.c1 + t2.c1) > (select t3.c1 from t3, t4);
=============================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-------------------------------------------------------------
|0 |SUBPLAN FILTER | |50000 |8750|
|1 | NESTED-LOOP JOIN | |50000 |5029|
|2 | PX COORDINATOR | |300 |464 |
|3 | EXCHANGE OUT DISTR |:EX10000 |300 |391 |
|4 | PX PARTITION ITERATOR | |300 |233 |
|5 | TABLE SCAN |t2 |300 |233 |
|6 | MATERIAL | |500 |531 |
|7 | PX COORDINATOR | |500 |528 |
|8 | EXCHANGE OUT DISTR |:EX20000 |500 |481 |
|9 | PX PARTITION ITERATOR | |500 |387 |
|10| TABLE SCAN |t1 |500 |387 |
|11| NESTED-LOOP JOIN CARTESIAN| |20000 |2845|
|12| TABLE SCAN |t4(idx_t4_c2)|100 |78 |
|13| MATERIAL | |200 |188 |
|14| PX COORDINATOR | |200 |187 |
|15| EXCHANGE OUT DISTR |:EX30000 |200 |176 |
|16| PX PARTITION ITERATOR | |200 |155 |
|17| TABLE SCAN |t3 |200 |155 |
=============================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)]), init_plan_idxs_(nil)
1 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds([t1.c1 + t2.c1 > ?]), nl_params_(nil)
2 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
5 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
6 - output([t1.c1], [t1.c2]), filter(nil)
7 - output([t1.c1], [t1.c2]), filter(nil)
8 - output([t1.c1], [t1.c2]), filter(nil), dop=1
9 - output([t1.c1], [t1.c2]), filter(nil)
10 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
11 - output([t3.c1]), filter(nil),
conds(nil), nl_params_(nil)
12 - output(nil), filter(nil),
access([t4.c1]), partitions(p0)
13 - output([t3.c1]), filter(nil)
14 - output([t3.c1]), filter(nil)
15 - output([t3.c1]), filter(nil), dop=1
16 - output([t3.c1]), filter(nil)
17 - output([t3.c1]), filter(nil),
access([t3.c1]), partitions(p[0-1])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
LEADING(@"SEL$2" ("opt"."t4"@"SEL$2" "opt"."t3"@"SEL$2"))
USE_NL(@"SEL$2" "opt"."t3"@"SEL$2")
PQ_DISTRIBUTE(@"SEL$2" "opt"."t3"@"SEL$2" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" "opt"."t3"@"SEL$2")
INDEX(@"SEL$2" "opt"."t4"@"SEL$2" "idx_t4_c2")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
LEADING(@"SEL$2" ("opt.t4"@"SEL$2" "opt.t3"@"SEL$2" ))
USE_NL(@"SEL$2" ("opt.t3"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("opt.t3"@"SEL$2" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" ("opt.t3"@"SEL$2" ))
INDEX(@"SEL$2" "opt"."t4"@"SEL$2" "idx_t4_c2")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 51(end) **************
*************** Case 52 ***************
SQL: select * from t1,t2 where t1.c1 > (select c1 from t2);
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------------------
|0 |SUBPLAN FILTER | |50000 |4479|
|1 | NESTED-LOOP JOIN CARTESIAN| |50000 |3324|
|2 | PX COORDINATOR | |300 |464 |
|3 | EXCHANGE OUT DISTR |:EX10000|300 |391 |
|4 | PX PARTITION ITERATOR | |300 |233 |
|5 | TABLE SCAN |t2 |300 |233 |
|6 | MATERIAL | |167 |278 |
|7 | PX COORDINATOR | |167 |277 |
|8 | EXCHANGE OUT DISTR |:EX20000|167 |261 |
|9 | PX PARTITION ITERATOR | |167 |230 |
|10| TABLE SCAN |t1 |167 |230 |
|11| PX COORDINATOR | |300 |280 |
|12| EXCHANGE OUT DISTR |:EX30000|300 |263 |
|13| PX PARTITION ITERATOR | |300 |233 |
|14| TABLE SCAN |t2 |300 |233 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)]), init_plan_idxs_(nil)
1 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds(nil), nl_params_(nil)
2 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
5 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
6 - output([t1.c1], [t1.c2]), filter(nil)
7 - output([t1.c1], [t1.c2]), filter(nil)
8 - output([t1.c1], [t1.c2]), filter(nil), dop=1
9 - output([t1.c1], [t1.c2]), filter(nil)
10 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
11 - output([t2.c1]), filter(nil)
12 - output([t2.c1]), filter(nil), dop=1
13 - output([t2.c1]), filter(nil)
14 - output([t2.c1]), filter(nil),
access([t2.c1]), partitions(p[0-2])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" ("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$2" "opt"."t2"@"SEL$2")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 52(end) **************
*************** Case 53 ***************
SQL: select /*+use_nl(t2) leading(t1 t2)*/ * from t1,t2 where t2.c1 > (select 1);
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST |
--------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN| |142500 |13231|
|1 | PX COORDINATOR | |500 |528 |
|2 | EXCHANGE OUT DISTR |:EX10000|500 |481 |
|3 | PX PARTITION ITERATOR | |500 |387 |
|4 | TABLE SCAN |t1 |500 |387 |
|5 | MATERIAL | |285 |459 |
|6 | PX COORDINATOR | |285 |453 |
|7 | EXCHANGE OUT DISTR |:EX20000|285 |383 |
|8 | PX PARTITION ITERATOR | |285 |232 |
|9 | TABLE SCAN |t2 |285 |232 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t1.c1], [t1.c2]), filter(nil)
2 - output([t1.c1], [t1.c2]), filter(nil), dop=1
3 - output([t1.c1], [t1.c2]), filter(nil)
4 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
5 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
6 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
7 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
8 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
9 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$4D615D57" ("opt"."t1"@"SEL$1" "opt"."t2"@"SEL$1"))
USE_NL(@"SEL$4D615D57" "opt"."t2"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$4D615D57" "opt"."t2"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$4D615D57" "opt"."t2"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t2"@"SEL$1")
SIMPLIFY_SUBQUERY(@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t1"@"SEL$1" "opt.t2"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t2"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t2"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t2"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 53(end) **************
*************** Case 54 ***************
SQL: select /*+use_nl(t2) leading(t1 t2)*/ * from t1,t2 where t1.c1 > (select 1);
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST |
--------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN| |142500 |13235|
|1 | PX COORDINATOR | |475 |520 |
|2 | EXCHANGE OUT DISTR |:EX10000|475 |476 |
|3 | PX PARTITION ITERATOR | |475 |387 |
|4 | TABLE SCAN |t1 |475 |387 |
|5 | MATERIAL | |300 |471 |
|6 | PX COORDINATOR | |300 |464 |
|7 | EXCHANGE OUT DISTR |:EX20000|300 |391 |
|8 | PX PARTITION ITERATOR | |300 |233 |
|9 | TABLE SCAN |t2 |300 |233 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t1.c1], [t1.c2]), filter(nil)
2 - output([t1.c1], [t1.c2]), filter(nil), dop=1
3 - output([t1.c1], [t1.c2]), filter(nil)
4 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
5 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
6 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
7 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
8 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
9 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$4D615D57" ("opt"."t1"@"SEL$1" "opt"."t2"@"SEL$1"))
USE_NL(@"SEL$4D615D57" "opt"."t2"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$4D615D57" "opt"."t2"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$4D615D57" "opt"."t2"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t2"@"SEL$1")
SIMPLIFY_SUBQUERY(@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t1"@"SEL$1" "opt.t2"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t2"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t2"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t2"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 54(end) **************
*************** Case 55 ***************
SQL: select /*+use_nl(t1) leading(t2 t1)*/ * from t1,t2 where t2.c1 > (select 1);
=======================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN| |142500 |8331|
|1 | PX COORDINATOR | |285 |453 |
|2 | EXCHANGE OUT DISTR |:EX10000|285 |383 |
|3 | PX PARTITION ITERATOR | |285 |232 |
|4 | TABLE SCAN |t2 |285 |232 |
|5 | MATERIAL | |500 |531 |
|6 | PX COORDINATOR | |500 |528 |
|7 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|8 | PX PARTITION ITERATOR | |500 |387 |
|9 | TABLE SCAN |t1 |500 |387 |
=======================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
2 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
5 - output([t1.c1], [t1.c2]), filter(nil)
6 - output([t1.c1], [t1.c2]), filter(nil)
7 - output([t1.c1], [t1.c2]), filter(nil), dop=1
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$4D615D57" ("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$4D615D57" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t2"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
SIMPLIFY_SUBQUERY(@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 55(end) **************
*************** Case 56 ***************
SQL: select /*+use_nl(t1) leading(t2 t1)*/ * from t1,t2 where t1.c1 > (select 1);
=======================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN| |142500 |8335|
|1 | PX COORDINATOR | |300 |464 |
|2 | EXCHANGE OUT DISTR |:EX10000|300 |391 |
|3 | PX PARTITION ITERATOR | |300 |233 |
|4 | TABLE SCAN |t2 |300 |233 |
|5 | MATERIAL | |475 |524 |
|6 | PX COORDINATOR | |475 |520 |
|7 | EXCHANGE OUT DISTR |:EX20000|475 |476 |
|8 | PX PARTITION ITERATOR | |475 |387 |
|9 | TABLE SCAN |t1 |475 |387 |
=======================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
2 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
5 - output([t1.c1], [t1.c2]), filter(nil)
6 - output([t1.c1], [t1.c2]), filter(nil)
7 - output([t1.c1], [t1.c2]), filter(nil), dop=1
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$4D615D57" ("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1"))
USE_NL(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$4D615D57" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t2"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
SIMPLIFY_SUBQUERY(@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 56(end) **************
*************** Case 57 ***************
SQL: select * from t1,t2,t3 where (t2.c1 + t1.c1) > (select 1);
==========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST |
----------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN| |10000000 |1294925|
|1 | NESTED-LOOP JOIN | |50000 |5427 |
|2 | PX COORDINATOR | |300 |464 |
|3 | EXCHANGE OUT DISTR |:EX10000|300 |391 |
|4 | PX PARTITION ITERATOR | |300 |233 |
|5 | TABLE SCAN |t2 |300 |233 |
|6 | MATERIAL | |500 |531 |
|7 | PX COORDINATOR | |500 |528 |
|8 | EXCHANGE OUT DISTR |:EX20000|500 |481 |
|9 | PX PARTITION ITERATOR| |500 |387 |
|10| TABLE SCAN |t1 |500 |387 |
|11| MATERIAL | |200 |314 |
|12| PX COORDINATOR | |200 |310 |
|13| EXCHANGE OUT DISTR |:EX30000|200 |261 |
|14| PX PARTITION ITERATOR | |200 |155 |
|15| TABLE SCAN |t3 |200 |155 |
==========================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3], [t3.c1], [t3.c2], [t3.c3]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds([t2.c1 + t1.c1 > ?]), nl_params_(nil)
2 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
5 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
6 - output([t1.c1], [t1.c2]), filter(nil)
7 - output([t1.c1], [t1.c2]), filter(nil)
8 - output([t1.c1], [t1.c2]), filter(nil), dop=1
9 - output([t1.c1], [t1.c2]), filter(nil)
10 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
11 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil)
12 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil)
13 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil), dop=1
14 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil)
15 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil),
access([t3.c1], [t3.c2], [t3.c3]), partitions(p[0-1])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$4D615D57" (("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1") "opt"."t3"@"SEL$1"))
USE_NL(@"SEL$4D615D57" "opt"."t3"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$4D615D57" "opt"."t3"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$4D615D57" "opt"."t3"@"SEL$1")
USE_NL(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$4D615D57" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t2"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t1"@"SEL$1")
FULL(@"SEL$4D615D57" "opt"."t3"@"SEL$1")
SIMPLIFY_SUBQUERY(@"SEL$1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" (("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" )"opt.t3"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t3"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t3"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t3"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t3"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 57(end) **************
*************** Case 58 ***************
SQL: select * from t1,t2,t3 where (t2.c1 + t1.c1) > (select t4.c1 from t4, t5);
================================================================
|ID|OPERATOR |NAME |EST. ROWS|COST |
----------------------------------------------------------------
|0 |SUBPLAN FILTER | |10000000 |1472709|
|1 | NESTED-LOOP JOIN CARTESIAN| |10000000 |1294528|
|2 | NESTED-LOOP JOIN | |50000 |5029 |
|3 | PX COORDINATOR | |300 |464 |
|4 | EXCHANGE OUT DISTR |:EX10000 |300 |391 |
|5 | PX PARTITION ITERATOR | |300 |233 |
|6 | TABLE SCAN |t2 |300 |233 |
|7 | MATERIAL | |500 |531 |
|8 | PX COORDINATOR | |500 |528 |
|9 | EXCHANGE OUT DISTR |:EX20000 |500 |481 |
|10| PX PARTITION ITERATOR| |500 |387 |
|11| TABLE SCAN |t1 |500 |387 |
|12| MATERIAL | |200 |314 |
|13| PX COORDINATOR | |200 |310 |
|14| EXCHANGE OUT DISTR |:EX30000 |200 |261 |
|15| PX PARTITION ITERATOR | |200 |155 |
|16| TABLE SCAN |t3 |200 |155 |
|17| NESTED-LOOP JOIN CARTESIAN| |30000 |2938 |
|18| TABLE SCAN |t4(idx_t4_c2)|100 |78 |
|19| MATERIAL | |300 |281 |
|20| PX COORDINATOR | |300 |280 |
|21| EXCHANGE OUT DISTR |:EX40000 |300 |263 |
|22| PX PARTITION ITERATOR | |300 |233 |
|23| TABLE SCAN |t5(idx_t5_c2)|300 |233 |
================================================================
Outputs & filters:
-------------------------------------
0 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3], [t3.c1], [t3.c2], [t3.c3]), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)]), init_plan_idxs_(nil)
1 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3], [t3.c1], [t3.c2], [t3.c3]), filter(nil),
conds(nil), nl_params_(nil)
2 - output([t1.c1], [t1.c2], [t2.c1], [t2.c2], [t2.c3]), filter(nil),
conds([t2.c1 + t1.c1 > ?]), nl_params_(nil)
3 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
4 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil), dop=1
5 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil)
6 - output([t2.c1], [t2.c2], [t2.c3]), filter(nil),
access([t2.c1], [t2.c2], [t2.c3]), partitions(p[0-2])
7 - output([t1.c1], [t1.c2]), filter(nil)
8 - output([t1.c1], [t1.c2]), filter(nil)
9 - output([t1.c1], [t1.c2]), filter(nil), dop=1
10 - output([t1.c1], [t1.c2]), filter(nil)
11 - output([t1.c1], [t1.c2]), filter(nil),
access([t1.c1], [t1.c2]), partitions(p[0-4])
12 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil)
13 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil)
14 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil), dop=1
15 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil)
16 - output([t3.c1], [t3.c2], [t3.c3]), filter(nil),
access([t3.c1], [t3.c2], [t3.c3]), partitions(p[0-1])
17 - output([t4.c1]), filter(nil),
conds(nil), nl_params_(nil)
18 - output([t4.c1]), filter(nil),
access([t4.c1]), partitions(p0)
19 - output(nil), filter(nil)
20 - output(nil), filter(nil)
21 - output(nil), filter(nil), dop=1
22 - output(nil), filter(nil)
23 - output(nil), filter(nil),
access([t5.c2]), partitions(p[0-2])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$1" (("opt"."t2"@"SEL$1" "opt"."t1"@"SEL$1") "opt"."t3"@"SEL$1"))
USE_NL(@"SEL$1" "opt"."t3"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t3"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" "opt"."t3"@"SEL$1")
USE_NL(@"SEL$1" "opt"."t1"@"SEL$1")
PQ_DISTRIBUTE(@"SEL$1" "opt"."t1"@"SEL$1" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t3"@"SEL$1")
LEADING(@"SEL$2" ("opt"."t4"@"SEL$2" "opt"."t5"@"SEL$2"))
USE_NL(@"SEL$2" "opt"."t5"@"SEL$2")
PQ_DISTRIBUTE(@"SEL$2" "opt"."t5"@"SEL$2" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" "opt"."t5"@"SEL$2")
INDEX(@"SEL$2" "opt"."t4"@"SEL$2" "idx_t4_c2")
INDEX(@"SEL$2" "opt"."t5"@"SEL$2" "idx_t5_c2")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" (("opt.t2"@"SEL$1" "opt.t1"@"SEL$1" )"opt.t3"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t3"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t3"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t3"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t2"@"SEL$1")
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$1" "opt"."t3"@"SEL$1")
LEADING(@"SEL$2" ("opt.t4"@"SEL$2" "opt.t5"@"SEL$2" ))
USE_NL(@"SEL$2" ("opt.t5"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("opt.t5"@"SEL$2" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" ("opt.t5"@"SEL$2" ))
INDEX(@"SEL$2" "opt"."t4"@"SEL$2" "idx_t4_c2")
INDEX(@"SEL$2" "opt"."t5"@"SEL$2" "idx_t5_c2")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 58(end) **************
*************** Case 59 ***************
SQL: select 1 from t1 inner join t1 t2 using(c1) where t1.c1 < (select t3.c1 from t3) and t1.c1 > (select t4.c1 from t4);
==========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------------
|0 |SUBPLAN FILTER | |56 |502 |
|1 | PX COORDINATOR | |56 |237 |
|2 | EXCHANGE OUT DISTR |:EX10000 |56 |234 |
|3 | PX PARTITION ITERATOR| |56 |228 |
|4 | TABLE SCAN |t1 |56 |228 |
|5 | PX COORDINATOR | |200 |187 |
|6 | EXCHANGE OUT DISTR |:EX20000 |200 |176 |
|7 | PX PARTITION ITERATOR| |200 |155 |
|8 | TABLE SCAN |t3 |200 |155 |
|9 | TABLE SCAN |t4(idx_t4_c2)|100 |78 |
==========================================================
Outputs & filters:
-------------------------------------
0 - output([?]), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)], [subquery(2)]), init_plan_idxs_(nil)
1 - output(nil), filter(nil)
2 - output(nil), filter(nil), dop=1
3 - output(nil), filter(nil)
4 - output(nil), filter(nil),
access([t1.c1]), partitions(p[0-4])
5 - output([t3.c1]), filter(nil)
6 - output([t3.c1]), filter(nil), dop=1
7 - output([t3.c1]), filter(nil)
8 - output([t3.c1]), filter(nil),
access([t3.c1]), partitions(p[0-1])
9 - output([t4.c1]), filter(nil),
access([t4.c1]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
FULL(@"SEL$488F0C13" "opt"."t1"@"SEL$1")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
INDEX(@"SEL$3" "opt"."t4"@"SEL$3" "idx_t4_c2")
OUTER_TO_INNER(@"SEL$1")
ELIMINATE_JOIN(@"SEL$C6D21C0F" "opt"."t2"@"SEL$C6D21C0F")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
INDEX(@"SEL$3" "opt"."t4"@"SEL$3" "idx_t4_c2")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 59(end) **************
*************** Case 60 ***************
SQL: select 1 from t1 inner join t1 t2 using(c1) where t1.c1 < (select t3.c1 from t3) order by (select t4.c1 from t4);
===========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-----------------------------------------------------------
|0 |SUBPLAN FILTER | |167 |526 |
|1 | SUBPLAN FILTER | |167 |446 |
|2 | PX COORDINATOR | |167 |257 |
|3 | EXCHANGE OUT DISTR |:EX10000 |167 |247 |
|4 | PX PARTITION ITERATOR| |167 |230 |
|5 | TABLE SCAN |t1 |167 |230 |
|6 | PX COORDINATOR | |200 |187 |
|7 | EXCHANGE OUT DISTR |:EX20000 |200 |176 |
|8 | PX PARTITION ITERATOR| |200 |155 |
|9 | TABLE SCAN |t3 |200 |155 |
|10| TABLE SCAN |t4(idx_t4_c2)|100 |78 |
===========================================================
Outputs & filters:
-------------------------------------
0 - output([?]), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)]), init_plan_idxs_(nil)
1 - output(nil), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)]), init_plan_idxs_(nil)
2 - output(nil), filter(nil)
3 - output(nil), filter(nil), dop=1
4 - output(nil), filter(nil)
5 - output(nil), filter(nil),
access([t1.c1]), partitions(p[0-4])
6 - output([t3.c1]), filter(nil)
7 - output([t3.c1]), filter(nil), dop=1
8 - output([t3.c1]), filter(nil)
9 - output([t3.c1]), filter(nil),
access([t3.c1]), partitions(p[0-1])
10 - output([t4.c1]), filter(nil),
access([t4.c1]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
FULL(@"SEL$488F0C13" "opt"."t1"@"SEL$1")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
INDEX(@"SEL$3" "opt"."t4"@"SEL$3" "idx_t4_c2")
OUTER_TO_INNER(@"SEL$1")
ELIMINATE_JOIN(@"SEL$C6D21C0F" "opt"."t2"@"SEL$C6D21C0F")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
INDEX(@"SEL$3" "opt"."t4"@"SEL$3" "idx_t4_c2")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 60(end) **************
*************** Case 61 ***************
SQL: select 1 from t1 inner join t1 t2 using(c1) where t1.c1 < (select t4.c1 from t3, t4);
=============================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
-------------------------------------------------------------
|0 |SUBPLAN FILTER | |167 |3104|
|1 | PX COORDINATOR | |167 |257 |
|2 | EXCHANGE OUT DISTR |:EX10000 |167 |247 |
|3 | PX PARTITION ITERATOR | |167 |230 |
|4 | TABLE SCAN |t1 |167 |230 |
|5 | NESTED-LOOP JOIN CARTESIAN| |20000 |2845|
|6 | TABLE SCAN |t4(idx_t4_c2)|100 |78 |
|7 | MATERIAL | |200 |188 |
|8 | PX COORDINATOR | |200 |187 |
|9 | EXCHANGE OUT DISTR |:EX20000 |200 |176 |
|10| PX PARTITION ITERATOR | |200 |155 |
|11| TABLE SCAN |t3 |200 |155 |
=============================================================
Outputs & filters:
-------------------------------------
0 - output([?]), filter(nil),
exec_params_(nil), onetime_exprs_([subquery(1)]), init_plan_idxs_(nil)
1 - output(nil), filter(nil)
2 - output(nil), filter(nil), dop=1
3 - output(nil), filter(nil)
4 - output(nil), filter(nil),
access([t1.c1]), partitions(p[0-4])
5 - output([t4.c1]), filter(nil),
conds(nil), nl_params_(nil)
6 - output([t4.c1]), filter(nil),
access([t4.c1]), partitions(p0)
7 - output(nil), filter(nil)
8 - output(nil), filter(nil)
9 - output(nil), filter(nil), dop=1
10 - output(nil), filter(nil)
11 - output(nil), filter(nil),
access([t3.c1]), partitions(p[0-1])
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
FULL(@"SEL$488F0C13" "opt"."t1"@"SEL$1")
LEADING(@"SEL$2" ("opt"."t4"@"SEL$2" "opt"."t3"@"SEL$2"))
USE_NL(@"SEL$2" "opt"."t3"@"SEL$2")
PQ_DISTRIBUTE(@"SEL$2" "opt"."t3"@"SEL$2" LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" "opt"."t3"@"SEL$2")
INDEX(@"SEL$2" "opt"."t4"@"SEL$2" "idx_t4_c2")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
OUTER_TO_INNER(@"SEL$1")
ELIMINATE_JOIN(@"SEL$C6D21C0F" "opt"."t2"@"SEL$C6D21C0F")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
FULL(@"SEL$1" "opt"."t1"@"SEL$1")
LEADING(@"SEL$2" ("opt.t4"@"SEL$2" "opt.t3"@"SEL$2" ))
USE_NL(@"SEL$2" ("opt.t3"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("opt.t3"@"SEL$2" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" ("opt.t3"@"SEL$2" ))
INDEX(@"SEL$2" "opt"."t4"@"SEL$2" "idx_t4_c2")
FULL(@"SEL$2" "opt"."t3"@"SEL$2")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 61(end) **************
*************** Case 62 ***************
SQL: select /*+qb_name(select_1)*/* from t4;
===================================
|ID|OPERATOR |NAME|EST. ROWS|COST|
-----------------------------------
|0 |TABLE SCAN|t4 |100 |78 |
===================================
Outputs & filters:
-------------------------------------
0 - output([t4.c1], [t4.c2], [t4.c3]), filter(nil),
access([t4.c1], [t4.c2], [t4.c3]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
FULL(@"SELECT_1" "opt"."t4"@"SELECT_1")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
FULL(@"SEL$1" "opt"."t4"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 62(end) **************
*************** Case 63 ***************
SQL: select /*+qb_name(select_1) qb_name(select_2)*/* from t4;
===================================
|ID|OPERATOR |NAME|EST. ROWS|COST|
-----------------------------------
|0 |TABLE SCAN|t4 |100 |78 |
===================================
Outputs & filters:
-------------------------------------
0 - output([t4.c1], [t4.c2], [t4.c3]), filter(nil),
access([t4.c1], [t4.c2], [t4.c3]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
FULL(@"SEL$1" "opt"."t4"@"SEL$1")
<<<<<<< HEAD
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 63(end) **************
*************** Case 64 ***************
SQL: select t20.c1 from t20 join t0 where t0.c1 in (select t7.c1 from t7 join t8);
========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
--------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |9000 |5731|
|1 | TABLE SCAN |t20 |100 |78 |
|2 | MATERIAL | |90 |3332|
|3 | MERGE SEMI JOIN | |90 |3331|
|4 | SORT | |100 |133 |
|5 | TABLE SCAN |t0 |100 |78 |
|6 | SUBPLAN SCAN |VIEW1|10000 |2911|
|7 | NESTED-LOOP JOIN CARTESIAN| |10000 |2736|
|8 | TABLE SCAN |t7 |100 |78 |
|9 | MATERIAL | |100 |78 |
|10| TABLE SCAN |t8 |100 |78 |
========================================================
Outputs & filters:
-------------------------------------
0 - output([t20.c1]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t20.c1]), filter(nil),
access([t20.c1]), partitions(p0)
2 - output(nil), filter(nil)
3 - output(nil), filter(nil),
equal_conds([t0.c1 = VIEW1.c1]), other_conds(nil)
4 - output([t0.c1]), filter(nil), sort_keys([t0.c1, ASC])
5 - output([t0.c1]), filter(nil),
access([t0.c1]), partitions(p0)
6 - output([VIEW1.c1]), filter(nil),
access([VIEW1.c1])
7 - output([t7.c1]), filter(nil),
conds(nil), nl_params_(nil)
8 - output([t7.c1]), filter(nil),
access([t7.c1]), partitions(p0)
9 - output(nil), filter(nil)
10 - output(nil), filter(nil),
access([t8.c1]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$6816FF38" ("opt"."t20"@"SEL$1" ("opt"."t0"@"SEL$1" "VIEW1"@"SEL$1")))
USE_NL(@"SEL$6816FF38" ("opt"."t0"@"SEL$1" "VIEW1"@"SEL$1"))
USE_NL_MATERIALIZATION(@"SEL$6816FF38" ("opt"."t0"@"SEL$1" "VIEW1"@"SEL$1"))
FULL(@"SEL$6816FF38" "opt"."t20"@"SEL$1")
USE_MERGE(@"SEL$6816FF38" "VIEW1"@"SEL$1")
FULL(@"SEL$6816FF38" "opt"."t0"@"SEL$1")
LEADING(@"SEL$9DC52427" ("opt"."t7"@"SEL$2" "opt"."t8"@"SEL$2"))
USE_NL(@"SEL$9DC52427" "opt"."t8"@"SEL$2")
USE_NL_MATERIALIZATION(@"SEL$9DC52427" "opt"."t8"@"SEL$2")
FULL(@"SEL$9DC52427" "opt"."t7"@"SEL$2")
FULL(@"SEL$9DC52427" "opt"."t8"@"SEL$2")
UNNEST(@"SEL$2")
OUTER_TO_INNER(@"SEL$2")
OUTER_TO_INNER(@"SEL$6FCAE2AA")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t20"@"SEL$1" ("opt.t0"@"SEL$1" "VIEW1"@"SEL$1" )))
USE_NL(@"SEL$1" ("opt.t0"@"SEL$1" "VIEW1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t0"@"SEL$1" "VIEW1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t0"@"SEL$1" "VIEW1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t20"@"SEL$1")
USE_MERGE(@"SEL$1" ("VIEW1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("VIEW1"@"SEL$1" ) LOCAL LOCAL)
FULL(@"SEL$1" "opt"."t0"@"SEL$1")
LEADING(@"SEL$2" ("opt.t7"@"SEL$2" "opt.t8"@"SEL$2" ))
USE_NL(@"SEL$2" ("opt.t8"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("opt.t8"@"SEL$2" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" ("opt.t8"@"SEL$2" ))
FULL(@"SEL$2" "opt"."t7"@"SEL$2")
FULL(@"SEL$2" "opt"."t8"@"SEL$2")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 64(end) **************
*************** Case 65 ***************
SQL: select t20.c1 from t20 join t0 join (t7 left join t8 on t7.c1 = t8.c1);
======================================================
|ID|OPERATOR |NAME|EST. ROWS|COST |
------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |1000000 |260652|
|1 | NESTED-LOOP JOIN CARTESIAN| |10000 |2736 |
|2 | TABLE SCAN |t20 |100 |78 |
|3 | MATERIAL | |100 |78 |
|4 | TABLE SCAN |t0 |100 |78 |
|5 | MATERIAL | |100 |78 |
|6 | TABLE SCAN |t7 |100 |78 |
======================================================
Outputs & filters:
-------------------------------------
0 - output([t20.c1]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t20.c1]), filter(nil),
conds(nil), nl_params_(nil)
2 - output([t20.c1]), filter(nil),
access([t20.c1]), partitions(p0)
3 - output(nil), filter(nil)
4 - output(nil), filter(nil),
access([t0.pk]), partitions(p0)
5 - output(nil), filter(nil)
6 - output(nil), filter(nil),
access([t7.c1]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$488F0C13" (("opt"."t20"@"SEL$1" "opt"."t0"@"SEL$1") "opt"."t7"@"SEL$1"))
USE_NL(@"SEL$488F0C13" "opt"."t7"@"SEL$1")
USE_NL_MATERIALIZATION(@"SEL$488F0C13" "opt"."t7"@"SEL$1")
USE_NL(@"SEL$488F0C13" "opt"."t0"@"SEL$1")
USE_NL_MATERIALIZATION(@"SEL$488F0C13" "opt"."t0"@"SEL$1")
FULL(@"SEL$488F0C13" "opt"."t20"@"SEL$1")
FULL(@"SEL$488F0C13" "opt"."t0"@"SEL$1")
FULL(@"SEL$488F0C13" "opt"."t7"@"SEL$1")
OUTER_TO_INNER(@"SEL$1")
ELIMINATE_JOIN(@"SEL$C6D21C0F" "opt"."t8"@"SEL$C6D21C0F")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" (("opt.t20"@"SEL$1" "opt.t0"@"SEL$1" )"opt.t7"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t7"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t7"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t7"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t0"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t0"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t0"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t20"@"SEL$1")
FULL(@"SEL$1" "opt"."t0"@"SEL$1")
FULL(@"SEL$1" "opt"."t7"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 65(end) **************
*************** Case 66 ***************
SQL: select t20.c1 from t20 left join (t7 left join t8 on t7.c1 = t8.c1) on t20.c1 = t7.c1 join t0;
===================================================
|ID|OPERATOR |NAME|EST. ROWS|COST|
---------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN| |10000 |2736|
|1 | TABLE SCAN |t20 |100 |78 |
|2 | MATERIAL | |100 |78 |
|3 | TABLE SCAN |t0 |100 |78 |
===================================================
Outputs & filters:
-------------------------------------
0 - output([t20.c1]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t20.c1]), filter(nil),
access([t20.c1]), partitions(p0)
2 - output(nil), filter(nil)
3 - output(nil), filter(nil),
access([t0.pk]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$488F0C13" ("opt"."t20"@"SEL$1" "opt"."t0"@"SEL$1"))
USE_NL(@"SEL$488F0C13" "opt"."t0"@"SEL$1")
USE_NL_MATERIALIZATION(@"SEL$488F0C13" "opt"."t0"@"SEL$1")
FULL(@"SEL$488F0C13" "opt"."t20"@"SEL$1")
FULL(@"SEL$488F0C13" "opt"."t0"@"SEL$1")
OUTER_TO_INNER(@"SEL$1")
ELIMINATE_JOIN(@"SEL$C6D21C0F" ("opt"."t7"@"SEL$C6D21C0F" "opt"."t8"@"SEL$C6D21C0F"))
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t20"@"SEL$1" "opt.t0"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t0"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t0"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t0"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t20"@"SEL$1")
FULL(@"SEL$1" "opt"."t0"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 66(end) **************
*************** Case 67 ***************
SQL: select t20.c1 from t20 join t0 where t0.c1 in (select max(t7.c1) from t7 join t8);
=========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
---------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |900 |3485|
|1 | TABLE SCAN |t20 |100 |78 |
|2 | MATERIAL | |9 |3174|
|3 | NESTED-LOOP JOIN | |9 |3174|
|4 | SUBPLAN SCAN |VIEW1|1 |3090|
|5 | SCALAR GROUP BY | |1 |3090|
|6 | NESTED-LOOP JOIN CARTESIAN| |10000 |2736|
|7 | TABLE SCAN |t7 |100 |78 |
|8 | MATERIAL | |100 |78 |
|9 | TABLE SCAN |t8 |100 |78 |
|10| TABLE SCAN |t0 |100 |78 |
=========================================================
Outputs & filters:
-------------------------------------
0 - output([t20.c1]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t20.c1]), filter(nil),
access([t20.c1]), partitions(p0)
2 - output(nil), filter(nil)
3 - output(nil), filter(nil),
conds([t0.c1 = VIEW1.max(t7.c1)]), nl_params_(nil)
4 - output([VIEW1.max(t7.c1)]), filter(nil),
access([VIEW1.max(t7.c1)])
5 - output([T_FUN_MAX(t7.c1)]), filter(nil),
group(nil), agg_func([T_FUN_MAX(t7.c1)])
6 - output([t7.c1]), filter(nil),
conds(nil), nl_params_(nil)
7 - output([t7.c1]), filter(nil),
access([t7.c1]), partitions(p0)
8 - output(nil), filter(nil)
9 - output(nil), filter(nil),
access([t8.c1]), partitions(p0)
10 - output([t0.c1]), filter(nil),
access([t0.c1]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$F70B38FF" ("opt"."t20"@"SEL$1" ("VIEW1"@"SEL$1" "opt"."t0"@"SEL$1")))
USE_NL(@"SEL$F70B38FF" ("opt"."t0"@"SEL$1" "VIEW1"@"SEL$1"))
USE_NL_MATERIALIZATION(@"SEL$F70B38FF" ("opt"."t0"@"SEL$1" "VIEW1"@"SEL$1"))
FULL(@"SEL$F70B38FF" "opt"."t20"@"SEL$1")
USE_NL(@"SEL$F70B38FF" "opt"."t0"@"SEL$1")
LEADING(@"SEL$9DC52427" ("opt"."t7"@"SEL$2" "opt"."t8"@"SEL$2"))
USE_NL(@"SEL$9DC52427" "opt"."t8"@"SEL$2")
USE_NL_MATERIALIZATION(@"SEL$9DC52427" "opt"."t8"@"SEL$2")
FULL(@"SEL$9DC52427" "opt"."t7"@"SEL$2")
FULL(@"SEL$9DC52427" "opt"."t8"@"SEL$2")
FULL(@"SEL$F70B38FF" "opt"."t0"@"SEL$1")
UNNEST(@"SEL$2")
SEMI_TO_INNER(@"SEL$6FCAE2AA" "VIEW1")
OUTER_TO_INNER(@"SEL$2")
OUTER_TO_INNER(@"SEL$E5385516")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t20"@"SEL$1" ("VIEW1"@"SEL$1" "opt.t0"@"SEL$1" )))
USE_NL(@"SEL$1" ("VIEW1"@"SEL$1" "opt.t0"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("VIEW1"@"SEL$1" "opt.t0"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("VIEW1"@"SEL$1" "opt.t0"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t20"@"SEL$1")
USE_NL(@"SEL$1" ("opt.t0"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t0"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t0"@"SEL$1" ))
LEADING(@"SEL$2" ("opt.t7"@"SEL$2" "opt.t8"@"SEL$2" ))
USE_NL(@"SEL$2" ("opt.t8"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("opt.t8"@"SEL$2" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" ("opt.t8"@"SEL$2" ))
FULL(@"SEL$2" "opt"."t7"@"SEL$2")
FULL(@"SEL$2" "opt"."t8"@"SEL$2")
FULL(@"SEL$1" "opt"."t0"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 67(end) **************
*************** Case 68 ***************
SQL: select t20.c1 from t20 join t0 where t0.c1 in (select max(t7.c1) from t7 join t8) and t0.c1 in (select max(t7.c2) from t7);
====================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
----------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN| |45 |178 |
|1 | TABLE SCAN |t20 |100 |78 |
|2 | MATERIAL | |1 |87 |
|3 | NESTED-LOOP JOIN | |1 |87 |
|4 | SUBPLAN SCAN |VIEW3|1 |83 |
|5 | SCALAR GROUP BY | |1 |83 |
|6 | TABLE SCAN |t7 |100 |78 |
|7 | TABLE SCAN |t0 |100 |78 |
====================================================
Outputs & filters:
-------------------------------------
0 - output([t20.c1]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t20.c1]), filter(nil),
access([t20.c1]), partitions(p0)
2 - output(nil), filter(nil)
3 - output(nil), filter(nil),
conds([t0.c1 = VIEW3.T_FUN_MAX(t7.c1)]), nl_params_(nil)
4 - output([VIEW3.T_FUN_MAX(t7.c1)]), filter(nil),
access([VIEW3.T_FUN_MAX(t7.c1)])
5 - output([T_FUN_MAX(t7.c2)], [T_FUN_MAX(t7.c1)]), filter([T_FUN_MAX(t7.c1) = T_FUN_MAX(t7.c2)]),
group(nil), agg_func([T_FUN_MAX(t7.c2)], [T_FUN_MAX(t7.c1)])
6 - output([t7.c1], [t7.c2]), filter(nil),
access([t7.c1], [t7.c2]), partitions(p0)
7 - output([t0.c1]), filter(nil),
access([t0.c1]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$E3C5A5E7" ("opt"."t20"@"SEL$1" ("VIEW3"@"SEL$E4C97F16" "opt"."t0"@"SEL$1")))
USE_NL(@"SEL$E3C5A5E7" ("opt"."t0"@"SEL$1" "VIEW3"@"SEL$E4C97F16"))
USE_NL_MATERIALIZATION(@"SEL$E3C5A5E7" ("opt"."t0"@"SEL$1" "VIEW3"@"SEL$E4C97F16"))
FULL(@"SEL$E3C5A5E7" "opt"."t20"@"SEL$1")
USE_NL(@"SEL$E3C5A5E7" "opt"."t0"@"SEL$1")
FULL(@"SEL$3" "opt"."t7"@"SEL$3")
FULL(@"SEL$E3C5A5E7" "opt"."t0"@"SEL$1")
UNNEST(@"SEL$2")
UNNEST(@"SEL$3")
SEMI_TO_INNER(@"SEL$F6B5C6D7" ("VIEW1" "VIEW2"))
OUTER_TO_INNER(@"SEL$2")
OUTER_TO_INNER(@"SEL$A4C9DBFA")
SIMPLIFY_WINFUNC(@"SEL$E4C97F16")
MERGE(@"SEL$05266C8A" > "SEL$E4C97F18")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" ("opt.t20"@"SEL$1" ("VIEW3"@"SEL$1" "opt.t0"@"SEL$1" )))
USE_NL(@"SEL$1" ("VIEW3"@"SEL$1" "opt.t0"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("VIEW3"@"SEL$1" "opt.t0"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("VIEW3"@"SEL$1" "opt.t0"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t20"@"SEL$1")
USE_NL(@"SEL$1" ("opt.t0"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t0"@"SEL$1" ) LOCAL LOCAL)
NO_USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t0"@"SEL$1" ))
FULL(@"SEL$3" "opt"."t7"@"SEL$3")
FULL(@"SEL$1" "opt"."t0"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 68(end) **************
*************** Case 69 ***************
SQL: select t20.c1 from t20 join t0 where 1 in (select t7.c1 from t7 join t8);
=========================================================
|ID|OPERATOR |NAME |EST. ROWS|COST|
---------------------------------------------------------
|0 |NESTED-LOOP JOIN CARTESIAN | |10000 |2854|
|1 | NESTED-LOOP JOIN CARTESIAN | |100 |196 |
|2 | TABLE SCAN |t20 |100 |78 |
|3 | MATERIAL | |1 |92 |
|4 | SUBPLAN SCAN |VIEW1|1 |92 |
|5 | LIMIT | |1 |92 |
|6 | NESTED-LOOP JOIN CARTESIAN| |1 |92 |
|7 | SUBPLAN SCAN |VIEW3|1 |46 |
|8 | TABLE SCAN |t8 |1 |46 |
|9 | MATERIAL | |1 |46 |
|10| SUBPLAN SCAN |VIEW2|1 |46 |
|11| TABLE GET |t7 |1 |46 |
|12| MATERIAL | |100 |78 |
|13| TABLE SCAN |t0 |100 |78 |
=========================================================
Outputs & filters:
-------------------------------------
0 - output([t20.c1]), filter(nil),
conds(nil), nl_params_(nil)
1 - output([t20.c1]), filter(nil),
conds(nil), nl_params_(nil)
2 - output([t20.c1]), filter(nil),
access([t20.c1]), partitions(p0)
3 - output(nil), filter(nil)
4 - output(nil), filter(nil),
access(nil)
5 - output([1]), filter(nil), limit(1), offset(nil)
6 - output(nil), filter(nil),
conds(nil), nl_params_(nil)
7 - output(nil), filter(nil),
access(nil)
8 - output([1]), filter(nil),
access([t8.c1]), partitions(p0),
limit(1), offset(nil)
9 - output(nil), filter(nil)
10 - output(nil), filter(nil),
access(nil)
11 - output([1]), filter(nil),
access([t7.c1]), partitions(p0),
limit(1), offset(nil)
12 - output(nil), filter(nil)
13 - output(nil), filter(nil),
access([t0.pk]), partitions(p0)
Outline Data:
-------------------------------------
/*+
BEGIN_OUTLINE_DATA
<<<<<<< HEAD
LEADING(@"SEL$E775832E" (("opt"."t20"@"SEL$1" "VIEW1"@"SEL$1") "opt"."t0"@"SEL$1"))
USE_NL(@"SEL$E775832E" "opt"."t0"@"SEL$1")
USE_NL_MATERIALIZATION(@"SEL$E775832E" "opt"."t0"@"SEL$1")
USE_NL(@"SEL$E775832E" "VIEW1"@"SEL$1")
USE_NL_MATERIALIZATION(@"SEL$E775832E" "VIEW1"@"SEL$1")
FULL(@"SEL$E775832E" "opt"."t20"@"SEL$1")
LEADING(@"SEL$6E616CF1" ("VIEW3"@"SEL$9DC52427" "VIEW2"@"SEL$9DC52427"))
USE_NL(@"SEL$6E616CF1" "VIEW2"@"SEL$9DC52427")
USE_NL_MATERIALIZATION(@"SEL$6E616CF1" "VIEW2"@"SEL$9DC52427")
FULL(@"SEL$9F3B17F5" "opt"."t8"@"SEL$2")
FULL(@"SEL$9F3B17F4" "opt"."t7"@"SEL$2")
FULL(@"SEL$E775832E" "opt"."t0"@"SEL$1")
UNNEST(@"SEL$2")
SEMI_TO_INNER(@"SEL$6FCAE2AA" "VIEW1")
OUTER_TO_INNER(@"SEL$2")
OUTER_TO_INNER(@"SEL$E5385516")
PUSH_LIMIT(@"SEL$9DC52427")
PROJECT_PRUNE(@"SEL$F70B38FF")
PROJECT_PRUNE(@"SEL$9F3B17F6")
OPTIMIZER_FEATURES_ENABLE('4.0.0.0')
=======
LEADING(@"SEL$1" (("opt.t20"@"SEL$1" "VIEW1"@"SEL$1" )"opt.t0"@"SEL$1" ))
USE_NL(@"SEL$1" ("opt.t0"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("opt.t0"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("opt.t0"@"SEL$1" ))
USE_NL(@"SEL$1" ("VIEW1"@"SEL$1" ))
PQ_DISTRIBUTE(@"SEL$1" ("VIEW1"@"SEL$1" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$1" ("VIEW1"@"SEL$1" ))
FULL(@"SEL$1" "opt"."t20"@"SEL$1")
LEADING(@"SEL$2" ("VIEW3"@"SEL$2" "VIEW2"@"SEL$2" ))
USE_NL(@"SEL$2" ("VIEW2"@"SEL$2" ))
PQ_DISTRIBUTE(@"SEL$2" ("VIEW2"@"SEL$2" ) LOCAL LOCAL)
USE_NL_MATERIALIZATION(@"SEL$2" ("VIEW2"@"SEL$2" ))
FULL(@"SEL$4" "opt"."t8"@"SEL$4")
FULL(@"SEL$3" "opt"."t7"@"SEL$3")
FULL(@"SEL$1" "opt"."t0"@"SEL$1")
>>>>>>> implement spm part1
END_OUTLINE_DATA
*/
*************** Case 69(end) **************
Reference in New Issue View Git Blame Copy Permalink