http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/query89.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/perf/tez/query89.q.out 
b/ql/src/test/results/clientpositive/perf/tez/query89.q.out
index e79b9dd..8501822 100644
--- a/ql/src/test/results/clientpositive/perf/tez/query89.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/query89.q.out
@@ -65,42 +65,41 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 11 (BROADCAST_EDGE), Reducer 9 (BROADCAST_EDGE)
-Reducer 11 <- Map 10 (CUSTOM_SIMPLE_EDGE)
+Map 1 <- Reducer 10 (BROADCAST_EDGE)
+Reducer 10 <- Map 9 (CUSTOM_SIMPLE_EDGE)
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
-Reducer 3 <- Map 10 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
-Reducer 4 <- Map 12 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
+Reducer 3 <- Map 9 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
+Reducer 4 <- Map 11 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
 Reducer 5 <- Reducer 4 (SIMPLE_EDGE)
 Reducer 6 <- Reducer 5 (SIMPLE_EDGE)
 Reducer 7 <- Reducer 6 (SIMPLE_EDGE)
-Reducer 9 <- Map 8 (CUSTOM_SIMPLE_EDGE)
 
 Stage-0
   Fetch Operator
     limit:-1
     Stage-1
       Reducer 7 vectorized
-      File Output Operator [FS_117]
-        Limit [LIM_116] (rows=100 width=801)
+      File Output Operator [FS_112]
+        Limit [LIM_111] (rows=100 width=801)
           Number of rows:100
-          Select Operator [SEL_115] (rows=4804228 width=801)
+          Select Operator [SEL_110] (rows=4804228 width=801)
             
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"]
           <-Reducer 6 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_114]
-              Select Operator [SEL_113] (rows=4804228 width=801)
+            SHUFFLE [RS_109]
+              Select Operator [SEL_108] (rows=4804228 width=801)
                 
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"]
-                Filter Operator [FIL_112] (rows=4804228 width=689)
+                Filter Operator [FIL_107] (rows=4804228 width=689)
                   predicate:CASE WHEN ((avg_window_0 <> 0)) THEN (((abs((_col6 
- avg_window_0)) / avg_window_0) > 0.1)) ELSE (null) END
-                  Select Operator [SEL_111] (rows=9608456 width=577)
+                  Select Operator [SEL_106] (rows=9608456 width=577)
                     
Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5","_col6"]
-                    PTF Operator [PTF_110] (rows=9608456 width=577)
+                    PTF Operator [PTF_105] (rows=9608456 width=577)
                       Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS 
FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col5 ASC NULLS 
FIRST","partition by:":"_col2, _col0, _col4, _col5"}]
-                      Select Operator [SEL_109] (rows=9608456 width=577)
+                      Select Operator [SEL_104] (rows=9608456 width=577)
                         
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"]
                       <-Reducer 5 [SIMPLE_EDGE] vectorized
-                        SHUFFLE [RS_108]
+                        SHUFFLE [RS_103]
                           PartitionCols:_col2, _col0, _col4, _col5
-                          Group By Operator [GBY_107] (rows=9608456 width=577)
+                          Group By Operator [GBY_102] (rows=9608456 width=577)
                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5
                           <-Reducer 4 [SIMPLE_EDGE]
                             SHUFFLE [RS_23]
@@ -108,13 +107,13 @@ Stage-0
                               Group By Operator [GBY_22] (rows=27308180 
width=577)
                                 
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)"],keys:_col5,
 _col6, _col7, _col9, _col11, _col12
                                 Merge Join Operator [MERGEJOIN_84] 
(rows=27308180 width=480)
-                                  
Conds:RS_18._col2=RS_106._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12"]
-                                <-Map 12 [SIMPLE_EDGE] vectorized
-                                  SHUFFLE [RS_106]
+                                  
Conds:RS_18._col2=RS_101._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12"]
+                                <-Map 11 [SIMPLE_EDGE] vectorized
+                                  SHUFFLE [RS_101]
                                     PartitionCols:_col0
-                                    Select Operator [SEL_105] (rows=1704 
width=183)
+                                    Select Operator [SEL_100] (rows=1704 
width=183)
                                       Output:["_col0","_col1","_col2"]
-                                      Filter Operator [FIL_104] (rows=1704 
width=183)
+                                      Filter Operator [FIL_99] (rows=1704 
width=183)
                                         predicate:s_store_sk is not null
                                         TableScan [TS_9] (rows=1704 width=183)
                                           
default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_name"]
@@ -122,13 +121,13 @@ Stage-0
                                   SHUFFLE [RS_18]
                                     PartitionCols:_col2
                                     Merge Join Operator [MERGEJOIN_83] 
(rows=27308180 width=301)
-                                      
Conds:RS_15._col0=RS_95._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col7","_col9"]
-                                    <-Map 10 [SIMPLE_EDGE] vectorized
-                                      SHUFFLE [RS_95]
+                                      
Conds:RS_15._col0=RS_87._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col7","_col9"]
+                                    <-Map 9 [SIMPLE_EDGE] vectorized
+                                      SHUFFLE [RS_87]
                                         PartitionCols:_col0
-                                        Select Operator [SEL_94] (rows=652 
width=8)
+                                        Select Operator [SEL_86] (rows=652 
width=8)
                                           Output:["_col0","_col1"]
-                                          Filter Operator [FIL_93] (rows=652 
width=12)
+                                          Filter Operator [FIL_85] (rows=652 
width=12)
                                             predicate:((d_year = 2000) and 
d_date_sk is not null)
                                             TableScan [TS_6] (rows=73049 
width=12)
                                               
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
@@ -136,45 +135,34 @@ Stage-0
                                       SHUFFLE [RS_15]
                                         PartitionCols:_col0
                                         Merge Join Operator [MERGEJOIN_82] 
(rows=76480702 width=364)
-                                          
Conds:RS_103._col1=RS_87._col0(Inner),Output:["_col0","_col2","_col3","_col5","_col6","_col7"]
-                                        <-Map 8 [SIMPLE_EDGE] vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_87]
-                                            PartitionCols:_col0
-                                            Select Operator [SEL_86] 
(rows=6988 width=286)
-                                              
Output:["_col0","_col1","_col2","_col3"]
-                                              Filter Operator [FIL_85] 
(rows=6988 width=286)
-                                                predicate:((((i_category) IN 
('Home', 'Books', 'Electronics') and (i_class) IN ('wallpaper', 'parenting', 
'musical')) or ((i_category) IN ('Shoes', 'Jewelry', 'Men') and (i_class) IN 
('womens', 'birdal', 'pants'))) and (i_category) IN ('Home', 'Books', 
'Electronics', 'Shoes', 'Jewelry', 'Men') and (i_class) IN ('wallpaper', 
'parenting', 'musical', 'womens', 'birdal', 'pants') and i_item_sk is not null)
-                                                TableScan [TS_3] (rows=462000 
width=286)
-                                                  
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category"]
+                                          
Conds:RS_95._col1=RS_98._col0(Inner),Output:["_col0","_col2","_col3","_col5","_col6","_col7"]
                                         <-Map 1 [SIMPLE_EDGE] vectorized
-                                          SHUFFLE [RS_103]
+                                          SHUFFLE [RS_95]
                                             PartitionCols:_col1
-                                            Select Operator [SEL_102] 
(rows=525329897 width=118)
+                                            Select Operator [SEL_94] 
(rows=525329897 width=118)
                                               
Output:["_col0","_col1","_col2","_col3"]
-                                              Filter Operator [FIL_101] 
(rows=525329897 width=118)
-                                                predicate:((ss_item_sk BETWEEN 
DynamicValue(RS_13_item_i_item_sk_min) AND 
DynamicValue(RS_13_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, 
DynamicValue(RS_13_item_i_item_sk_bloom_filter))) and (ss_sold_date_sk BETWEEN 
DynamicValue(RS_16_date_dim_d_date_sk_min) AND 
DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) and ss_item_sk is not 
null and ss_sold_date_sk is not null and ss_store_sk is not null)
+                                              Filter Operator [FIL_93] 
(rows=525329897 width=118)
+                                                predicate:((ss_sold_date_sk 
BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND 
DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) and ss_item_sk is not 
null and ss_sold_date_sk is not null and ss_store_sk is not null)
                                                 TableScan [TS_0] 
