http://git-wip-us.apache.org/repos/asf/hive/blob/83d1fd23/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out
index 7678363..f848093 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out
@@ -1,7 +1,7 @@
-Warning: Shuffle Join MERGEJOIN[437][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 19' is a cross product
-Warning: Shuffle Join MERGEJOIN[438][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 20' is a cross product
-Warning: Shuffle Join MERGEJOIN[440][tables = [$hdt$_2, $hdt$_3]] in Stage 
'Reducer 23' is a cross product
-Warning: Shuffle Join MERGEJOIN[441][tables = [$hdt$_2, $hdt$_3, $hdt$_1]] in 
Stage 'Reducer 24' is a cross product
+Warning: Shuffle Join MERGEJOIN[443][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 19' is a cross product
+Warning: Shuffle Join MERGEJOIN[444][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 20' is a cross product
+Warning: Shuffle Join MERGEJOIN[446][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 23' is a cross product
+Warning: Shuffle Join MERGEJOIN[447][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 24' is a cross product
 PREHOOK: query: explain
 with frequent_ss_items as 
  (select substr(i_item_desc,1,30) itemdesc,i_item_sk item_sk,d_date 
solddate,count(*) cnt
@@ -123,13 +123,13 @@ Plan optimized by CBO.
 Vertex dependency in root stage
 Map 1 <- Reducer 9 (BROADCAST_EDGE)
 Map 15 <- Reducer 27 (BROADCAST_EDGE)
-Map 33 <- Reducer 7 (BROADCAST_EDGE)
-Map 35 <- Reducer 32 (BROADCAST_EDGE)
-Map 37 <- Reducer 14 (BROADCAST_EDGE)
-Map 38 <- Reducer 13 (BROADCAST_EDGE)
-Reducer 10 <- Map 37 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
+Map 28 <- Reducer 7 (BROADCAST_EDGE)
+Map 30 <- Reducer 36 (BROADCAST_EDGE)
+Map 38 <- Reducer 14 (BROADCAST_EDGE)
+Map 39 <- Reducer 13 (BROADCAST_EDGE)
+Reducer 10 <- Map 38 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
 Reducer 11 <- Reducer 10 (SIMPLE_EDGE), Reducer 24 (SIMPLE_EDGE)
-Reducer 12 <- Reducer 11 (SIMPLE_EDGE), Reducer 31 (ONE_TO_ONE_EDGE), Union 5 
(CONTAINS)
+Reducer 12 <- Reducer 11 (SIMPLE_EDGE), Reducer 34 (SIMPLE_EDGE), Union 5 
(CONTAINS)
 Reducer 13 <- Reducer 10 (CUSTOM_SIMPLE_EDGE)
 Reducer 14 <- Map 8 (CUSTOM_SIMPLE_EDGE)
 Reducer 16 <- Map 15 (SIMPLE_EDGE), Map 26 (SIMPLE_EDGE)
@@ -137,22 +137,22 @@ Reducer 17 <- Reducer 16 (SIMPLE_EDGE)
 Reducer 18 <- Reducer 17 (CUSTOM_SIMPLE_EDGE)
 Reducer 19 <- Reducer 18 (CUSTOM_SIMPLE_EDGE), Reducer 21 (CUSTOM_SIMPLE_EDGE)
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
-Reducer 20 <- Reducer 19 (CUSTOM_SIMPLE_EDGE), Reducer 34 (CUSTOM_SIMPLE_EDGE)
+Reducer 20 <- Reducer 19 (CUSTOM_SIMPLE_EDGE), Reducer 29 (CUSTOM_SIMPLE_EDGE)
 Reducer 21 <- Reducer 17 (CUSTOM_SIMPLE_EDGE)
 Reducer 22 <- Reducer 17 (CUSTOM_SIMPLE_EDGE)
 Reducer 23 <- Reducer 22 (CUSTOM_SIMPLE_EDGE), Reducer 25 (CUSTOM_SIMPLE_EDGE)
-Reducer 24 <- Reducer 23 (CUSTOM_SIMPLE_EDGE), Reducer 39 (CUSTOM_SIMPLE_EDGE)
+Reducer 24 <- Reducer 23 (CUSTOM_SIMPLE_EDGE), Reducer 40 (CUSTOM_SIMPLE_EDGE)
 Reducer 25 <- Reducer 17 (CUSTOM_SIMPLE_EDGE)
 Reducer 27 <- Map 26 (CUSTOM_SIMPLE_EDGE)
-Reducer 28 <- Map 26 (SIMPLE_EDGE), Map 35 (SIMPLE_EDGE)
-Reducer 29 <- Map 36 (SIMPLE_EDGE), Reducer 28 (SIMPLE_EDGE)
+Reducer 29 <- Map 28 (SIMPLE_EDGE)
 Reducer 3 <- Reducer 2 (SIMPLE_EDGE), Reducer 20 (SIMPLE_EDGE)
-Reducer 30 <- Reducer 29 (SIMPLE_EDGE)
-Reducer 31 <- Reducer 29 (SIMPLE_EDGE)
-Reducer 32 <- Map 26 (CUSTOM_SIMPLE_EDGE)
-Reducer 34 <- Map 33 (SIMPLE_EDGE)
-Reducer 39 <- Map 38 (SIMPLE_EDGE)
-Reducer 4 <- Reducer 3 (SIMPLE_EDGE), Reducer 30 (ONE_TO_ONE_EDGE), Union 5 
(CONTAINS)
+Reducer 31 <- Map 30 (SIMPLE_EDGE), Map 35 (SIMPLE_EDGE)
+Reducer 32 <- Map 37 (SIMPLE_EDGE), Reducer 31 (SIMPLE_EDGE)
+Reducer 33 <- Reducer 32 (SIMPLE_EDGE)
+Reducer 34 <- Reducer 32 (SIMPLE_EDGE)
+Reducer 36 <- Map 35 (CUSTOM_SIMPLE_EDGE)
+Reducer 4 <- Reducer 3 (SIMPLE_EDGE), Reducer 33 (SIMPLE_EDGE), Union 5 
(CONTAINS)
+Reducer 40 <- Map 39 (SIMPLE_EDGE)
 Reducer 6 <- Union 5 (CUSTOM_SIMPLE_EDGE)
 Reducer 7 <- Reducer 2 (CUSTOM_SIMPLE_EDGE)
 Reducer 9 <- Map 8 (CUSTOM_SIMPLE_EDGE)
@@ -162,335 +162,348 @@ Stage-0
     limit:100
     Stage-1
       Reducer 6 vectorized
-      File Output Operator [FS_527]
-        Limit [LIM_526] (rows=1 width=112)
+      File Output Operator [FS_537]
+        Limit [LIM_536] (rows=1 width=112)
           Number of rows:100
-          Group By Operator [GBY_525] (rows=1 width=112)
+          Group By Operator [GBY_535] (rows=1 width=112)
             Output:["_col0"],aggregations:["sum(VALUE._col0)"]
           <-Union 5 [CUSTOM_SIMPLE_EDGE]
             <-Reducer 12 [CONTAINS]
-              Reduce Output Operator [RS_454]
-                Group By Operator [GBY_453] (rows=1 width=112)
+              Reduce Output Operator [RS_460]
+                Group By Operator [GBY_459] (rows=1 width=112)
                   Output:["_col0"],aggregations:["sum(_col0)"]
-                  Select Operator [SEL_451] (rows=52 width=112)
+                  Select Operator [SEL_457] (rows=155 width=112)
                     Output:["_col0"]
-                    Merge Join Operator [MERGEJOIN_450] (rows=52 width=2)
-                      
Conds:RS_192._col1=RS_552._col0(Inner),Output:["_col3","_col4"]
+                    Merge Join Operator [MERGEJOIN_456] (rows=155 width=0)
+                      Conds:RS_198._col1=RS_564._col0(Left 
Semi),Output:["_col3","_col4"]
                     <-Reducer 11 [SIMPLE_EDGE]
-                      SHUFFLE [RS_192]
+                      SHUFFLE [RS_198]
                         PartitionCols:_col1
-                        Merge Join Operator [MERGEJOIN_442] (rows=3941101 
width=118)
-                          
Conds:RS_189._col2=RS_190._col0(Inner),Output:["_col1","_col3","_col4"]
+                        Merge Join Operator [MERGEJOIN_448] (rows=3941101 
width=118)
+                          
Conds:RS_193._col2=RS_194._col0(Inner),Output:["_col1","_col3","_col4"]
                         <-Reducer 10 [SIMPLE_EDGE]
-                          PARTITION_ONLY_SHUFFLE [RS_189]
+                          PARTITION_ONLY_SHUFFLE [RS_193]
                             PartitionCols:_col2
-                            Merge Join Operator [MERGEJOIN_432] (rows=3941102 
width=122)
-                              
Conds:RS_532._col0=RS_459._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
+                            Merge Join Operator [MERGEJOIN_438] (rows=3941102 
width=122)
+                              
Conds:RS_542._col0=RS_465._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
                             <-Map 8 [SIMPLE_EDGE] vectorized
-                              PARTITION_ONLY_SHUFFLE [RS_459]
+                              PARTITION_ONLY_SHUFFLE [RS_465]
                                 PartitionCols:_col0
-                                Select Operator [SEL_456] (rows=50 width=4)
+                                Select Operator [SEL_462] (rows=50 width=4)
                                   Output:["_col0"]
-                                  Filter Operator [FIL_455] (rows=50 width=12)
+                                  Filter Operator [FIL_461] (rows=50 width=12)
                                     predicate:((d_moy = 1) and (d_year = 1999))
                                     TableScan [TS_3] (rows=73049 width=12)
                                       
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
-                            <-Map 37 [SIMPLE_EDGE] vectorized
-                              SHUFFLE [RS_532]
+                            <-Map 38 [SIMPLE_EDGE] vectorized
+                              SHUFFLE [RS_542]
                                 PartitionCols:_col0
-                                Select Operator [SEL_531] (rows=143930993 
width=127)
+                                Select Operator [SEL_541] (rows=143930993 
width=127)
                                   
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                  Filter Operator [FIL_530] (rows=143930993 
width=127)
-                                    predicate:((ws_sold_date_sk BETWEEN 
DynamicValue(RS_187_date_dim_d_date_sk_min) AND 
DynamicValue(RS_187_date_dim_d_date_sk_max) and 
in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_187_date_dim_d_date_sk_bloom_filter))) and ws_bill_customer_sk 
is not null and ws_sold_date_sk is not null)
-                                    TableScan [TS_98] (rows=144002668 
width=127)
+                                  Filter Operator [FIL_540] (rows=143930993 
width=127)
+                                    predicate:((ws_sold_date_sk BETWEEN 
DynamicValue(RS_191_date_dim_d_date_sk_min) AND 
DynamicValue(RS_191_date_dim_d_date_sk_max) and 
in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_191_date_dim_d_date_sk_bloom_filter))) and ws_bill_customer_sk 
is not null and ws_sold_date_sk is not null)
+                                    TableScan [TS_101] (rows=144002668 
width=127)
                                       
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk","ws_quantity","ws_list_price"]
                                     <-Reducer 14 [BROADCAST_EDGE] vectorized
-                                      BROADCAST [RS_529]
-                                        Group By Operator [GBY_528] (rows=1 
width=12)
+                                      BROADCAST [RS_539]
+                                        Group By Operator [GBY_538] (rows=1 
width=12)
                                           
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                         <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_464]
-                                            Group By Operator [GBY_462] 
(rows=1 width=12)
+                                          PARTITION_ONLY_SHUFFLE [RS_470]
+                                            Group By Operator [GBY_468] 
(rows=1 width=12)
                                               
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                              Select Operator [SEL_460] 
(rows=50 width=4)
+                                              Select Operator [SEL_466] 
(rows=50 width=4)
                                                 Output:["_col0"]
-                                                 Please refer to the previous 
Select Operator [SEL_456]
+                                                 Please refer to the previous 
Select Operator [SEL_462]
                         <-Reducer 24 [SIMPLE_EDGE]
-                          SHUFFLE [RS_190]
+                          SHUFFLE [RS_194]
                             PartitionCols:_col0
-                            Select Operator [SEL_165] (rows=471875 width=3)
+                            Select Operator [SEL_168] (rows=471875 width=3)
                               Output:["_col0"]
-                              Filter Operator [FIL_164] (rows=471875 width=227)
+                              Filter Operator [FIL_167] (rows=471875 width=227)
                                 predicate:(_col3 > (0.95 * _col1))
-                                Merge Join Operator [MERGEJOIN_441] 
(rows=1415626 width=227)
+                                Merge Join Operator [MERGEJOIN_447] 
(rows=1415626 width=227)
                                   
Conds:(Inner),Output:["_col1","_col2","_col3"]
                                 <-Reducer 23 [CUSTOM_SIMPLE_EDGE]
-                                  PARTITION_ONLY_SHUFFLE [RS_161]
-                                    Merge Join Operator [MERGEJOIN_440] 
(rows=1 width=112)
+                                  PARTITION_ONLY_SHUFFLE [RS_164]
+                                    Merge Join Operator [MERGEJOIN_446] 
(rows=1 width=112)
                                       Conds:(Inner),Output:["_col1"]
                                     <-Reducer 22 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                      PARTITION_ONLY_SHUFFLE [RS_538]
-                                        Select Operator [SEL_537] (rows=1 
width=8)
-                                          Filter Operator [FIL_536] (rows=1 
width=8)
+                                      PARTITION_ONLY_SHUFFLE [RS_548]
+                                        Select Operator [SEL_547] (rows=1 
width=8)
+                                          Filter Operator [FIL_546] (rows=1 
width=8)
                                             predicate:(sq_count_check(_col0) 
<= 1)
-                                            Group By Operator [GBY_535] 
(rows=1 width=8)
+                                            Group By Operator [GBY_545] 
(rows=1 width=8)
                                               
Output:["_col0"],aggregations:["count()"]
-                                              Select Operator [SEL_534] 
(rows=1 width=8)
-                                                Group By Operator [GBY_533] 
(rows=1 width=8)
+                                              Select Operator [SEL_544] 
(rows=1 width=8)
+                                                Group By Operator [GBY_543] 
(rows=1 width=8)
                                                   
Output:["_col0"],aggregations:["count(VALUE._col0)"]
                                                 <-Reducer 17 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                  PARTITION_ONLY_SHUFFLE 
[RS_496]
-                                                    Group By Operator 
[GBY_492] (rows=1 width=8)
+                                                  PARTITION_ONLY_SHUFFLE 
[RS_498]
+                                                    Group By Operator 
[GBY_494] (rows=1 width=8)
                                                       
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_488] (rows=50562 width=112)
+                                                      Select Operator 
[SEL_490] (rows=50562 width=112)
                                                         Output:["_col0"]
-                                                        Group By Operator 
[GBY_485] (rows=50562 width=112)
+                                                        Group By Operator 
[GBY_487] (rows=50562 width=112)
                                                           
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
                                                         <-Reducer 16 
[SIMPLE_EDGE]
                                                           SHUFFLE [RS_17]
                                                             PartitionCols:_col0
                                                             Group By Operator 
[GBY_16] (rows=455058 width=112)
                                                               
Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col1
-                                                              Merge Join 
Operator [MERGEJOIN_428] (rows=18762463 width=112)
-                                                                
Conds:RS_484._col0=RS_472._col0(Inner),Output:["_col1","_col2"]
+                                                              Merge Join 
Operator [MERGEJOIN_434] (rows=18762463 width=112)
+                                                                
Conds:RS_486._col0=RS_478._col0(Inner),Output:["_col1","_col2"]
                                                               <-Map 26 
[SIMPLE_EDGE] vectorized
-                                                                
PARTITION_ONLY_SHUFFLE [RS_472]
+                                                                
PARTITION_ONLY_SHUFFLE [RS_478]
                                                                   
PartitionCols:_col0
-                                                                  Select 
Operator [SEL_471] (rows=2609 width=4)
+                                                                  Select 
Operator [SEL_477] (rows=2609 width=4)
                                                                     
Output:["_col0"]
-                                                                    Filter 
Operator [FIL_470] (rows=2609 width=8)
+                                                                    Filter 
Operator [FIL_476] (rows=2609 width=8)
                                                                       
predicate:(d_year) IN (1999, 2000, 2001, 2002)
                                                                       
TableScan [TS_9] (rows=73049 width=8)
                                                                         
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"]
                                                               <-Map 15 
[SIMPLE_EDGE] vectorized
-                                                                SHUFFLE 
[RS_484]
+                                                                SHUFFLE 
[RS_486]
                                                                   
PartitionCols:_col0
-                                                                  Select 
Operator [SEL_483] (rows=525327388 width=119)
+                                                                  Select 
Operator [SEL_485] (rows=525327388 width=119)
                                                                     
Output:["_col0","_col1","_col2"]
-                                                                    Filter 
Operator [FIL_482] (rows=525327388 width=118)
+                                                                    Filter 
Operator [FIL_484] (rows=525327388 width=118)
                                                                       
predicate:((ss_sold_date_sk BETWEEN DynamicValue(RS_13_date_dim_d_date_sk_min) 
AND DynamicValue(RS_13_date_dim_d_date_sk_max) and 
in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_sold_date_sk is not null)
                                                                       
TableScan [TS_6] (rows=575995635 width=118)
                                                                         
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_quantity","ss_sales_price"]
                                                                       
<-Reducer 27 [BROADCAST_EDGE] vectorized
-                                                                        
BROADCAST [RS_481]
-                                                                          
Group By Operator [GBY_480] (rows=1 width=12)
+                                                                        
BROADCAST [RS_483]
+                                                                          
Group By Operator [GBY_482] (rows=1 width=12)
                                                                             
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                                                           
<-Map 26 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                            
PARTITION_ONLY_SHUFFLE [RS_478]
-                                                                              
Group By Operator [GBY_476] (rows=1 width=12)
+                                                                            
PARTITION_ONLY_SHUFFLE [RS_481]
+                                                                              
Group By Operator [GBY_480] (rows=1 width=12)
                                                                                
 
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
 Select Operator [SEL_473] (rows=2609 width=4)
+                                                                               
 Select Operator [SEL_479] (rows=2609 width=4)
                                                                                
   Output:["_col0"]
-                                                                               
    Please refer to the previous Select Operator [SEL_471]
+                                                                               
    Please refer to the previous Select Operator [SEL_477]
                                     <-Reducer 25 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                      PARTITION_ONLY_SHUFFLE [RS_540]
-                                        Group By Operator [GBY_539] (rows=1 
width=112)
+                                      PARTITION_ONLY_SHUFFLE [RS_550]
+                                        Group By Operator [GBY_549] (rows=1 
width=112)
                                           
Output:["_col0"],aggregations:["max(VALUE._col0)"]
                                         <-Reducer 17 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_497]
-                                            Group By Operator [GBY_493] 
(rows=1 width=112)
+                                          PARTITION_ONLY_SHUFFLE [RS_499]
+                                            Group By Operator [GBY_495] 
(rows=1 width=112)
                                               
Output:["_col0"],aggregations:["max(_col1)"]
-                                              Select Operator [SEL_489] 
(rows=50562 width=112)
+                                              Select Operator [SEL_491] 
(rows=50562 width=112)
                                                 Output:["_col1"]
-                                                 Please refer to the previous 
Group By Operator [GBY_485]
-                                <-Reducer 39 [CUSTOM_SIMPLE_EDGE] vectorized
-                                  PARTITION_ONLY_SHUFFLE [RS_548]
-                                    Group By Operator [GBY_547] (rows=1415626 
width=115)
+                                                 Please refer to the previous 
Group By Operator [GBY_487]
+                                <-Reducer 40 [CUSTOM_SIMPLE_EDGE] vectorized
+                                  PARTITION_ONLY_SHUFFLE [RS_558]
+                                    Group By Operator [GBY_557] (rows=1415626 
width=115)
                                       
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
-                                    <-Map 38 [SIMPLE_EDGE] vectorized
-                                      SHUFFLE [RS_546]
+                                    <-Map 39 [SIMPLE_EDGE] vectorized
+                                      SHUFFLE [RS_556]
                                         PartitionCols:_col0
-                                        Group By Operator [GBY_545] 
(rows=550080312 width=115)
+                                        Group By Operator [GBY_555] 
(rows=550080312 width=115)
                                           
Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0
-                                          Select Operator [SEL_544] 
(rows=550080312 width=114)
+                                          Select Operator [SEL_554] 
(rows=550080312 width=114)
                                             Output:["_col0","_col1"]
-                                            Filter Operator [FIL_543] 
(rows=550080312 width=114)
-                                              predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_189_web_sales_ws_bill_customer_sk_min) AND 
DynamicValue(RS_189_web_sales_ws_bill_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_189_web_sales_ws_bill_customer_sk_bloom_filter))) and 
ss_customer_sk is not null)
-                                              TableScan [TS_150] 
(rows=575995635 width=114)
+                                            Filter Operator [FIL_553] 
(rows=550080312 width=114)
+                                              predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_193_web_sales_ws_bill_customer_sk_min) AND 
DynamicValue(RS_193_web_sales_ws_bill_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_193_web_sales_ws_bill_customer_sk_bloom_filter))) and 
ss_customer_sk is not null)
+                                              TableScan [TS_153] 
(rows=575995635 width=114)
                                                 
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_customer_sk","ss_quantity","ss_sales_price"]
                                               <-Reducer 13 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_542]
-                                                  Group By Operator [GBY_541] 
(rows=1 width=12)
+                                                BROADCAST [RS_552]
+                                                  Group By Operator [GBY_551] 
(rows=1 width=12)
                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                                   <-Reducer 10 
[CUSTOM_SIMPLE_EDGE]
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_406]
-                                                      Group By Operator 
[GBY_405] (rows=1 width=12)
+                                                    PARTITION_ONLY_SHUFFLE 
[RS_412]
+                                                      Group By Operator 
[GBY_411] (rows=1 width=12)
                                                         
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                        Select Operator 
[SEL_404] (rows=3941102 width=7)
+                                                        Select Operator 
[SEL_410] (rows=3941102 width=7)
                                                           Output:["_col0"]
-                                                           Please refer to the 
previous Merge Join Operator [MERGEJOIN_432]
-                    <-Reducer 31 [ONE_TO_ONE_EDGE] vectorized
-                      FORWARD [RS_552]
+                                                           Please refer to the 
previous Merge Join Operator [MERGEJOIN_438]
+                    <-Reducer 34 [SIMPLE_EDGE] vectorized
+                      SHUFFLE [RS_564]
                         PartitionCols:_col0
-                        Select Operator [SEL_551] (rows=745 width=4)
-                          Output:["_col0"]
-                          Filter Operator [FIL_550] (rows=745 width=12)
-                            predicate:(_col1 > 4L)
-                            Group By Operator [GBY_549] (rows=2235 width=12)
-                              
Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0
-                            <-Reducer 29 [SIMPLE_EDGE]
-                              SHUFFLE [RS_182]
-                                PartitionCols:_col0
-                                Group By Operator [GBY_83] (rows=2235 width=12)
-                                  
Output:["_col0","_col1"],aggregations:["count()"],keys:_col4
-                                  Merge Join Operator [MERGEJOIN_431] 
(rows=19646398 width=4)
-                                    
Conds:RS_79._col1=RS_520._col0(Inner),Output:["_col4"]
-                                  <-Map 36 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_520]
-                                      PartitionCols:_col0
-                                      Select Operator [SEL_519] (rows=462000 
width=188)
-                                        Output:["_col0"]
-                                        TableScan [TS_74] (rows=462000 width=4)
-                                          
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk"]
-                                  <-Reducer 28 [SIMPLE_EDGE]
-                                    SHUFFLE [RS_79]
-                                      PartitionCols:_col1
-                                      Merge Join Operator [MERGEJOIN_430] 
(rows=19646398 width=4)
-                                        
Conds:RS_518._col0=RS_474._col0(Inner),Output:["_col1"]
-                                      <-Map 26 [SIMPLE_EDGE] vectorized
-                                        PARTITION_ONLY_SHUFFLE [RS_474]
-                                          PartitionCols:_col0
-                                           Please refer to the previous Select 
Operator [SEL_471]
-                                      <-Map 35 [SIMPLE_EDGE] vectorized
-                                        SHUFFLE [RS_518]
+                        Group By Operator [GBY_563] (rows=2235 width=4)
+                          Output:["_col0"],keys:_col0
+                          Select Operator [SEL_562] (rows=6548799 width=4)
+                            Output:["_col0"]
+                            Filter Operator [FIL_561] (rows=6548799 width=290)
+                              predicate:(_col3 > 4L)
+                              Select Operator [SEL_560] (rows=19646398 
width=290)
+                                Output:["_col1","_col3"]
+                                Group By Operator [GBY_559] (rows=19646398 
width=290)
+                                  
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
+                                <-Reducer 32 [SIMPLE_EDGE]
+                                  SHUFFLE [RS_185]
+                                    PartitionCols:_col0, _col1, _col2
+                                    Group By Operator [GBY_83] (rows=19646398 
width=290)
+                                      
Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, 
_col3, _col5
+                                      Merge Join Operator [MERGEJOIN_437] 
(rows=19646398 width=282)
+                                        
Conds:RS_79._col1=RS_528._col0(Inner),Output:["_col3","_col4","_col5"]
+                                      <-Map 37 [SIMPLE_EDGE] vectorized
+                                        SHUFFLE [RS_528]
                                           PartitionCols:_col0