(rows=575995635 width=118)
                                                   
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"]
-                                                <-Reducer 11 [BROADCAST_EDGE] 
vectorized
-                                                  BROADCAST [RS_100]
-                                                    Group By Operator [GBY_99] 
(rows=1 width=12)
-                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                    <-Map 10 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                      SHUFFLE [RS_98]
-                                                        Group By Operator 
[GBY_97] (rows=1 width=12)
-                                                          
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                          Select Operator 
[SEL_96] (rows=652 width=4)
-                                                            Output:["_col0"]
-                                                             Please refer to 
the previous Select Operator [SEL_94]
-                                                <-Reducer 9 [BROADCAST_EDGE] 
vectorized
+                                                <-Reducer 10 [BROADCAST_EDGE] 
vectorized
                                                   BROADCAST [RS_92]
                                                     Group By Operator [GBY_91] 
(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_90]
+                                                    <-Map 9 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                      SHUFFLE [RS_90]
                                                         Group By Operator 
[GBY_89] (rows=1 width=12)
                                                           
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                          Select Operator 
[SEL_88] (rows=6988 width=4)
+                                                          Select Operator 
[SEL_88] (rows=652 width=4)
                                                             Output:["_col0"]
                                                              Please refer to 
the previous Select Operator [SEL_86]
+                                        <-Map 8 [SIMPLE_EDGE] vectorized
+                                          SHUFFLE [RS_98]
+                                            PartitionCols:_col0
+                                            Select Operator [SEL_97] 
(rows=6988 width=286)
+                                              
Output:["_col0","_col1","_col2","_col3"]
+                                              Filter Operator [FIL_96] 
(rows=6988 width=286)
+                                                predicate:((((i_category) IN 
('Home', 'Books', 'Electronics') and (i_class) IN ('wallpaper', 'parenting', 
'musical')) or ((i_category) IN ('Shoes', 'Jewelry', 'Men') and (i_class) IN 
('womens', 'birdal', 'pants'))) and (i_category) IN ('Home', 'Books', 
'Electronics', 'Shoes', 'Jewelry', 'Men') and (i_class) IN ('wallpaper', 
'parenting', 'musical', 'womens', 'birdal', 'pants') and i_item_sk is not null)
+                                                TableScan [TS_3] (rows=462000 
width=286)
+                                                  
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category"]
 

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/query90.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/perf/tez/query90.q.out 
b/ql/src/test/results/clientpositive/perf/tez/query90.q.out
index 916a232..0ba2b2a 100644
--- a/ql/src/test/results/clientpositive/perf/tez/query90.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/query90.q.out
@@ -54,34 +54,27 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 16 (BROADCAST_EDGE), Reducer 19 (BROADCAST_EDGE), Reducer 9 
(BROADCAST_EDGE)
-Map 21 <- Reducer 14 (BROADCAST_EDGE), Reducer 17 (BROADCAST_EDGE), Reducer 20 
(BROADCAST_EDGE)
-Reducer 10 <- Map 21 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
-Reducer 11 <- Map 15 (SIMPLE_EDGE), Reducer 10 (SIMPLE_EDGE)
-Reducer 12 <- Map 18 (SIMPLE_EDGE), Reducer 11 (SIMPLE_EDGE)
-Reducer 13 <- Reducer 12 (CUSTOM_SIMPLE_EDGE)
-Reducer 14 <- Map 8 (CUSTOM_SIMPLE_EDGE)
-Reducer 16 <- Map 15 (CUSTOM_SIMPLE_EDGE)
-Reducer 17 <- Map 15 (CUSTOM_SIMPLE_EDGE)
-Reducer 19 <- Map 18 (CUSTOM_SIMPLE_EDGE)
-Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
-Reducer 20 <- Map 18 (CUSTOM_SIMPLE_EDGE)
-Reducer 3 <- Map 15 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
-Reducer 4 <- Map 18 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
+Map 1 <- Reducer 14 (BROADCAST_EDGE)
+Reducer 10 <- Reducer 9 (CUSTOM_SIMPLE_EDGE)
+Reducer 14 <- Map 13 (CUSTOM_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 13 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
 Reducer 5 <- Reducer 4 (CUSTOM_SIMPLE_EDGE)
-Reducer 6 <- Reducer 13 (CUSTOM_SIMPLE_EDGE), Reducer 5 (CUSTOM_SIMPLE_EDGE)
+Reducer 6 <- Reducer 10 (CUSTOM_SIMPLE_EDGE), Reducer 5 (CUSTOM_SIMPLE_EDGE)
 Reducer 7 <- Reducer 6 (SIMPLE_EDGE)
-Reducer 9 <- Map 8 (CUSTOM_SIMPLE_EDGE)
+Reducer 8 <- Map 12 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
+Reducer 9 <- Map 13 (SIMPLE_EDGE), Reducer 8 (SIMPLE_EDGE)
 
 Stage-0
   Fetch Operator
     limit:100
     Stage-1
       Reducer 7 vectorized
-      File Output Operator [FS_209]
-        Limit [LIM_208] (rows=1 width=112)
+      File Output Operator [FS_180]
+        Limit [LIM_179] (rows=1 width=112)
           Number of rows:100
-          Select Operator [SEL_207] (rows=1 width=112)
+          Select Operator [SEL_178] (rows=1 width=112)
             Output:["_col0"]
           <-Reducer 6 [SIMPLE_EDGE]
             SHUFFLE [RS_56]
@@ -89,171 +82,102 @@ Stage-0
                 Output:["_col0"]
                 Merge Join Operator [MERGEJOIN_152] (rows=1 width=16)
                   Conds:(Inner),Output:["_col0","_col1"]
-                <-Reducer 13 [CUSTOM_SIMPLE_EDGE] vectorized
-                  PARTITION_ONLY_SHUFFLE [RS_206]
-                    Group By Operator [GBY_205] (rows=1 width=8)
+                <-Reducer 10 [CUSTOM_SIMPLE_EDGE] vectorized
+                  PARTITION_ONLY_SHUFFLE [RS_177]
+                    Group By Operator [GBY_176] (rows=1 width=8)
                       Output:["_col0"],aggregations:["count(VALUE._col0)"]
-                    <-Reducer 12 [CUSTOM_SIMPLE_EDGE]
+                    <-Reducer 9 [CUSTOM_SIMPLE_EDGE]
                       PARTITION_ONLY_SHUFFLE [RS_49]
                         Group By Operator [GBY_48] (rows=1 width=8)
                           Output:["_col0"],aggregations:["count()"]
                           Merge Join Operator [MERGEJOIN_151] (rows=153010 
width=8)
-                            Conds:RS_44._col1=RS_183._col0(Inner)
-                          <-Map 18 [SIMPLE_EDGE] vectorized
-                            SHUFFLE [RS_183]
+                            Conds:RS_44._col1=RS_157._col0(Inner)
+                          <-Map 13 [SIMPLE_EDGE] vectorized
+                            SHUFFLE [RS_157]
                               PartitionCols:_col0
-                              Select Operator [SEL_180] (rows=655 width=4)
+                              Select Operator [SEL_154] (rows=655 width=4)
                                 Output:["_col0"]
-                                Filter Operator [FIL_179] (rows=655 width=8)
+                                Filter Operator [FIL_153] (rows=655 width=8)
                                   predicate:((hd_dep_count = 8) and hd_demo_sk 
is not null)
                                   TableScan [TS_9] (rows=7200 width=8)
                                     
default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count"]
-                          <-Reducer 11 [SIMPLE_EDGE]
+                          <-Reducer 8 [SIMPLE_EDGE]
                             SHUFFLE [RS_44]
                               PartitionCols:_col1
                               Merge Join Operator [MERGEJOIN_150] 
(rows=1681936 width=3)
-                                
Conds:RS_41._col0=RS_171._col0(Inner),Output:["_col1"]
-                              <-Map 15 [SIMPLE_EDGE] vectorized
-                                SHUFFLE [RS_171]
+                                
Conds:RS_41._col0=RS_173._col0(Inner),Output:["_col1"]
+                              <-Map 12 [SIMPLE_EDGE] vectorized
+                                SHUFFLE [RS_173]
                                   PartitionCols:_col0
-                                  Select Operator [SEL_168] (rows=9095 width=4)
+                                  Select Operator [SEL_171] (rows=9095 width=4)
                                     Output:["_col0"]
-                                    Filter Operator [FIL_166] (rows=9095 
width=8)
+                                    Filter Operator [FIL_169] (rows=9095 
width=8)
                                       predicate:(t_hour BETWEEN 14 AND 15 and 
t_time_sk is not null)
                                       TableScan [TS_6] (rows=86400 width=8)
                                         
default@time_dim,time_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["t_time_sk","t_hour"]
-                              <-Reducer 10 [SIMPLE_EDGE]
+                              <-Reducer 2 [SIMPLE_EDGE]
                                 SHUFFLE [RS_41]
                                   PartitionCols:_col0
-                                  Merge Join Operator [MERGEJOIN_149] 
(rows=15977923 width=7)
-                                    
Conds:RS_204._col2=RS_157._col0(Inner),Output:["_col0","_col1"]
-                                  <-Map 8 [SIMPLE_EDGE] vectorized
-                                    PARTITION_ONLY_SHUFFLE [RS_157]
-                                      PartitionCols:_col0
-                                      Select Operator [SEL_154] (rows=511 
width=4)
-                                        Output:["_col0"]
-                                        Filter Operator [FIL_153] (rows=511 
width=7)
-                                          predicate:(wp_char_count BETWEEN 
5000 AND 5200 and wp_web_page_sk is not null)
-                                          TableScan [TS_3] (rows=4602 width=7)
-                                            
default@web_page,web_page,Tbl:COMPLETE,Col:COMPLETE,Output:["wp_web_page_sk","wp_char_count"]
-                                  <-Map 21 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_204]
+                                  Merge Join Operator [MERGEJOIN_146] 
(rows=15977923 width=7)
+                                    
Conds:RS_164._col2=RS_167._col0(Inner),Output:["_col0","_col1"]
+                                  <-Map 1 [SIMPLE_EDGE] vectorized
+                                    SHUFFLE [RS_164]
                                       PartitionCols:_col2