-                                          Select Operator [SEL_517] 
(rows=550076554 width=7)
+                                          Select Operator [SEL_527] 
(rows=462000 width=188)
                                             Output:["_col0","_col1"]
-                                            Filter Operator [FIL_516] 
(rows=550076554 width=7)
-                                              predicate:((ss_sold_date_sk 
BETWEEN DynamicValue(RS_77_date_dim_d_date_sk_min) AND 
DynamicValue(RS_77_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_77_date_dim_d_date_sk_bloom_filter))) and ss_sold_date_sk is 
not null)
-                                              TableScan [TS_68] 
(rows=575995635 width=7)
-                                                
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk"]
-                                              <-Reducer 32 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_515]
-                                                  Group By Operator [GBY_514] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                  <-Map 26 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_479]
-                                                      Group By Operator 
[GBY_477] (rows=1 width=12)
-                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                        Select Operator 
[SEL_475] (rows=2609 width=4)
-                                                          Output:["_col0"]
-                                                           Please refer to the 
previous Select Operator [SEL_471]
+                                            TableScan [TS_74] (rows=462000 
width=188)
+                                              
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_desc"]
+                                      <-Reducer 31 [SIMPLE_EDGE]
+                                        SHUFFLE [RS_79]
+                                          PartitionCols:_col1
+                                          Merge Join Operator [MERGEJOIN_436] 
(rows=19646398 width=98)
+                                            
Conds:RS_526._col0=RS_518._col0(Inner),Output:["_col1","_col3"]
+                                          <-Map 35 [SIMPLE_EDGE] vectorized
+                                            PARTITION_ONLY_SHUFFLE [RS_518]
+                                              PartitionCols:_col0
+                                              Select Operator [SEL_517] 
(rows=2609 width=98)
+                                                Output:["_col0","_col1"]
+                                                Filter Operator [FIL_516] 
(rows=2609 width=102)
+                                                  predicate:(d_year) IN (1999, 
2000, 2001, 2002)
+                                                  TableScan [TS_71] 
(rows=73049 width=102)
+                                                    
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date","d_year"]
+                                          <-Map 30 [SIMPLE_EDGE] vectorized
+                                            SHUFFLE [RS_526]
+                                              PartitionCols:_col0
+                                              Select Operator [SEL_525] 
(rows=550076554 width=7)
+                                                Output:["_col0","_col1"]
+                                                Filter Operator [FIL_524] 
(rows=550076554 width=7)
+                                                  predicate:((ss_sold_date_sk 
BETWEEN DynamicValue(RS_77_date_dim_d_date_sk_min) AND 
DynamicValue(RS_77_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_77_date_dim_d_date_sk_bloom_filter))) and ss_sold_date_sk is 
not null)
+                                                  TableScan [TS_68] 
(rows=575995635 width=7)
+                                                    
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk"]
+                                                  <-Reducer 36 
[BROADCAST_EDGE] vectorized
+                                                    BROADCAST [RS_523]
+                                                      Group By Operator 
[GBY_522] (rows=1 width=12)
+                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
+                                                      <-Map 35 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                        PARTITION_ONLY_SHUFFLE 
[RS_521]
+                                                          Group By Operator 
[GBY_520] (rows=1 width=12)
+                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
+                                                            Select Operator 
[SEL_519] (rows=2609 width=4)
+                                                              Output:["_col0"]
+                                                               Please refer to 
the previous Select Operator [SEL_517]
             <-Reducer 4 [CONTAINS]
-              Reduce Output Operator [RS_449]
-                Group By Operator [GBY_448] (rows=1 width=112)
+              Reduce Output Operator [RS_455]
+                Group By Operator [GBY_454] (rows=1 width=112)
                   Output:["_col0"],aggregations:["sum(_col0)"]
-                  Select Operator [SEL_446] (rows=102 width=112)
+                  Select Operator [SEL_452] (rows=304 width=112)
                     Output:["_col0"]
-                    Merge Join Operator [MERGEJOIN_445] (rows=102 width=1)
-                      
Conds:RS_94._col2=RS_524._col0(Inner),Output:["_col3","_col4"]
+                    Merge Join Operator [MERGEJOIN_451] (rows=304 width=0)
+                      Conds:RS_97._col2=RS_534._col0(Left 
Semi),Output:["_col3","_col4"]
                     <-Reducer 3 [SIMPLE_EDGE]
-                      SHUFFLE [RS_94]
+                      SHUFFLE [RS_97]
                         PartitionCols:_col2
-                        Merge Join Operator [MERGEJOIN_439] (rows=7751875 
width=98)
-                          
Conds:RS_91._col1=RS_92._col0(Inner),Output:["_col2","_col3","_col4"]
+                        Merge Join Operator [MERGEJOIN_445] (rows=7751875 
width=98)
+                          
Conds:RS_92._col1=RS_93._col0(Inner),Output:["_col2","_col3","_col4"]
                         <-Reducer 2 [SIMPLE_EDGE]
-                          PARTITION_ONLY_SHUFFLE [RS_91]
+                          PARTITION_ONLY_SHUFFLE [RS_92]
                             PartitionCols:_col1
-                            Merge Join Operator [MERGEJOIN_427] (rows=7751875 
width=101)
-                              
Conds:RS_469._col0=RS_457._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
+                            Merge Join Operator [MERGEJOIN_433] (rows=7751875 
width=101)
+                              
Conds:RS_475._col0=RS_463._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
                             <-Map 8 [SIMPLE_EDGE] vectorized
-                              PARTITION_ONLY_SHUFFLE [RS_457]
+                              PARTITION_ONLY_SHUFFLE [RS_463]
                                 PartitionCols:_col0
-                                 Please refer to the previous Select Operator 
[SEL_456]
+                                 Please refer to the previous Select Operator 
[SEL_462]
                             <-Map 1 [SIMPLE_EDGE] vectorized
-                              SHUFFLE [RS_469]
+                              SHUFFLE [RS_475]
                                 PartitionCols:_col0
-                                Select Operator [SEL_468] (rows=285117831 
width=127)
+                                Select Operator [SEL_474] (rows=285117831 
width=127)
                                   
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                  Filter Operator [FIL_467] (rows=285117831 
width=127)
-                                    predicate:((cs_sold_date_sk BETWEEN 
DynamicValue(RS_89_date_dim_d_date_sk_min) AND 
DynamicValue(RS_89_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_89_date_dim_d_date_sk_bloom_filter))) and cs_bill_customer_sk 
is not null and cs_sold_date_sk is not null)
+                                  Filter Operator [FIL_473] (rows=285117831 
width=127)
+                                    predicate:((cs_sold_date_sk BETWEEN 
DynamicValue(RS_90_date_dim_d_date_sk_min) AND 
DynamicValue(RS_90_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_90_date_dim_d_date_sk_bloom_filter))) and cs_bill_customer_sk 
is not null and cs_sold_date_sk is not null)
                                     TableScan [TS_0] (rows=287989836 width=127)
                                       
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_quantity","cs_list_price"]
                                     <-Reducer 9 [BROADCAST_EDGE] vectorized
-                                      BROADCAST [RS_466]
-                                        Group By Operator [GBY_465] (rows=1 
width=12)
+                                      BROADCAST [RS_472]
+                                        Group By Operator [GBY_471] (rows=1 
width=12)
                                           
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                         <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_463]
-                                            Group By Operator [GBY_461] 
(rows=1 width=12)
+                                          PARTITION_ONLY_SHUFFLE [RS_469]
+                                            Group By Operator [GBY_467] 
(rows=1 width=12)
                                               
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                              Select Operator [SEL_458] 
(rows=50 width=4)
+                                              Select Operator [SEL_464] 
(rows=50 width=4)
                                                 Output:["_col0"]
-                                                 Please refer to the previous 
Select Operator [SEL_456]
+                                                 Please refer to the previous 
Select Operator [SEL_462]
                         <-Reducer 20 [SIMPLE_EDGE]
-                          SHUFFLE [RS_92]
+                          SHUFFLE [RS_93]
                             PartitionCols:_col0
                             Select Operator [SEL_67] (rows=471875 width=3)
                               Output:["_col0"]
                               Filter Operator [FIL_66] (rows=471875 width=227)
                                 predicate:(_col3 > (0.95 * _col1))
-                                Merge Join Operator [MERGEJOIN_438] 
(rows=1415626 width=227)
+                                Merge Join Operator [MERGEJOIN_444] 
(rows=1415626 width=227)
                                   
Conds:(Inner),Output:["_col1","_col2","_col3"]
                                 <-Reducer 19 [CUSTOM_SIMPLE_EDGE]
                                   PARTITION_ONLY_SHUFFLE [RS_63]
-                                    Merge Join Operator [MERGEJOIN_437] 
(rows=1 width=112)
+                                    Merge Join Operator [MERGEJOIN_443] 
(rows=1 width=112)
                                       Conds:(Inner),Output:["_col1"]
                                     <-Reducer 18 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                      PARTITION_ONLY_SHUFFLE [RS_503]