-                                      Select Operator [SEL_203] 
(rows=143895111 width=11)
+                                      Select Operator [SEL_163] 
(rows=143895111 width=11)
                                         Output:["_col0","_col1","_col2"]
-                                        Filter Operator [FIL_202] 
(rows=143895111 width=11)
-                                          predicate:((ws_ship_hdemo_sk BETWEEN 
DynamicValue(RS_45_household_demographics_hd_demo_sk_min) AND 
DynamicValue(RS_45_household_demographics_hd_demo_sk_max) and 
in_bloom_filter(ws_ship_hdemo_sk, 
DynamicValue(RS_45_household_demographics_hd_demo_sk_bloom_filter))) and 
(ws_sold_time_sk BETWEEN DynamicValue(RS_42_time_dim_t_time_sk_min) AND 
DynamicValue(RS_42_time_dim_t_time_sk_max) and in_bloom_filter(ws_sold_time_sk, 
DynamicValue(RS_42_time_dim_t_time_sk_bloom_filter))) and (ws_web_page_sk 
BETWEEN DynamicValue(RS_39_web_page_wp_web_page_sk_min) AND 
DynamicValue(RS_39_web_page_wp_web_page_sk_max) and 
in_bloom_filter(ws_web_page_sk, 
DynamicValue(RS_39_web_page_wp_web_page_sk_bloom_filter))) and ws_ship_hdemo_sk 
is not null and ws_sold_time_sk is not null and ws_web_page_sk is not null)
-                                          TableScan [TS_26] (rows=144002668 
width=11)
+                                        Filter Operator [FIL_162] 
(rows=143895111 width=11)
+                                          predicate:((ws_ship_hdemo_sk BETWEEN 
DynamicValue(RS_19_household_demographics_hd_demo_sk_min) AND 
DynamicValue(RS_19_household_demographics_hd_demo_sk_max) and 
in_bloom_filter(ws_ship_hdemo_sk, 
DynamicValue(RS_19_household_demographics_hd_demo_sk_bloom_filter))) and 
ws_ship_hdemo_sk is not null and ws_sold_time_sk is not null and ws_web_page_sk 
is not null)
+                                          TableScan [TS_0] (rows=144002668 
width=11)
                                             
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_time_sk","ws_ship_hdemo_sk","ws_web_page_sk"]
                                           <-Reducer 14 [BROADCAST_EDGE] 
vectorized
-                                            BROADCAST [RS_197]
-                                              Group By Operator [GBY_196] 
(rows=1 width=12)
+                                            BROADCAST [RS_161]
+                                              Group By Operator [GBY_160] 
(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_162]
-                                                  Group By Operator [GBY_160] 
(rows=1 width=12)
+                                              <-Map 13 [CUSTOM_SIMPLE_EDGE] 
vectorized
+                                                SHUFFLE [RS_159]
+                                                  Group By Operator [GBY_158] 
(rows=1 width=12)
                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                    Select Operator [SEL_158] 
(rows=511 width=4)
+                                                    Select Operator [SEL_156] 
(rows=655 width=4)
                                                       Output:["_col0"]
                                                        Please refer to the 
previous Select Operator [SEL_154]
-                                          <-Reducer 17 [BROADCAST_EDGE] 
vectorized
-                                            BROADCAST [RS_199]
-                                              Group By Operator [GBY_198] 
(rows=1 width=12)
-                                                
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                              <-Map 15 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                                SHUFFLE [RS_176]
-                                                  Group By Operator [GBY_174] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                    Select Operator [SEL_172] 
(rows=9095 width=4)
-                                                      Output:["_col0"]
-                                                       Please refer to the 
previous Select Operator [SEL_168]
-                                          <-Reducer 20 [BROADCAST_EDGE] 
vectorized
-                                            BROADCAST [RS_201]
-                                              Group By Operator [GBY_200] 
(rows=1 width=12)
-                                                
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                              <-Map 18 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                                SHUFFLE [RS_188]
-                                                  Group By Operator [GBY_186] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                    Select Operator [SEL_184] 
(rows=655 width=4)
-                                                      Output:["_col0"]
-                                                       Please refer to the 
previous Select Operator [SEL_180]
+                                  <-Map 11 [SIMPLE_EDGE] vectorized
+                                    SHUFFLE [RS_167]
+                                      PartitionCols:_col0
+                                      Select Operator [SEL_166] (rows=511 
width=4)
+                                        Output:["_col0"]
+                                        Filter Operator [FIL_165] (rows=511 
width=7)
+                                          predicate:(wp_char_count BETWEEN 
5000 AND 5200 and wp_web_page_sk is not null)
+                                          TableScan [TS_3] (rows=4602 width=7)
+                                            
default@web_page,web_page,Tbl:COMPLETE,Col:COMPLETE,Output:["wp_web_page_sk","wp_char_count"]
                 <-Reducer 5 [CUSTOM_SIMPLE_EDGE] vectorized
-                  PARTITION_ONLY_SHUFFLE [RS_195]
-                    Group By Operator [GBY_194] (rows=1 width=8)
+                  PARTITION_ONLY_SHUFFLE [RS_175]
+                    Group By Operator [GBY_174] (rows=1 width=8)
                       Output:["_col0"],aggregations:["count(VALUE._col0)"]
                     <-Reducer 4 [CUSTOM_SIMPLE_EDGE]
                       PARTITION_ONLY_SHUFFLE [RS_23]
                         Group By Operator [GBY_22] (rows=1 width=8)
                           Output:["_col0"],aggregations:["count()"]
                           Merge Join Operator [MERGEJOIN_148] (rows=153010 
width=8)
-                            Conds:RS_18._col1=RS_181._col0(Inner)
-                          <-Map 18 [SIMPLE_EDGE] vectorized
-                            SHUFFLE [RS_181]
+                            Conds:RS_18._col1=RS_155._col0(Inner)
+                          <-Map 13 [SIMPLE_EDGE] vectorized
+                            SHUFFLE [RS_155]
                               PartitionCols:_col0
-                               Please refer to the previous Select Operator 
[SEL_180]
+                               Please refer to the previous Select Operator 
[SEL_154]
                           <-Reducer 3 [SIMPLE_EDGE]
                             SHUFFLE [RS_18]
                               PartitionCols:_col1
                               Merge Join Operator [MERGEJOIN_147] 
(rows=1681936 width=3)
-                                
Conds:RS_15._col0=RS_169._col0(Inner),Output:["_col1"]
-                              <-Map 15 [SIMPLE_EDGE] vectorized
-                                SHUFFLE [RS_169]
+                                
Conds:RS_15._col0=RS_172._col0(Inner),Output:["_col1"]
+                              <-Map 12 [SIMPLE_EDGE] vectorized
+                                SHUFFLE [RS_172]
                                   PartitionCols:_col0
-                                  Select Operator [SEL_167] (rows=9095 width=4)
+                                  Select Operator [SEL_170] (rows=9095 width=4)
                                     Output:["_col0"]
-                                    Filter Operator [FIL_165] (rows=9095 
width=8)
+                                    Filter Operator [FIL_168] (rows=9095 
width=8)
                                       predicate:(t_hour BETWEEN 6 AND 7 and 
t_time_sk is not null)
                                        Please refer to the previous TableScan 
[TS_6]
                               <-Reducer 2 [SIMPLE_EDGE]
                                 SHUFFLE [RS_15]
                                   PartitionCols:_col0
-                                  Merge Join Operator [MERGEJOIN_146] 
(rows=15977923 width=7)
-                                    
Conds:RS_193._col2=RS_155._col0(Inner),Output:["_col0","_col1"]
-                                  <-Map 8 [SIMPLE_EDGE] vectorized
-                                    PARTITION_ONLY_SHUFFLE [RS_155]
-                                      PartitionCols:_col0
-                                       Please refer to the previous Select 
Operator [SEL_154]
-                                  <-Map 1 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_193]
-                                      PartitionCols:_col2
-                                      Select Operator [SEL_192] 
(rows=143895111 width=11)
-                                        Output:["_col0","_col1","_col2"]
-                                        Filter Operator [FIL_191] 
(rows=143895111 width=11)
-                                          predicate:((ws_ship_hdemo_sk BETWEEN 
DynamicValue(RS_19_household_demographics_hd_demo_sk_min) AND 
DynamicValue(RS_19_household_demographics_hd_demo_sk_max) and 
in_bloom_filter(ws_ship_hdemo_sk, 
DynamicValue(RS_19_household_demographics_hd_demo_sk_bloom_filter))) and 
(ws_sold_time_sk BETWEEN DynamicValue(RS_16_time_dim_t_time_sk_min) AND 
DynamicValue(RS_16_time_dim_t_time_sk_max) and in_bloom_filter(ws_sold_time_sk, 
DynamicValue(RS_16_time_dim_t_time_sk_bloom_filter))) and (ws_web_page_sk 
BETWEEN DynamicValue(RS_13_web_page_wp_web_page_sk_min) AND 
DynamicValue(RS_13_web_page_wp_web_page_sk_max) and 
in_bloom_filter(ws_web_page_sk, 
DynamicValue(RS_13_web_page_wp_web_page_sk_bloom_filter))) and ws_ship_hdemo_sk 
is not null and ws_sold_time_sk is not null and ws_web_page_sk is not null)
-                                          TableScan [TS_0] (rows=144002668 
width=11)
-                                            
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_time_sk","ws_ship_hdemo_sk","ws_web_page_sk"]
-                                          <-Reducer 16 [BROADCAST_EDGE] 
vectorized
-                                            BROADCAST [RS_178]
-                                              Group By Operator [GBY_177] 
(rows=1 width=12)
-                                                
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                              <-Map 15 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                                SHUFFLE [RS_175]
-                                                  Group By Operator [GBY_173] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                    Select Operator [SEL_170] 
(rows=9095 width=4)
-                                                      Output:["_col0"]
-                                                       Please refer to the 
previous Select Operator [SEL_167]
-                                          <-Reducer 19 [BROADCAST_EDGE] 
vectorized
-                                            BROADCAST [RS_190]
-                                              Group By Operator [GBY_189] 
(rows=1 width=12)
-                                                
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                              <-Map 18 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                                SHUFFLE [RS_187]
-                                                  Group By Operator [GBY_185] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                    Select Operator [SEL_182] 
(rows=655 width=4)
-                                                      Output:["_col0"]
-                                                       Please refer to the 
previous Select Operator [SEL_180]
-                                          <-Reducer 9 [BROADCAST_EDGE] 
vectorized
-                                            BROADCAST [RS_164]
-                                              Group By Operator [GBY_163] 
(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_161]
-                                                  Group By Operator [GBY_159] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                    Select Operator [SEL_156] 
(rows=511 width=4)
-                                                      Output:["_col0"]
-                                                       Please refer to the 
previous Select Operator [SEL_154]
+                                   Please refer to the previous Merge Join 
Operator [MERGEJOIN_146]
 

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/query92.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/perf/tez/query92.q.out 
b/ql/src/test/results/clientpositive/perf/tez/query92.q.out
index 1f837dd..3989d9e 100644
--- a/ql/src/test/results/clientpositive/perf/tez/query92.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/query92.q.out
@@ -67,35 +67,33 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 15 (BROADCAST_EDGE), Reducer 8 (BROADCAST_EDGE)
-Map 13 <- Reducer 12 (BROADCAST_EDGE), Reducer 15 (BROADCAST_EDGE), Reducer 6 
(BROADCAST_EDGE)
-Reducer 10 <- Reducer 9 (SIMPLE_EDGE)
-Reducer 11 <- Map 14 (SIMPLE_EDGE), Reducer 10 (ONE_TO_ONE_EDGE)
-Reducer 12 <- Map 7 (CUSTOM_SIMPLE_EDGE)
-Reducer 15 <- Map 14 (CUSTOM_SIMPLE_EDGE)
-Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 7 (SIMPLE_EDGE)
-Reducer 3 <- Reducer 11 (ONE_TO_ONE_EDGE), Reducer 2 (SIMPLE_EDGE)
+Map 1 <- Reducer 10 (BROADCAST_EDGE)
+Map 11 <- Reducer 13 (BROADCAST_EDGE)
+Reducer 10 <- Reducer 9 (CUSTOM_SIMPLE_EDGE)
+Reducer 13 <- Map 12 (CUSTOM_SIMPLE_EDGE)
+Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 6 (SIMPLE_EDGE)
+Reducer 3 <- Reducer 2 (SIMPLE_EDGE), Reducer 9 (ONE_TO_ONE_EDGE)
 Reducer 4 <- Reducer 3 (CUSTOM_SIMPLE_EDGE)
 Reducer 5 <- Reducer 4 (SIMPLE_EDGE)
-Reducer 6 <- Reducer 2 (CUSTOM_SIMPLE_EDGE)
-Reducer 8 <- Map 7 (CUSTOM_SIMPLE_EDGE)
-Reducer 9 <- Map 13 (SIMPLE_EDGE), Map 7 (SIMPLE_EDGE)
+Reducer 7 <- Map 11 (SIMPLE_EDGE), Map 6 (SIMPLE_EDGE)
+Reducer 8 <- Reducer 7 (SIMPLE_EDGE)
+Reducer 9 <- Map 12 (SIMPLE_EDGE), Reducer 8 (ONE_TO_ONE_EDGE)
 
 Stage-0
   Fetch Operator
     limit:-1
     Stage-1
       Reducer 5 vectorized
-      File Output Operator [FS_147]
-        Limit [LIM_146] (rows=1 width=224)
+      File Output Operator [FS_136]
+        Limit [LIM_135] (rows=1 width=224)
           Number of rows:100
-          Select Operator [SEL_145] (rows=1 width=224)
+          Select Operator [SEL_134] (rows=1 width=224)
             Output:["_col0"]
           <-Reducer 4 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_144]