-                                        Select Operator [SEL_502] (rows=1 
width=8)
-                                          Filter Operator [FIL_501] (rows=1 
width=8)
+                                      PARTITION_ONLY_SHUFFLE [RS_505]
+                                        Select Operator [SEL_504] (rows=1 
width=8)
+                                          Filter Operator [FIL_503] (rows=1 
width=8)
                                             predicate:(sq_count_check(_col0) 
<= 1)
-                                            Group By Operator [GBY_500] 
(rows=1 width=8)
+                                            Group By Operator [GBY_502] 
(rows=1 width=8)
                                               
Output:["_col0"],aggregations:["count()"]
-                                              Select Operator [SEL_499] 
(rows=1 width=8)
-                                                Group By Operator [GBY_498] 
(rows=1 width=8)
+                                              Select Operator [SEL_501] 
(rows=1 width=8)
+                                                Group By Operator [GBY_500] 
(rows=1 width=8)
                                                   
Output:["_col0"],aggregations:["count(VALUE._col0)"]
                                                 <-Reducer 17 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                  PARTITION_ONLY_SHUFFLE 
[RS_494]
-                                                    Group By Operator 
[GBY_490] (rows=1 width=8)
+                                                  PARTITION_ONLY_SHUFFLE 
[RS_496]
+                                                    Group By Operator 
[GBY_492] (rows=1 width=8)
                                                       
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_486] (rows=50562 width=112)
+                                                      Select Operator 
[SEL_488] (rows=50562 width=112)
                                                         Output:["_col0"]
-                                                         Please refer to the 
previous Group By Operator [GBY_485]
+                                                         Please refer to the 
previous Group By Operator [GBY_487]
                                     <-Reducer 21 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                      PARTITION_ONLY_SHUFFLE [RS_505]
-                                        Group By Operator [GBY_504] (rows=1 
width=112)
+                                      PARTITION_ONLY_SHUFFLE [RS_507]
+                                        Group By Operator [GBY_506] (rows=1 
width=112)
                                           
Output:["_col0"],aggregations:["max(VALUE._col0)"]
                                         <-Reducer 17 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_495]
-                                            Group By Operator [GBY_491] 
(rows=1 width=112)
+                                          PARTITION_ONLY_SHUFFLE [RS_497]
+                                            Group By Operator [GBY_493] 
(rows=1 width=112)
                                               
Output:["_col0"],aggregations:["max(_col1)"]
-                                              Select Operator [SEL_487] 
(rows=50562 width=112)
+                                              Select Operator [SEL_489] 
(rows=50562 width=112)
                                                 Output:["_col1"]
-                                                 Please refer to the previous 
Group By Operator [GBY_485]
-                                <-Reducer 34 [CUSTOM_SIMPLE_EDGE] vectorized
-                                  PARTITION_ONLY_SHUFFLE [RS_513]
-                                    Group By Operator [GBY_512] (rows=1415626 
width=115)
+                                                 Please refer to the previous 
Group By Operator [GBY_487]
+                                <-Reducer 29 [CUSTOM_SIMPLE_EDGE] vectorized
+                                  PARTITION_ONLY_SHUFFLE [RS_515]
+                                    Group By Operator [GBY_514] (rows=1415626 
width=115)
                                       
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
-                                    <-Map 33 [SIMPLE_EDGE] vectorized
-                                      SHUFFLE [RS_511]
+                                    <-Map 28 [SIMPLE_EDGE] vectorized
+                                      SHUFFLE [RS_513]
                                         PartitionCols:_col0
-                                        Group By Operator [GBY_510] 
(rows=550080312 width=115)
+                                        Group By Operator [GBY_512] 
(rows=550080312 width=115)
                                           
Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0
-                                          Select Operator [SEL_509] 
(rows=550080312 width=114)
+                                          Select Operator [SEL_511] 
(rows=550080312 width=114)
                                             Output:["_col0","_col1"]
-                                            Filter Operator [FIL_508] 
(rows=550080312 width=114)
-                                              predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_91_catalog_sales_cs_bill_customer_sk_min) AND 
DynamicValue(RS_91_catalog_sales_cs_bill_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_91_catalog_sales_cs_bill_customer_sk_bloom_filter))) and 
ss_customer_sk is not null)
+                                            Filter Operator [FIL_510] 
(rows=550080312 width=114)
+                                              predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_92_catalog_sales_cs_bill_customer_sk_min) AND 
DynamicValue(RS_92_catalog_sales_cs_bill_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_92_catalog_sales_cs_bill_customer_sk_bloom_filter))) and 
ss_customer_sk is not null)
                                               TableScan [TS_52] 
(rows=575995635 width=114)
                                                 
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_customer_sk","ss_quantity","ss_sales_price"]
                                               <-Reducer 7 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_507]
-                                                  Group By Operator [GBY_506] 
(rows=1 width=12)
+                                                BROADCAST [RS_509]
+                                                  Group By Operator [GBY_508] 
(rows=1 width=12)
                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                                   <-Reducer 2 
[CUSTOM_SIMPLE_EDGE]
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_333]
-                                                      Group By Operator 
[GBY_332] (rows=1 width=12)
+                                                    PARTITION_ONLY_SHUFFLE 
[RS_339]
+                                                      Group By Operator 
[GBY_338] (rows=1 width=12)
                                                         
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                        Select Operator 
[SEL_331] (rows=7751875 width=6)
+                                                        Select Operator 
[SEL_337] (rows=7751875 width=6)
                                                           Output:["_col0"]
-                                                           Please refer to the 
previous Merge Join Operator [MERGEJOIN_427]
-                    <-Reducer 30 [ONE_TO_ONE_EDGE] vectorized
-                      FORWARD [RS_524]
+                                                           Please refer to the 
previous Merge Join Operator [MERGEJOIN_433]
+                    <-Reducer 33 [SIMPLE_EDGE] vectorized
+                      SHUFFLE [RS_534]
                         PartitionCols:_col0
-                        Select Operator [SEL_523] (rows=745 width=4)
-                          Output:["_col0"]
-                          Filter Operator [FIL_522] (rows=745 width=12)
-                            predicate:(_col1 > 4L)
-                            Group By Operator [GBY_521] (rows=2235 width=12)
-                              
Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0
-                            <-Reducer 29 [SIMPLE_EDGE]
-                              SHUFFLE [RS_84]
-                                PartitionCols:_col0
-                                 Please refer to the previous Group By 
Operator [GBY_83]
+                        Group By Operator [GBY_533] (rows=2235 width=4)
+                          Output:["_col0"],keys:_col0
+                          Select Operator [SEL_532] (rows=6548799 width=4)
+                            Output:["_col0"]
+                            Filter Operator [FIL_531] (rows=6548799 width=290)
+                              predicate:(_col3 > 4L)
+                              Select Operator [SEL_530] (rows=19646398 
width=290)
+                                Output:["_col1","_col3"]
+                                Group By Operator [GBY_529] (rows=19646398 
width=290)
+                                  
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
+                                <-Reducer 32 [SIMPLE_EDGE]
+                                  SHUFFLE [RS_84]
+                                    PartitionCols:_col0, _col1, _col2
+                                     Please refer to the previous Group By 
Operator [GBY_83]
 

http://git-wip-us.apache.org/repos/asf/hive/blob/83d1fd23/ql/src/test/results/clientpositive/perf/tez/constraints/query39.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query39.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query39.q.out
index 812928b..ca2d830 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query39.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query39.q.out
@@ -66,7 +66,7 @@ Vertex dependency in root stage
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE)
 Reducer 3 <- Map 11 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
 Reducer 4 <- Reducer 3 (SIMPLE_EDGE)
-Reducer 5 <- Reducer 4 (ONE_TO_ONE_EDGE), Reducer 9 (ONE_TO_ONE_EDGE)
+Reducer 5 <- Reducer 4 (SIMPLE_EDGE), Reducer 9 (SIMPLE_EDGE)
 Reducer 6 <- Reducer 5 (SIMPLE_EDGE)
 Reducer 7 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE)
 Reducer 8 <- Map 11 (SIMPLE_EDGE), Reducer 7 (SIMPLE_EDGE)
@@ -77,99 +77,101 @@ Stage-0
     limit:-1
     Stage-1
       Reducer 6 vectorized
-      File Output Operator [FS_166]
-        Select Operator [SEL_165] (rows=859 width=56)
+      File Output Operator [FS_170]
+        Select Operator [SEL_169] (rows=189509 width=56)
           
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"]
         <-Reducer 5 [SIMPLE_EDGE]
           SHUFFLE [RS_44]