-              Select Operator [SEL_143] (rows=1 width=224)
+            SHUFFLE [RS_133]
+              Select Operator [SEL_132] (rows=1 width=224)
                 Output:["_col1"]
-                Group By Operator [GBY_142] (rows=1 width=112)
+                Group By Operator [GBY_131] (rows=1 width=112)
                   Output:["_col0"],aggregations:["sum(VALUE._col0)"]
                 <-Reducer 3 [CUSTOM_SIMPLE_EDGE]
                   PARTITION_ONLY_SHUFFLE [RS_36]
@@ -107,115 +105,90 @@ Stage-0
                           predicate:(_col2 > _col5)
                           Merge Join Operator [MERGEJOIN_107] (rows=7434 
width=112)
                             
Conds:RS_30._col1=RS_31._col2(Inner),Output:["_col2","_col5"]
-                          <-Reducer 2 [SIMPLE_EDGE]
-                            PARTITION_ONLY_SHUFFLE [RS_30]
-                              PartitionCols:_col1
-                              Merge Join Operator [MERGEJOIN_104] 
(rows=15995224 width=115)
-                                
Conds:RS_131._col0=RS_110._col0(Inner),Output:["_col1","_col2"]
-                              <-Map 7 [SIMPLE_EDGE] vectorized
-                                SHUFFLE [RS_110]
-                                  PartitionCols:_col0
-                                  Select Operator [SEL_109] (rows=8116 width=4)
-                                    Output:["_col0"]
-                                    Filter Operator [FIL_108] (rows=8116 
width=98)
-                                      predicate:(CAST( d_date AS TIMESTAMP) 
BETWEEN TIMESTAMP'1998-03-18 00:00:00' AND TIMESTAMP'1998-06-16 00:00:00' and 
d_date_sk is not null)
-                                      TableScan [TS_3] (rows=73049 width=98)
-                                        
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"]
-                              <-Map 1 [SIMPLE_EDGE] vectorized
-                                SHUFFLE [RS_131]
-                                  PartitionCols:_col0
-                                  Select Operator [SEL_130] (rows=143966864 
width=119)
-                                    Output:["_col0","_col1","_col2"]
-                                    Filter Operator [FIL_129] (rows=143966864 
width=119)
-                                      predicate:((ws_item_sk BETWEEN 
DynamicValue(RS_24_item_i_item_sk_min) AND 
DynamicValue(RS_24_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_24_item_i_item_sk_bloom_filter))) and (ws_sold_date_sk BETWEEN 
DynamicValue(RS_28_date_dim_d_date_sk_min) AND 
DynamicValue(RS_28_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_28_date_dim_d_date_sk_bloom_filter))) and ws_item_sk is not 
null and ws_sold_date_sk is not null)
-                                      TableScan [TS_0] (rows=144002668 
width=119)
-                                        
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_discount_amt"]
-                                      <-Reducer 15 [BROADCAST_EDGE] vectorized
-                                        BROADCAST [RS_127]
-                                          Group By Operator [GBY_126] (rows=1 
width=12)
-                                            
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                          <-Map 14 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                            PARTITION_ONLY_SHUFFLE [RS_125]
-                                              Group By Operator [GBY_124] 
(rows=1 width=12)
-                                                
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                Select Operator [SEL_123] 
(rows=669 width=4)
-                                                  Output:["_col0"]
-                                                  Select Operator [SEL_121] 
(rows=669 width=4)
-                                                    Output:["_col0"]
-                                                    Filter Operator [FIL_120] 
(rows=669 width=7)
-                                                      
predicate:((i_manufact_id = 269) and i_item_sk is not null)
-                                                      TableScan [TS_20] 
(rows=462000 width=7)
-                                                        
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_manufact_id"]
-                                      <-Reducer 8 [BROADCAST_EDGE] vectorized
-                                        BROADCAST [RS_119]
-                                          Group By Operator [GBY_118] (rows=1 
width=12)
-                                            
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                          <-Map 7 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                            SHUFFLE [RS_116]
-                                              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_111] 
(rows=8116 width=4)
-                                                  Output:["_col0"]
-                                                   Please refer to the 
previous Select Operator [SEL_109]
-                          <-Reducer 11 [ONE_TO_ONE_EDGE]
+                          <-Reducer 9 [ONE_TO_ONE_EDGE]
                             FORWARD [RS_31]
                               PartitionCols:_col2
                               Merge Join Operator [MERGEJOIN_106] (rows=97 
width=116)
-                                
Conds:RS_141._col0=RS_122._col0(Inner),Output:["_col1","_col2"]
-                              <-Map 14 [SIMPLE_EDGE] vectorized
-                                PARTITION_ONLY_SHUFFLE [RS_122]
+                                
Conds:RS_125._col0=RS_114._col0(Inner),Output:["_col1","_col2"]
+                              <-Map 12 [SIMPLE_EDGE] vectorized
+                                SHUFFLE [RS_114]
                                   PartitionCols:_col0
-                                   Please refer to the previous Select 
Operator [SEL_121]
-                              <-Reducer 10 [ONE_TO_ONE_EDGE] vectorized
-                                FORWARD [RS_141]
+                                  Select Operator [SEL_113] (rows=669 width=4)
+                                    Output:["_col0"]
+                                    Filter Operator [FIL_112] (rows=669 
width=7)
+                                      predicate:((i_manufact_id = 269) and 
i_item_sk is not null)
+                                      TableScan [TS_20] (rows=462000 width=7)
+                                        
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_manufact_id"]
+                              <-Reducer 8 [ONE_TO_ONE_EDGE] vectorized
+                                FORWARD [RS_125]
                                   PartitionCols:_col0
-                                  Select Operator [SEL_140] (rows=6951 
width=116)
+                                  Select Operator [SEL_124] (rows=6951 
width=116)
                                     Output:["_col0","_col1"]
-                                    Group By Operator [GBY_139] (rows=6951 
width=124)
+                                    Group By Operator [GBY_123] (rows=6951 
width=124)
                                       
Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0
-                                    <-Reducer 9 [SIMPLE_EDGE]
+                                    <-Reducer 7 [SIMPLE_EDGE]
                                       SHUFFLE [RS_17]
                                         PartitionCols:_col0
                                         Group By Operator [GBY_16] (rows=55608 
width=124)
                                           
Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col1
                                           Merge Join Operator [MERGEJOIN_105] 
(rows=15995224 width=115)
-                                            
Conds:RS_138._col0=RS_112._col0(Inner),Output:["_col1","_col2"]
-                                          <-Map 7 [SIMPLE_EDGE] vectorized
-                                            SHUFFLE [RS_112]
+                                            
Conds:RS_122._col0=RS_111._col0(Inner),Output:["_col1","_col2"]
+                                          <-Map 6 [SIMPLE_EDGE] vectorized
+                                            SHUFFLE [RS_111]
                                               PartitionCols:_col0
-                                               Please refer to the previous 
Select Operator [SEL_109]
-                                          <-Map 13 [SIMPLE_EDGE] vectorized
-                                            SHUFFLE [RS_138]
+                                              Select Operator [SEL_109] 
(rows=8116 width=4)
+                                                Output:["_col0"]
+                                                Filter Operator [FIL_108] 
(rows=8116 width=98)
+                                                  predicate:(CAST( d_date AS 
TIMESTAMP) BETWEEN TIMESTAMP'1998-03-18 00:00:00' AND TIMESTAMP'1998-06-16 
00:00:00' and d_date_sk is not null)
+                                                  TableScan [TS_3] (rows=73049 
width=98)
+                                                    
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"]
+                                          <-Map 11 [SIMPLE_EDGE] vectorized
+                                            SHUFFLE [RS_122]
                                               PartitionCols:_col0
-                                              Select Operator [SEL_137] 
(rows=143966864 width=119)
+                                              Select Operator [SEL_121] 
(rows=143966864 width=119)
                                                 
Output:["_col0","_col1","_col2"]
-                                                Filter Operator [FIL_136] 
(rows=143966864 width=119)
-                                                  predicate:((ws_item_sk 
BETWEEN DynamicValue(RS_24_item_i_item_sk_min) AND 
DynamicValue(RS_24_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_24_item_i_item_sk_bloom_filter))) and (ws_item_sk BETWEEN 
DynamicValue(RS_30_web_sales_ws_item_sk_min) AND 
DynamicValue(RS_30_web_sales_ws_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_30_web_sales_ws_item_sk_bloom_filter))) and (ws_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(ws_sold_date_sk, 
DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) and ws_item_sk is not 
null and ws_sold_date_sk is not null)
+                                                Filter Operator [FIL_120] 
(rows=143966864 width=119)
+                                                  predicate:((ws_item_sk 
BETWEEN DynamicValue(RS_24_item_i_item_sk_min) AND 
DynamicValue(RS_24_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_24_item_i_item_sk_bloom_filter))) and ws_item_sk is not null 
and ws_sold_date_sk is not null)
                                                   TableScan [TS_6] 
(rows=144002668 width=119)
                                                     
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_discount_amt"]
-                                                  <-Reducer 15 
[BROADCAST_EDGE] vectorized
-                                                    BROADCAST [RS_128]
-                                                       Please refer to the 
previous Group By Operator [GBY_126]
-                                                  <-Reducer 12 
[BROADCAST_EDGE] vectorized
-                                                    BROADCAST [RS_133]
-                                                      Group By Operator 
[GBY_132] (rows=1 width=12)
+                                                  <-Reducer 13 
[BROADCAST_EDGE] vectorized
+                                                    BROADCAST [RS_119]
+                                                      Group By Operator 
[GBY_118] (rows=1 width=12)
                                                         
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                      <-Map 7 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                      <-Map 12 
[CUSTOM_SIMPLE_EDGE] vectorized
                                                         SHUFFLE [RS_117]
-                                                          Group By Operator 
[GBY_115] (rows=1 width=12)
+                                                          Group By Operator 
[GBY_116] (rows=1 width=12)
                                                             
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                            Select Operator 
[SEL_113] (rows=8116 width=4)
+                                                            Select Operator 
[SEL_115] (rows=669 width=4)
                                                               Output:["_col0"]
-                                                               Please refer to 
the previous Select Operator [SEL_109]
-                                                  <-Reducer 6 [BROADCAST_EDGE] 
vectorized
-                                                    BROADCAST [RS_135]
-                                                      Group By Operator 
[GBY_134] (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_94]
-                                                          Group By Operator 
[GBY_93] (rows=1 width=12)
-                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                            Select Operator 
[SEL_92] (rows=15995224 width=8)
-                                                              Output:["_col0"]
-                                                               Please refer to 
the previous Merge Join Operator [MERGEJOIN_104]
+                                                               Please refer to 
the previous Select Operator [SEL_113]
+                          <-Reducer 2 [SIMPLE_EDGE]
+                            SHUFFLE [RS_30]
+                              PartitionCols:_col1
+                              Merge Join Operator [MERGEJOIN_104] 
(rows=15995224 width=115)
+                                
Conds:RS_130._col0=RS_110._col0(Inner),Output:["_col1","_col2"]
+                              <-Map 6 [SIMPLE_EDGE] vectorized
+                                SHUFFLE [RS_110]
+                                  PartitionCols:_col0
+                                   Please refer to the previous Select 
Operator [SEL_109]
+                              <-Map 1 [SIMPLE_EDGE] vectorized
+                                SHUFFLE [RS_130]
+                                  PartitionCols:_col0
+                                  Select Operator [SEL_129] (rows=143966864 
width=119)
+                                    Output:["_col0","_col1","_col2"]
+                                    Filter Operator [FIL_128] (rows=143966864 
width=119)
+                                      predicate:((ws_item_sk BETWEEN 
DynamicValue(RS_31_item_i_item_sk_min) AND 
DynamicValue(RS_31_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_31_item_i_item_sk_bloom_filter))) and ws_item_sk is not null 
and ws_sold_date_sk is not null)
+                                      TableScan [TS_0] (rows=144002668 
width=119)
+                                        
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_discount_amt"]
+                                      <-Reducer 10 [BROADCAST_EDGE] vectorized
+                                        BROADCAST [RS_127]
+                                          Group By Operator [GBY_126] (rows=1 
width=12)
+                                            
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
+                                          <-Reducer 9 [CUSTOM_SIMPLE_EDGE]
+                                            FORWARD [RS_68]
+                                              Group By Operator [GBY_67] 
(rows=1 width=12)
+                                                
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
+                                                Select Operator [SEL_66] 
(rows=97 width=8)
+                                                  Output:["_col0"]
+                                                   Please refer to the 
previous Merge Join Operator [MERGEJOIN_106]
 

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/query93.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/perf/tez/query93.q.out 
b/ql/src/test/results/clientpositive/perf/tez/query93.q.out
index 45e6e9f..b5e6ba9 100644
--- a/ql/src/test/results/clientpositive/perf/tez/query93.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/query93.q.out
@@ -43,27 +43,26 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 9 <- Reducer 6 (BROADCAST_EDGE), Reducer 7 (BROADCAST_EDGE)
-Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
-Reducer 3 <- Map 9 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
+Map 8 <- Reducer 6 (BROADCAST_EDGE)
+Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 7 (SIMPLE_EDGE)
+Reducer 3 <- Map 8 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
 Reducer 4 <- Reducer 3 (SIMPLE_EDGE)
 Reducer 5 <- Reducer 4 (SIMPLE_EDGE)
 Reducer 6 <- Reducer 2 (CUSTOM_SIMPLE_EDGE)
-Reducer 7 <- Reducer 2 (CUSTOM_SIMPLE_EDGE)
 
 Stage-0
   Fetch Operator
     limit:100
     Stage-1
       Reducer 5 vectorized
-      File Output Operator [FS_82]
-        Limit [LIM_81] (rows=100 width=112)
+      File Output Operator [FS_80]
+        Limit [LIM_79] (rows=100 width=112)
           Number of rows:100
-          Select Operator [SEL_80] (rows=38308 width=112)
+          Select Operator [SEL_78] (rows=38308 width=112)
             Output:["_col0","_col1"]
           <-Reducer 4 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_79]
-              Group By Operator [GBY_78] (rows=38308 width=112)
+            SHUFFLE [RS_77]
+              Group By Operator [GBY_76] (rows=38308 width=112)
                 
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
               <-Reducer 3 [SIMPLE_EDGE]
                 SHUFFLE [RS_18]
@@ -73,7 +72,7 @@ Stage-0
                     Select Operator [SEL_15] (rows=15586502 width=119)
                       Output:["_col0","_col1"]
                       Merge Join Operator [MERGEJOIN_64] (rows=15586502 
width=119)
-                        Conds:RS_12._col0, _col2=RS_77._col0, 
_col2(Inner),Output:["_col3","_col4","_col7","_col9","_col10","_col11"]
+                        Conds:RS_12._col0, _col2=RS_75._col0, 
_col2(Inner),Output:["_col3","_col4","_col7","_col9","_col10","_col11"]
                       <-Reducer 2 [SIMPLE_EDGE]
                         PARTITION_ONLY_SHUFFLE [RS_12]
                           PartitionCols:_col0, _col2
@@ -88,7 +87,7 @@ Stage-0
                                   predicate:(sr_item_sk is not null and 
sr_reason_sk is not null and sr_ticket_number is not null)
                                   TableScan [TS_0] (rows=57591150 width=15)
                                     
default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_reason_sk","sr_ticket_number","sr_return_quantity"]
-                          <-Map 8 [SIMPLE_EDGE] vectorized
+                          <-Map 7 [SIMPLE_EDGE] vectorized
                             SHUFFLE [RS_70]
                               PartitionCols:_col0
                               Select Operator [SEL_69] (rows=1 width=4)