-            Select Operator [SEL_43] (rows=859 width=48)
-              Output:["_col0","_col1","_col2","_col3","_col6","_col7"]
-              Merge Join Operator [MERGEJOIN_144] (rows=859 width=40)
-                Conds:RS_160._col0, _col1=RS_164._col0, 
_col1(Inner),Output:["_col0","_col1","_col2","_col3","_col6","_col7"]
-              <-Reducer 4 [ONE_TO_ONE_EDGE] vectorized
-                FORWARD [RS_160]
-                  PartitionCols:_col0, _col1
-                  Select Operator [SEL_159] (rows=859 width=24)
-                    Output:["_col0","_col1","_col2","_col3"]
-                    Filter Operator [FIL_158] (rows=859 width=40)
-                      predicate:CASE WHEN (((UDFToDouble(_col2) / _col3) = 0)) 
THEN (false) ELSE (((power(((_col4 - ((_col5 * _col5) / _col3)) / CASE WHEN 
((_col3 = 1L)) THEN (null) ELSE ((_col3 - 1)) END), 0.5) / (UDFToDouble(_col2) 
/ _col3)) > 1.0D)) END
-                      Group By Operator [GBY_157] (rows=1719 width=40)
-                        
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0,
 KEY._col1
+            Merge Join Operator [MERGEJOIN_146] (rows=189509 width=48)
+              Conds:RS_163._col0, _col1=RS_168._col0, 
_col1(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"]
+            <-Reducer 4 [SIMPLE_EDGE] vectorized
+              SHUFFLE [RS_163]
+                PartitionCols:_col0, _col1
+                Select Operator [SEL_162] (rows=18049 width=24)
+                  Output:["_col0","_col1","_col2","_col3"]
+                  Filter Operator [FIL_161] (rows=18049 width=40)
+                    predicate:CASE WHEN (((UDFToDouble(_col3) / _col4) = 0)) 
THEN (false) ELSE (((power(((_col5 - ((_col6 * _col6) / _col4)) / CASE WHEN 
((_col4 = 1L)) THEN (null) ELSE ((_col4 - 1)) END), 0.5) / (UDFToDouble(_col3) 
/ _col4)) > 1.0D)) END
+                    Select Operator [SEL_160] (rows=36099 width=40)
+                      Output:["_col0","_col1","_col3","_col4","_col5","_col6"]
+                      Group By Operator [GBY_159] (rows=36099 width=140)
+                        
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0,
 KEY._col1, KEY._col2
                       <-Reducer 3 [SIMPLE_EDGE]
                         SHUFFLE [RS_16]
-                          PartitionCols:_col0, _col1
-                          Group By Operator [GBY_15] (rows=1719 width=40)
-                            
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col3)","count(_col3)","sum(_col5)","sum(_col4)"],keys:_col1,
 _col2
-                            Select Operator [SEL_13] (rows=1032514 width=8)
-                              Output:["_col1","_col2","_col3","_col4","_col5"]
-                              Merge Join Operator [MERGEJOIN_141] 
(rows=1032514 width=8)
-                                
Conds:RS_10._col1=RS_155._col0(Inner),Output:["_col2","_col3","_col5"]
+                          PartitionCols:_col0, _col1, _col2
+                          Group By Operator [GBY_15] (rows=36099 width=140)
+                            
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)","count(_col3)","sum(_col5)","sum(_col4)"],keys:_col1,
 _col2, _col0
+                            Select Operator [SEL_13] (rows=1032514 width=108)
+                              
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
+                              Merge Join Operator [MERGEJOIN_143] 
(rows=1032514 width=108)
+                                
Conds:RS_10._col1=RS_157._col0(Inner),Output:["_col2","_col3","_col5","_col6"]
                               <-Map 11 [SIMPLE_EDGE] vectorized
-                                SHUFFLE [RS_155]
+                                SHUFFLE [RS_157]
                                   PartitionCols:_col0
-                                  Select Operator [SEL_154] (rows=27 width=4)
-                                    Output:["_col0"]
-                                    TableScan [TS_5] (rows=27 width=4)
-                                      
default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk"]
+                                  Select Operator [SEL_156] (rows=27 width=104)
+                                    Output:["_col0","_col1"]
+                                    TableScan [TS_5] (rows=27 width=104)
+                                      
default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"]
                               <-Reducer 2 [SIMPLE_EDGE]
                                 SHUFFLE [RS_10]
                                   PartitionCols:_col1
-                                  Merge Join Operator [MERGEJOIN_140] 
(rows=1032514 width=8)
-                                    
Conds:RS_146._col0=RS_152._col0(Inner),Output:["_col1","_col2","_col3"]
+                                  Merge Join Operator [MERGEJOIN_142] 
(rows=1032514 width=8)
+                                    
Conds:RS_148._col0=RS_154._col0(Inner),Output:["_col1","_col2","_col3"]
                                   <-Map 1 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_146]
+                                    SHUFFLE [RS_148]
                                       PartitionCols:_col0
-                                      Select Operator [SEL_145] (rows=37584000 
width=15)
+                                      Select Operator [SEL_147] (rows=37584000 
width=15)
                                         
Output:["_col0","_col1","_col2","_col3"]
                                         TableScan [TS_0] (rows=37584000 
width=15)
                                           
default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"]
                                   <-Map 10 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_152]
+                                    SHUFFLE [RS_154]
                                       PartitionCols:_col0
-                                      Select Operator [SEL_150] (rows=50 
width=4)
+                                      Select Operator [SEL_152] (rows=50 
width=4)
                                         Output:["_col0"]
-                                        Filter Operator [FIL_148] (rows=50 
width=12)
-                                          predicate:((d_moy = 5) and (d_year = 
1999))
+                                        Filter Operator [FIL_150] (rows=50 
width=12)
+                                          predicate:((d_moy = 4) and (d_year = 
1999))
                                           TableScan [TS_2] (rows=73049 
width=12)
                                             
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
-              <-Reducer 9 [ONE_TO_ONE_EDGE] vectorized
-                FORWARD [RS_164]
-                  PartitionCols:_col0, _col1
-                  Select Operator [SEL_163] (rows=859 width=24)
-                    Output:["_col0","_col1","_col2","_col3"]
-                    Filter Operator [FIL_162] (rows=859 width=40)
-                      predicate:CASE WHEN (((UDFToDouble(_col2) / _col3) = 0)) 
THEN (false) ELSE (((power(((_col4 - ((_col5 * _col5) / _col3)) / CASE WHEN 
((_col3 = 1L)) THEN (null) ELSE ((_col3 - 1)) END), 0.5) / (UDFToDouble(_col2) 
/ _col3)) > 1.0D)) END
-                      Group By Operator [GBY_161] (rows=1719 width=40)
-                        
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0,
 KEY._col1
+            <-Reducer 9 [SIMPLE_EDGE] vectorized
+              SHUFFLE [RS_168]
+                PartitionCols:_col0, _col1
+                Select Operator [SEL_167] (rows=18049 width=24)
+                  Output:["_col0","_col1","_col2","_col3"]
+                  Filter Operator [FIL_166] (rows=18049 width=40)
+                    predicate:CASE WHEN (((UDFToDouble(_col3) / _col4) = 0)) 
THEN (false) ELSE (((power(((_col5 - ((_col6 * _col6) / _col4)) / CASE WHEN 
((_col4 = 1L)) THEN (null) ELSE ((_col4 - 1)) END), 0.5) / (UDFToDouble(_col3) 
/ _col4)) > 1.0D)) END
+                    Select Operator [SEL_165] (rows=36099 width=40)
+                      Output:["_col0","_col1","_col3","_col4","_col5","_col6"]
+                      Group By Operator [GBY_164] (rows=36099 width=140)
+                        
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0,
 KEY._col1, KEY._col2
                       <-Reducer 8 [SIMPLE_EDGE]
                         SHUFFLE [RS_36]
-                          PartitionCols:_col0, _col1
-                          Group By Operator [GBY_35] (rows=1719 width=40)
-                            
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col3)","count(_col3)","sum(_col5)","sum(_col4)"],keys:_col1,
 _col2
-                            Select Operator [SEL_33] (rows=1032514 width=8)
-                              Output:["_col1","_col2","_col3","_col4","_col5"]
-                              Merge Join Operator [MERGEJOIN_143] 
(rows=1032514 width=8)
-                                
Conds:RS_30._col1=RS_156._col0(Inner),Output:["_col2","_col3","_col5"]
+                          PartitionCols:_col0, _col1, _col2
+                          Group By Operator [GBY_35] (rows=36099 width=140)
+                            
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)","count(_col3)","sum(_col5)","sum(_col4)"],keys:_col1,
 _col2, _col0