@@ -97,13 +96,13 @@ Stage-0
                                   predicate:((r_reason_desc = 'Did not like 
the warranty') and r_reason_sk is not null)
                                   TableScan [TS_3] (rows=72 width=101)
                                     
default@reason,reason,Tbl:COMPLETE,Col:COMPLETE,Output:["r_reason_sk","r_reason_desc"]
-                      <-Map 9 [SIMPLE_EDGE] vectorized
-                        SHUFFLE [RS_77]
+                      <-Map 8 [SIMPLE_EDGE] vectorized
+                        SHUFFLE [RS_75]
                           PartitionCols:_col0, _col2
-                          Select Operator [SEL_76] (rows=575995635 width=234)
+                          Select Operator [SEL_74] (rows=575995635 width=234)
                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
-                            Filter Operator [FIL_75] (rows=575995635 width=122)
-                              predicate:((ss_item_sk BETWEEN 
DynamicValue(RS_12_store_returns_sr_item_sk_min) AND 
DynamicValue(RS_12_store_returns_sr_item_sk_max) and 
in_bloom_filter(ss_item_sk, 
DynamicValue(RS_12_store_returns_sr_item_sk_bloom_filter))) and 
(ss_ticket_number BETWEEN 
DynamicValue(RS_12_store_returns_sr_ticket_number_min) AND 
DynamicValue(RS_12_store_returns_sr_ticket_number_max) and 
in_bloom_filter(ss_ticket_number, 
DynamicValue(RS_12_store_returns_sr_ticket_number_bloom_filter))) and 
ss_item_sk is not null and ss_ticket_number is not null)
+                            Filter Operator [FIL_73] (rows=575995635 width=122)
+                              predicate:((ss_ticket_number BETWEEN 
DynamicValue(RS_12_store_returns_sr_ticket_number_min) AND 
DynamicValue(RS_12_store_returns_sr_ticket_number_max) and 
in_bloom_filter(ss_ticket_number, 
DynamicValue(RS_12_store_returns_sr_ticket_number_bloom_filter))) and 
ss_item_sk is not null and ss_ticket_number is not null)
                               TableScan [TS_6] (rows=575995635 width=122)
                                 
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_customer_sk","ss_ticket_number","ss_quantity","ss_sales_price"]
                               <-Reducer 6 [BROADCAST_EDGE] vectorized
@@ -111,17 +110,6 @@ Stage-0
                                   Group By Operator [GBY_71] (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_55]
-                                      Group By Operator [GBY_54] (rows=1 
width=12)
-                                        
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                        Select Operator [SEL_53] (rows=1522298 
width=4)
-                                          Output:["_col0"]
-                                           Please refer to the previous Merge 
Join Operator [MERGEJOIN_63]
-                              <-Reducer 7 [BROADCAST_EDGE] vectorized
-                                BROADCAST [RS_74]
-                                  Group By Operator [GBY_73] (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_60]
                                       Group By Operator [GBY_59] (rows=1 
width=12)
                                         
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/query94.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/perf/tez/query94.q.out 
b/ql/src/test/results/clientpositive/perf/tez/query94.q.out
index ada9f3b..e6ac653 100644
--- a/ql/src/test/results/clientpositive/perf/tez/query94.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/query94.q.out
@@ -69,18 +69,16 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 12 (BROADCAST_EDGE), Reducer 14 (BROADCAST_EDGE), Reducer 16 
(BROADCAST_EDGE)
-Map 17 <- Reducer 10 (BROADCAST_EDGE)
+Map 1 <- Reducer 13 (BROADCAST_EDGE)
+Map 15 <- Reducer 10 (BROADCAST_EDGE)
 Reducer 10 <- Reducer 4 (CUSTOM_SIMPLE_EDGE)
-Reducer 12 <- Map 11 (CUSTOM_SIMPLE_EDGE)
-Reducer 14 <- Map 13 (CUSTOM_SIMPLE_EDGE)
-Reducer 16 <- Map 15 (CUSTOM_SIMPLE_EDGE)
-Reducer 19 <- Map 18 (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 13 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
-Reducer 4 <- Map 15 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
-Reducer 5 <- Map 17 (SIMPLE_EDGE), Reducer 4 (SIMPLE_EDGE)
-Reducer 6 <- Reducer 19 (ONE_TO_ONE_EDGE), Reducer 5 (ONE_TO_ONE_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 <- 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)
@@ -90,22 +88,22 @@ Stage-0
     limit:-1
     Stage-1
       Reducer 9 vectorized
-      File Output Operator [FS_178]
-        Limit [LIM_177] (rows=1 width=240)
+      File Output Operator [FS_168]
+        Limit [LIM_167] (rows=1 width=240)
           Number of rows:100
-          Select Operator [SEL_176] (rows=1 width=240)
+          Select Operator [SEL_166] (rows=1 width=240)
             Output:["_col0","_col1","_col2"]
           <-Reducer 8 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_175]
-              Select Operator [SEL_174] (rows=1 width=240)
+            SHUFFLE [RS_165]
+              Select Operator [SEL_164] (rows=1 width=240)
                 Output:["_col1","_col2","_col3"]
-                Group By Operator [GBY_173] (rows=1 width=232)
+                Group By Operator [GBY_163] (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_172]
-                    Group By Operator [GBY_171] (rows=1 width=232)
+                  PARTITION_ONLY_SHUFFLE [RS_162]
+                    Group By Operator [GBY_161] (rows=1 width=232)
                       
Output:["_col0","_col1","_col2"],aggregations:["count(_col0)","sum(_col1)","sum(_col2)"]
-                      Group By Operator [GBY_170] (rows=2511437 width=228)
+                      Group By Operator [GBY_160] (rows=2511437 width=228)
                         
Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0
                       <-Reducer 6 [SIMPLE_EDGE]
                         SHUFFLE [RS_74]
@@ -117,20 +115,20 @@ Stage-0
                               Filter Operator [FIL_41] (rows=5022875 width=229)
                                 predicate:_col14 is null
                                 Merge Join Operator [MERGEJOIN_130] 
(rows=10045750 width=229)
-                                  Conds:RS_38._col4=RS_169._col0(Left 
Outer),Output:["_col4","_col5","_col6","_col14"]
-                                <-Reducer 19 [ONE_TO_ONE_EDGE] vectorized
-                                  FORWARD [RS_169]
+                                  Conds:RS_38._col4=RS_159._col0(Left 
Outer),Output:["_col4","_col5","_col6","_col14"]
+                                <-Reducer 17 [ONE_TO_ONE_EDGE] vectorized
+                                  FORWARD [RS_159]
                                     PartitionCols:_col0
-                                    Select Operator [SEL_168] (rows=8007986 
width=8)
+                                    Select Operator [SEL_158] (rows=8007986 
width=8)
                                       Output:["_col0","_col1"]
-                                      Group By Operator [GBY_167] 
(rows=8007986 width=4)
+                                      Group By Operator [GBY_157] 
(rows=8007986 width=4)
                                         Output:["_col0"],keys:KEY._col0
-                                      <-Map 18 [SIMPLE_EDGE] vectorized
-                                        SHUFFLE [RS_166]
+                                      <-Map 16 [SIMPLE_EDGE] vectorized
+                                        SHUFFLE [RS_156]
                                           PartitionCols:_col0
-                                          Group By Operator [GBY_165] 
(rows=14398467 width=4)
+                                          Group By Operator [GBY_155] 
(rows=14398467 width=4)
                                             
Output:["_col0"],keys:wr_order_number
-                                            Filter Operator [FIL_164] 
(rows=14398467 width=4)
+                                            Filter Operator [FIL_154] 
(rows=14398467 width=4)
                                               predicate:wr_order_number is not 
null
                                               TableScan [TS_25] (rows=14398467 
width=4)
                                                 
default@web_returns,wr1,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_order_number"]
@@ -140,18 +138,18 @@ Stage-0
                                     Select Operator [SEL_37] (rows=5022875 
width=231)
                                       Output:["_col4","_col5","_col6"]
                                       Merge Join Operator [MERGEJOIN_129] 
(rows=5022875 width=235)
-                                        Conds:RS_34._col4=RS_163._col0(Left 
Semi),Output:["_col3","_col4","_col5","_col6","_col14"],residual filter 
predicates:{(_col3 <> _col14)}
+                                        Conds:RS_34._col4=RS_153._col0(Left 
Semi),Output:["_col3","_col4","_col5","_col6","_col14"],residual filter 
predicates:{(_col3 <> _col14)}
                                       <-Reducer 4 [SIMPLE_EDGE]
                                         SHUFFLE [RS_34]
                                           PartitionCols:_col4
                                           Merge Join Operator [MERGEJOIN_128] 
(rows=5022875 width=231)
-                                            
Conds:RS_18._col2=RS_149._col0(Inner),Output:["_col3","_col4","_col5","_col6"]
-                                          <-Map 15 [SIMPLE_EDGE] vectorized
-                                            SHUFFLE [RS_149]
+                                            
Conds:RS_18._col2=RS_147._col0(Inner),Output:["_col3","_col4","_col5","_col6"]
+                                          <-Map 14 [SIMPLE_EDGE] vectorized
+                                            SHUFFLE [RS_147]
                                               PartitionCols:_col0
-                                              Select Operator [SEL_148] 
(rows=12 width=91)
+                                              Select Operator [SEL_146] 
(rows=12 width=91)
                                                 Output:["_col0"]
-                                                Filter Operator [FIL_147] 
(rows=12 width=92)
+                                                Filter Operator [FIL_145] 
(rows=12 width=92)
                                                   predicate:((web_company_name 
= 'pri') and web_site_sk is not null)
                                                   TableScan [TS_9] (rows=84 
width=92)
                                                     
default@web_site,web_site,Tbl:COMPLETE,Col:COMPLETE,Output:["web_site_sk","web_company_name"]
@@ -159,13 +157,13 @@ Stage-0
                                             SHUFFLE [RS_18]
                                               PartitionCols:_col2
                                               Merge Join Operator 
[MERGEJOIN_127] (rows=15673790 width=235)
-                                                
Conds:RS_15._col1=RS_141._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"]
-                                              <-Map 13 [SIMPLE_EDGE] vectorized
-                                                SHUFFLE [RS_141]
+                                                
Conds:RS_15._col1=RS_133._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"]
+                                              <-Map 12 [SIMPLE_EDGE] vectorized
+                                                SHUFFLE [RS_133]
                                                   PartitionCols:_col0
-                                                  Select Operator [SEL_140] 
(rows=784314 width=90)
+                                                  Select Operator [SEL_132] 
(rows=784314 width=90)
                                                     Output:["_col0"]
-                                                    Filter Operator [FIL_139] 
(rows=784314 width=90)
+                                                    Filter Operator [FIL_131] 
(rows=784314 width=90)
                                                       predicate:((ca_state = 
'TX') and ca_address_sk is not null)
                                                       TableScan [TS_6] 
(rows=40000000 width=90)
                                                         
default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"]
@@ -173,72 +171,50 @@ Stage-0
                                                 SHUFFLE [RS_15]
                                                   PartitionCols:_col1
                                                   Merge Join Operator 
[MERGEJOIN_126] (rows=15987241 width=239)
-                                                    
Conds:RS_157._col0=RS_133._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6"]
-                                                  <-Map 11 [SIMPLE_EDGE] 
vectorized
-                                                    SHUFFLE [RS_133]
-                                                      PartitionCols:_col0
-                                                      Select Operator 
[SEL_132] (rows=8116 width=98)
-                                                        Output:["_col0"]
-                                                        Filter Operator 
[FIL_131] (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' and d_date_sk is not null)
-                                                          TableScan [TS_3] 
(rows=73049 width=98)
-                                                            
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"]
+                                                    
Conds:RS_141._col0=RS_144._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6"]
                                                   <-Map 1 [SIMPLE_EDGE] 
vectorized
-                                                    SHUFFLE [RS_157]
+                                                    SHUFFLE [RS_141]
                                                       PartitionCols:_col0
-                                                      Select Operator 
[SEL_156] (rows=143895019 width=243)
+                                                      Select Operator 
[SEL_140] (rows=143895019 width=243)
                                                         
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"]
-                                                        Filter Operator 
[FIL_155] (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_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(ws_ship_date_sk, 
DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) and (ws_web_site_sk 
BETWEEN DynamicValue(RS_19_web_site_web_site_sk_min) AND 
DynamicValue(RS_19_web_site_web_site_sk_max) and 
in_bloom_filter(ws_web_site_sk, 
DynamicValue(RS_19_web_site_web_site_sk_bloom_filter))) and ws_order_number is 
not null and ws_ship_addr_sk is not null and ws_ship_date_sk is not null and 
ws_web_site_sk is not null)
+                                                        Filter Operator 
[FIL_139] (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_order_number is not null 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 12 
[BROADCAST_EDGE] vectorized
+                                                          <-Reducer 13 
[BROADCAST_EDGE] vectorized
                                                             BROADCAST [RS_138]
                                                               Group By 
Operator [GBY_137] (rows=1 width=12)
                                                                 
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                              <-Map 11 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                              <-Map 12 
[CUSTOM_SIMPLE_EDGE] vectorized
                                                                 SHUFFLE 
[RS_136]
                                                                   Group By 
Operator [GBY_135] (rows=1 width=12)
                                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                    Select 
Operator [SEL_134] (rows=8116 width=4)
+                                                                    Select 
Operator [SEL_134] (rows=784314 width=4)
                                                                       
Output:["_col0"]
                                                                        Please 
refer to the previous Select Operator [SEL_132]
-                                                          <-Reducer 14 
[BROADCAST_EDGE] vectorized
-                                                            BROADCAST [RS_146]
-                                                              Group By 
Operator [GBY_145] (rows=1 width=12)
-                                                                
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                              <-Map 13 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                SHUFFLE 
[RS_144]
-                                                                  Group By 
Operator [GBY_143] (rows=1 width=12)
-                                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                    Select 
Operator [SEL_142] (rows=784314 width=4)
-                                                                      
Output:["_col0"]
-                                                                       Please 
refer to the previous Select Operator [SEL_140]
-                                                          <-Reducer 16 
[BROADCAST_EDGE] vectorized
-                                                            BROADCAST [RS_154]
-                                                              Group By 
Operator [GBY_153] (rows=1 width=12)
-                                                                
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                              <-Map 15 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                SHUFFLE 
[RS_152]
-                                                                  Group By 
Operator [GBY_151] (rows=1 width=12)
-                                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                    Select 
Operator [SEL_150] (rows=12 width=4)
-                                                                      
Output:["_col0"]
-                                                                       Please 
refer to the previous Select Operator [SEL_148]
-                                      <-Map 17 [SIMPLE_EDGE] vectorized
-                                        SHUFFLE [RS_163]
+                                                  <-Map 11 [SIMPLE_EDGE] 
vectorized
+                                                    SHUFFLE [RS_144]
+                                                      PartitionCols:_col0
+                                                      Select Operator 
[SEL_143] (rows=8116 width=98)
+                                                        Output:["_col0"]
+                                                        Filter Operator 
[FIL_142] (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' and d_date_sk is not null)
+                                                          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_153]
                                           PartitionCols:_col0
-                                          Group By Operator [GBY_162] 
(rows=143966743 width=7)
+                                          Group By Operator [GBY_152] 
(rows=143966743 width=7)
                                             
Output:["_col0","_col1"],keys:_col0, _col1
-                                            Select Operator [SEL_161] 
(rows=143966743 width=7)
+                                            Select Operator [SEL_151] 
(rows=143966743 width=7)
                                               Output:["_col0","_col1"]
-                                              Filter Operator [FIL_160] 
(rows=143966743 width=7)
+                                              Filter Operator [FIL_150] 
(rows=143966743 width=7)
                                                 predicate:((ws_order_number 
BETWEEN DynamicValue(RS_34_ws1_ws_order_number_min) AND 
DynamicValue(RS_34_ws1_ws_order_number_max) and 
in_bloom_filter(ws_order_number, 
DynamicValue(RS_34_ws1_ws_order_number_bloom_filter))) and ws_order_number is 
not null 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_159]
-                                                    Group By Operator 
[GBY_158] (rows=1 width=12)
+                                                  BROADCAST [RS_149]
+                                                    Group By Operator 
[GBY_148] (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_116]

Reply via email to