+                            Select Operator [SEL_33] (rows=1032514 width=108)
+                              
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
+                              Merge Join Operator [MERGEJOIN_145] 
(rows=1032514 width=108)
+                                
Conds:RS_30._col1=RS_158._col0(Inner),Output:["_col2","_col3","_col5","_col6"]
                               <-Map 11 [SIMPLE_EDGE] vectorized
-                                SHUFFLE [RS_156]
+                                SHUFFLE [RS_158]
                                   PartitionCols:_col0
-                                   Please refer to the previous Select 
Operator [SEL_154]
+                                   Please refer to the previous Select 
Operator [SEL_156]
                               <-Reducer 7 [SIMPLE_EDGE]
                                 SHUFFLE [RS_30]
                                   PartitionCols:_col1
-                                  Merge Join Operator [MERGEJOIN_142] 
(rows=1032514 width=8)
-                                    
Conds:RS_147._col0=RS_153._col0(Inner),Output:["_col1","_col2","_col3"]
+                                  Merge Join Operator [MERGEJOIN_144] 
(rows=1032514 width=8)
+                                    
Conds:RS_149._col0=RS_155._col0(Inner),Output:["_col1","_col2","_col3"]
                                   <-Map 1 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_147]
+                                    SHUFFLE [RS_149]
                                       PartitionCols:_col0
-                                       Please refer to the previous Select 
Operator [SEL_145]
+                                       Please refer to the previous Select 
Operator [SEL_147]
                                   <-Map 10 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_153]
+                                    SHUFFLE [RS_155]
                                       PartitionCols:_col0
-                                      Select Operator [SEL_151] (rows=50 
width=4)
+                                      Select Operator [SEL_153] (rows=50 
width=4)
                                         Output:["_col0"]
-                                        Filter Operator [FIL_149] (rows=50 
width=12)
-                                          predicate:((d_moy = 4) and (d_year = 
1999))
+                                        Filter Operator [FIL_151] (rows=50 
width=12)
+                                          predicate:((d_moy = 5) and (d_year = 
1999))
                                            Please refer to the previous 
TableScan [TS_2]
 
 PREHOOK: query: with inv as

http://git-wip-us.apache.org/repos/asf/hive/blob/83d1fd23/ql/src/test/results/clientpositive/perf/tez/constraints/query94.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query94.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query94.q.out
index 7290441..1dba4fb 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query94.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query94.q.out
@@ -73,11 +73,12 @@ Map 1 <- Reducer 13 (BROADCAST_EDGE)
 Map 15 <- Reducer 10 (BROADCAST_EDGE)
 Reducer 10 <- Reducer 4 (CUSTOM_SIMPLE_EDGE)
 Reducer 13 <- Map 12 (CUSTOM_SIMPLE_EDGE)
+Reducer 17 <- Map 16 (SIMPLE_EDGE)
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 11 (SIMPLE_EDGE)
 Reducer 3 <- Map 12 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
 Reducer 4 <- Map 14 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
 Reducer 5 <- Map 15 (SIMPLE_EDGE), Reducer 4 (SIMPLE_EDGE)
-Reducer 6 <- Map 16 (SIMPLE_EDGE), Reducer 5 (ONE_TO_ONE_EDGE)
+Reducer 6 <- Reducer 17 (ONE_TO_ONE_EDGE), Reducer 5 (ONE_TO_ONE_EDGE)
 Reducer 7 <- Reducer 6 (SIMPLE_EDGE)
 Reducer 8 <- Reducer 7 (CUSTOM_SIMPLE_EDGE)
 Reducer 9 <- Reducer 8 (SIMPLE_EDGE)
@@ -87,130 +88,137 @@ Stage-0
     limit:-1
     Stage-1
       Reducer 9 vectorized
-      File Output Operator [FS_159]
-        Limit [LIM_158] (rows=1 width=240)
+      File Output Operator [FS_166]
+        Limit [LIM_165] (rows=1 width=240)
           Number of rows:100
-          Select Operator [SEL_157] (rows=1 width=240)
+          Select Operator [SEL_164] (rows=1 width=240)
             Output:["_col0","_col1","_col2"]
           <-Reducer 8 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_156]
-              Select Operator [SEL_155] (rows=1 width=240)
+            SHUFFLE [RS_163]
+              Select Operator [SEL_162] (rows=1 width=240)
                 Output:["_col1","_col2","_col3"]
-                Group By Operator [GBY_154] (rows=1 width=232)
+                Group By Operator [GBY_161] (rows=1 width=232)
                   
Output:["_col0","_col1","_col2"],aggregations:["count(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"]
                 <-Reducer 7 [CUSTOM_SIMPLE_EDGE] vectorized
-                  PARTITION_ONLY_SHUFFLE [RS_153]
-                    Group By Operator [GBY_152] (rows=1 width=232)
+                  PARTITION_ONLY_SHUFFLE [RS_160]
+                    Group By Operator [GBY_159] (rows=1 width=232)
                       
Output:["_col0","_col1","_col2"],aggregations:["count(_col0)","sum(_col1)","sum(_col2)"]
-                      Group By Operator [GBY_151] (rows=2511437 width=228)
+                      Group By Operator [GBY_158] (rows=2511437 width=228)
                         
Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0
                       <-Reducer 6 [SIMPLE_EDGE]
-                        SHUFFLE [RS_69]
+                        SHUFFLE [RS_73]
                           PartitionCols:_col0
-                          Group By Operator [GBY_68] (rows=2511437 width=228)
+                          Group By Operator [GBY_72] (rows=2511437 width=228)
                             
Output:["_col0","_col2","_col3"],aggregations:["sum(_col5)","sum(_col6)"],keys:_col4
-                            Select Operator [SEL_37] (rows=5022875 width=230)
+                            Select Operator [SEL_41] (rows=5022875 width=229)
                               Output:["_col4","_col5","_col6"]
-                              Filter Operator [FIL_36] (rows=5022875 width=230)
+                              Filter Operator [FIL_40] (rows=5022875 width=229)
                                 predicate:_col14 is null
-                                Merge Join Operator [MERGEJOIN_125] 
(rows=14054072 width=230)
-                                  Conds:RS_33._col4=RS_150._col0(Left 
Outer),Output:["_col4","_col5","_col6","_col14"]
-                                <-Map 16 [SIMPLE_EDGE] vectorized
-                                  SHUFFLE [RS_150]
+                                Merge Join Operator [MERGEJOIN_129] 
(rows=10045750 width=229)
+                                  Conds:RS_37._col4=RS_157._col0(Left 
Outer),Output:["_col4","_col5","_col6","_col14"]
+                                <-Reducer 17 [ONE_TO_ONE_EDGE] vectorized
+                                  FORWARD [RS_157]
                                     PartitionCols:_col0
-                                    Select Operator [SEL_149] (rows=14398467 
width=8)
+                                    Select Operator [SEL_156] (rows=8007986 
width=8)
                                       Output:["_col0","_col1"]
-                                      TableScan [TS_25] (rows=14398467 width=4)
-                                        
default@web_returns,wr1,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_order_number"]
+                                      Group By Operator [GBY_155] 
(rows=8007986 width=4)
+                                        Output:["_col0"],keys:KEY._col0
+                                      <-Map 16 [SIMPLE_EDGE] vectorized
+                                        SHUFFLE [RS_154]
+                                          PartitionCols:_col0
+                                          Group By Operator [GBY_153] 
(rows=14398467 width=4)
+                                            
Output:["_col0"],keys:wr_order_number
+                                            TableScan [TS_25] (rows=14398467 
width=4)
+                                              
default@web_returns,wr1,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_order_number"]
                                 <-Reducer 5 [ONE_TO_ONE_EDGE]
-                                  FORWARD [RS_33]
+                                  FORWARD [RS_37]
                                     PartitionCols:_col4
-                                    Select Operator [SEL_32] (rows=5022875 
width=231)
+                                    Select Operator [SEL_36] (rows=5022875 
width=231)
                                       Output:["_col4","_col5","_col6"]
-                                      Merge Join Operator [MERGEJOIN_124] 
(rows=5022875 width=235)
-                                        Conds:RS_29._col4=RS_148._col0(Left 
Semi),Output:["_col3","_col4","_col5","_col6","_col14"],residual filter 
predicates:{(_col3 <> _col14)}
+                                      Merge Join Operator [MERGEJOIN_128] 
(rows=5022875 width=235)
+                                        Conds:RS_33._col4=RS_152._col0(Left 
Semi),Output:["_col3","_col4","_col5","_col6","_col14"],residual filter 
predicates:{(_col3 <> _col14)}
                                       <-Reducer 4 [SIMPLE_EDGE]
-                                        SHUFFLE [RS_29]
+                                        SHUFFLE [RS_33]
                                           PartitionCols:_col4
-                                          Merge Join Operator [MERGEJOIN_123] 
(rows=5022875 width=231)
-                                            
Conds:RS_18._col2=RS_142._col0(Inner),Output:["_col3","_col4","_col5","_col6"]
+                                          Merge Join Operator [MERGEJOIN_127] 
(rows=5022875 width=231)
+                                            
Conds:RS_18._col2=RS_146._col0(Inner),Output:["_col3","_col4","_col5","_col6"]
                                           <-Map 14 [SIMPLE_EDGE] vectorized
-                                            SHUFFLE [RS_142]
+                                            SHUFFLE [RS_146]
                                               PartitionCols:_col0
-                                              Select Operator [SEL_141] 
(rows=12 width=91)
+                                              Select Operator [SEL_145] 
(rows=12 width=91)
                                                 Output:["_col0"]
-                                                Filter Operator [FIL_140] 
(rows=12 width=92)
+                                                Filter Operator [FIL_144] 
(rows=12 width=92)
                                                   predicate:(web_company_name 
= 'pri')
                                                   TableScan [TS_9] (rows=84 
width=92)
                                                     
default@web_site,web_site,Tbl:COMPLETE,Col:COMPLETE,Output:["web_site_sk","web_company_name"]
                                           <-Reducer 3 [SIMPLE_EDGE]
                                             SHUFFLE [RS_18]
                                               PartitionCols:_col2
-                                              Merge Join Operator 
[MERGEJOIN_122] (rows=15673790 width=235)
-                                                
Conds:RS_15._col1=RS_128._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"]
+                                              Merge Join Operator 
[MERGEJOIN_126] (rows=15673790 width=235)
+                                                
Conds:RS_15._col1=RS_132._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"]
                                               <-Map 12 [SIMPLE_EDGE] vectorized
-                                                SHUFFLE [RS_128]
+                                                SHUFFLE [RS_132]
                                                   PartitionCols:_col0
-                                                  Select Operator [SEL_127] 
(rows=784314 width=90)
+                                                  Select Operator [SEL_131] 
(rows=784314 width=90)
                                                     Output:["_col0"]
-                                                    Filter Operator [FIL_126] 
(rows=784314 width=90)
+                                                    Filter Operator [FIL_130] 
(rows=784314 width=90)
                                                       predicate:(ca_state = 
'TX')
                                                       TableScan [TS_6] 
(rows=40000000 width=90)
                                                         
default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"]
                                               <-Reducer 2 [SIMPLE_EDGE]
                                                 SHUFFLE [RS_15]
                                                   PartitionCols:_col1
-                                                  Merge Join Operator 
[MERGEJOIN_121] (rows=15987241 width=239)
-                                                    
Conds:RS_136._col0=RS_139._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6"]
+                                                  Merge Join Operator 
[MERGEJOIN_125] (rows=15987241 width=239)
+                                                    
Conds:RS_140._col0=RS_143._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6"]
                                                   <-Map 1 [SIMPLE_EDGE] 
vectorized
-                                                    SHUFFLE [RS_136]
+                                                    SHUFFLE [RS_140]
                                                       PartitionCols:_col0
-                                                      Select Operator 
[SEL_135] (rows=143895019 width=243)
+                                                      Select Operator 
[SEL_139] (rows=143895019 width=243)
                                                         
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"]
-                                                        Filter Operator 
[FIL_134] (rows=143895019 width=243)
+                                                        Filter Operator 
[FIL_138] (rows=143895019 width=243)
                                                           
predicate:((ws_ship_addr_sk BETWEEN 
DynamicValue(RS_16_customer_address_ca_address_sk_min) AND 
DynamicValue(RS_16_customer_address_ca_address_sk_max) and 
in_bloom_filter(ws_ship_addr_sk, 
DynamicValue(RS_16_customer_address_ca_address_sk_bloom_filter))) and 
ws_ship_addr_sk is not null and ws_ship_date_sk is not null and ws_web_site_sk 
is not null)
                                                           TableScan [TS_0] 
(rows=144002668 width=243)
                                                             
default@web_sales,ws1,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_ship_date_sk","ws_ship_addr_sk","ws_web_site_sk","ws_warehouse_sk","ws_order_number","ws_ext_ship_cost","ws_net_profit"]
                                                           <-Reducer 13 
[BROADCAST_EDGE] vectorized
-                                                            BROADCAST [RS_133]
-                                                              Group By 
Operator [GBY_132] (rows=1 width=12)
+                                                            BROADCAST [RS_137]
+                                                              Group By 
Operator [GBY_136] (rows=1 width=12)
                                                                 
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                                               <-Map 12 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                SHUFFLE 
[RS_131]
-                                                                  Group By 
Operator [GBY_130] (rows=1 width=12)
+                                                                SHUFFLE 
[RS_135]
+                                                                  Group By 
Operator [GBY_134] (rows=1 width=12)
                                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                    Select 
Operator [SEL_129] (rows=784314 width=4)
+                                                                    Select 
Operator [SEL_133] (rows=784314 width=4)
                                                                       
Output:["_col0"]
-                                                                       Please 
refer to the previous Select Operator [SEL_127]
+                                                                       Please 
refer to the previous Select Operator [SEL_131]
                                                   <-Map 11 [SIMPLE_EDGE] 
vectorized
-                                                    SHUFFLE [RS_139]
+                                                    SHUFFLE [RS_143]
                                                       PartitionCols:_col0
-                                                      Select Operator 
[SEL_138] (rows=8116 width=98)
+                                                      Select Operator 
[SEL_142] (rows=8116 width=98)
                                                         Output:["_col0"]
-                                                        Filter Operator 
[FIL_137] (rows=8116 width=98)
+                                                        Filter Operator 
[FIL_141] (rows=8116 width=98)
                                                           predicate:CAST( 
d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1999-05-01 00:00:00' AND 
TIMESTAMP'1999-06-30 00:00:00'
                                                           TableScan [TS_3] 
(rows=73049 width=98)
                                                             
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"]
                                       <-Map 15 [SIMPLE_EDGE] vectorized
-                                        SHUFFLE [RS_148]
+                                        SHUFFLE [RS_152]
                                           PartitionCols:_col0
-                                          Group By Operator [GBY_147] 
(rows=143966743 width=7)
+                                          Group By Operator [GBY_151] 
(rows=143966743 width=7)
                                             
Output:["_col0","_col1"],keys:_col0, _col1
-                                            Select Operator [SEL_146] 
(rows=143966743 width=7)
+                                            Select Operator [SEL_150] 
(rows=143966743 width=7)
                                               Output:["_col0","_col1"]
-                                              Filter Operator [FIL_145] 
(rows=143966743 width=7)
-                                                predicate:((ws_order_number 
BETWEEN DynamicValue(RS_29_ws1_ws_order_number_min) AND 
DynamicValue(RS_29_ws1_ws_order_number_max) and 
in_bloom_filter(ws_order_number, 
DynamicValue(RS_29_ws1_ws_order_number_bloom_filter))) and ws_warehouse_sk is 
not null)
+                                              Filter Operator [FIL_149] 
(rows=143966743 width=7)
+                                                predicate:((ws_order_number 
BETWEEN DynamicValue(RS_33_ws1_ws_order_number_min) AND 
DynamicValue(RS_33_ws1_ws_order_number_max) and 
in_bloom_filter(ws_order_number, 
DynamicValue(RS_33_ws1_ws_order_number_bloom_filter))) and ws_warehouse_sk is 
not null)
                                                 TableScan [TS_22] 
(rows=144002668 width=7)
                                                   
default@web_sales,ws2,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_warehouse_sk","ws_order_number"]
                                                 <-Reducer 10 [BROADCAST_EDGE] 
vectorized
-                                                  BROADCAST [RS_144]
-                                                    Group By Operator 
[GBY_143] (rows=1 width=12)
+                                                  BROADCAST [RS_148]
+                                                    Group By Operator 
[GBY_147] (rows=1 width=12)
                                                       
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                                     <-Reducer 4 
[CUSTOM_SIMPLE_EDGE]
-                                                      SHUFFLE [RS_111]
-                                                        Group By Operator 
[GBY_110] (rows=1 width=12)
+                                                      SHUFFLE [RS_115]
+                                                        Group By Operator 
[GBY_114] (rows=1 width=12)
                                                           
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                          Select Operator 
[SEL_109] (rows=5022875 width=8)
+                                                          Select Operator 
[SEL_113] (rows=5022875 width=8)
                                                             Output:["_col0"]
-                                                             Please refer to 
the previous Merge Join Operator [MERGEJOIN_123]
+                                                             Please refer to 
the previous Merge Join Operator [MERGEJOIN_127]
 

Reply via email to