http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/constraints/query95.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query95.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query95.q.out
index 4dc9cd8..0b0c9c5 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query95.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query95.q.out
@@ -75,20 +75,18 @@ 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 20 <- Reducer 10 (BROADCAST_EDGE)
+Map 1 <- Reducer 13 (BROADCAST_EDGE)
+Map 15 <- Reducer 10 (BROADCAST_EDGE)
+Map 18 <- 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 18 <- Map 17 (SIMPLE_EDGE), Map 20 (SIMPLE_EDGE)
-Reducer 19 <- Map 21 (SIMPLE_EDGE), Reducer 18 (ONE_TO_ONE_EDGE)
+Reducer 13 <- Map 12 (CUSTOM_SIMPLE_EDGE)
+Reducer 16 <- Map 15 (SIMPLE_EDGE), Map 18 (SIMPLE_EDGE)
+Reducer 17 <- Map 19 (SIMPLE_EDGE), Reducer 16 (ONE_TO_ONE_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 <- Reducer 18 (ONE_TO_ONE_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 <- Reducer 16 (ONE_TO_ONE_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)
@@ -98,22 +96,22 @@ Stage-0
     limit:-1
     Stage-1
       Reducer 9 vectorized
-      File Output Operator [FS_273]
-        Limit [LIM_272] (rows=1 width=240)
+      File Output Operator [FS_263]
+        Limit [LIM_262] (rows=1 width=240)
           Number of rows:100
-          Select Operator [SEL_271] (rows=1 width=240)
+          Select Operator [SEL_261] (rows=1 width=240)
             Output:["_col0","_col1","_col2"]
           <-Reducer 8 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_270]
-              Select Operator [SEL_269] (rows=1 width=240)
+            SHUFFLE [RS_260]
+              Select Operator [SEL_259] (rows=1 width=240)
                 Output:["_col1","_col2","_col3"]
-                Group By Operator [GBY_268] (rows=1 width=232)
+                Group By Operator [GBY_258] (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_267]
-                    Group By Operator [GBY_266] (rows=1 width=232)
+                  PARTITION_ONLY_SHUFFLE [RS_257]
+                    Group By Operator [GBY_256] (rows=1 width=232)
                       
Output:["_col0","_col1","_col2"],aggregations:["count(_col0)","sum(_col1)","sum(_col2)"]
-                      Group By Operator [GBY_265] (rows=38111880083 width=228)
+                      Group By Operator [GBY_255] (rows=38111880083 width=228)
                         
Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0
                       <-Reducer 6 [SIMPLE_EDGE]
                         SHUFFLE [RS_101]
@@ -122,14 +120,14 @@ Stage-0
                             
Output:["_col0","_col2","_col3"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col3
                             Merge Join Operator [MERGEJOIN_227] 
(rows=83469759007 width=227)
                               
Conds:RS_47._col3=RS_48._col0(Inner),Output:["_col3","_col4","_col5"]
-                            <-Reducer 19 [ONE_TO_ONE_EDGE]
+                            <-Reducer 17 [ONE_TO_ONE_EDGE]
                               FORWARD [RS_48]
                                 PartitionCols:_col0
                                 Select Operator [SEL_34] (rows=1384229738 
width=4)
                                   Output:["_col0"]
                                   Merge Join Operator [MERGEJOIN_221] 
(rows=1384229738 width=4)
-                                    
Conds:RS_31._col0=RS_264.wr_order_number(Inner),Output:["_col14"]
-                                  <-Reducer 18 [ONE_TO_ONE_EDGE]
+                                    
Conds:RS_31._col0=RS_254.wr_order_number(Inner),Output:["_col14"]
+                                  <-Reducer 16 [ONE_TO_ONE_EDGE]
                                     FORWARD [RS_31]
                                       PartitionCols:_col0
                                       Select Operator [SEL_29] 
(rows=1411940834 width=4)
@@ -137,19 +135,19 @@ Stage-0
                                         Filter Operator [FIL_28] 
(rows=1411940834 width=11)
                                           predicate:(_col0 <> _col2)
                                           Merge Join Operator [MERGEJOIN_220] 
(rows=1411940834 width=11)
-                                            
Conds:RS_260._col1=RS_263._col1(Inner),Output:["_col0","_col1","_col2"]
-                                          <-Map 17 [SIMPLE_EDGE] vectorized
-                                            SHUFFLE [RS_260]
+                                            
Conds:RS_250._col1=RS_253._col1(Inner),Output:["_col0","_col1","_col2"]
+                                          <-Map 15 [SIMPLE_EDGE] vectorized
+                                            SHUFFLE [RS_250]
                                               PartitionCols:_col1
-                                              Select Operator [SEL_259] 
(rows=144002668 width=7)
+                                              Select Operator [SEL_249] 
(rows=144002668 width=7)
                                                 Output:["_col0","_col1"]
-                                                Filter Operator [FIL_258] 
(rows=144002668 width=7)
+                                                Filter Operator [FIL_248] 
(rows=144002668 width=7)
                                                   
predicate:(in_bloom_filter(ws_order_number, 
DynamicValue(RS_44_ws1_ws_order_number_bloom_filter)) and ws_order_number 
BETWEEN DynamicValue(RS_44_ws1_ws_order_number_min) AND 
DynamicValue(RS_44_ws1_ws_order_number_max))
                                                   TableScan [TS_21] 
(rows=144002668 width=7)
                                                     
default@web_sales,ws1,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_warehouse_sk","ws_order_number"]
                                                   <-Reducer 10 
[BROADCAST_EDGE] vectorized
-                                                    BROADCAST [RS_256]
-                                                      Group By Operator 
[GBY_255] (rows=1 width=12)
+                                                    BROADCAST [RS_246]
+                                                      Group By Operator 
[GBY_245] (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_179]
@@ -158,13 +156,13 @@ Stage-0
                                                             Select Operator 
[SEL_177] (rows=5022875 width=8)
                                                               Output:["_col0"]
                                                               Merge Join 
Operator [MERGEJOIN_224] (rows=5022875 width=227)
-                                                                
Conds:RS_41._col2=RS_246._col0(Inner),Output:["_col3","_col4","_col5"]
-                                                              <-Map 15 
[SIMPLE_EDGE] vectorized
-                                                                SHUFFLE 
[RS_246]
+                                                                
Conds:RS_41._col2=RS_244._col0(Inner),Output:["_col3","_col4","_col5"]
+                                                              <-Map 14 
[SIMPLE_EDGE] vectorized
+                                                                SHUFFLE 
[RS_244]
                                                                   
PartitionCols:_col0
-                                                                  Select 
Operator [SEL_245] (rows=12 width=4)
+                                                                  Select 
Operator [SEL_243] (rows=12 width=4)
                                                                     
Output:["_col0"]
-                                                                    Filter 
Operator [FIL_244] (rows=12 width=92)
+                                                                    Filter 
Operator [FIL_242] (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"]
@@ -172,13 +170,13 @@ Stage-0
                                                                 SHUFFLE [RS_41]
                                                                   
PartitionCols:_col2
                                                                   Merge Join 
Operator [MERGEJOIN_223] (rows=15673790 width=231)
-                                                                    
Conds:RS_38._col1=RS_238._col0(Inner),Output:["_col2","_col3","_col4","_col5"]
-                                                                  <-Map 13 
[SIMPLE_EDGE] vectorized
-                                                                    SHUFFLE 
[RS_238]
+                                                                    
Conds:RS_38._col1=RS_230._col0(Inner),Output:["_col2","_col3","_col4","_col5"]
+                                                                  <-Map 12 
[SIMPLE_EDGE] vectorized
+                                                                    SHUFFLE 
[RS_230]
                                                                       
PartitionCols:_col0
-                                                                      Select 
Operator [SEL_237] (rows=784314 width=4)
+                                                                      Select 
Operator [SEL_229] (rows=784314 width=4)
                                                                         
Output:["_col0"]
-                                                                        Filter 
Operator [FIL_236] (rows=784314 width=90)
+                                                                        Filter 
Operator [FIL_228] (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"]
@@ -186,72 +184,50 @@ Stage-0
                                                                     SHUFFLE 
[RS_38]
                                                                       
PartitionCols:_col1
                                                                       Merge 
Join Operator [MERGEJOIN_222] (rows=15987241 width=235)
-                                                                        
Conds:RS_254._col0=RS_230._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"]
-                                                                      <-Map 11 
[SIMPLE_EDGE] vectorized
-                                                                        
SHUFFLE [RS_230]
-                                                                          
PartitionCols:_col0
-                                                                          
Select Operator [SEL_229] (rows=8116 width=98)
-                                                                            
Output:["_col0"]
-                                                                            
Filter Operator [FIL_228] (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"]
+                                                                        
Conds:RS_238._col0=RS_241._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"]
                                                                       <-Map 1 
[SIMPLE_EDGE] vectorized
-                                                                        
SHUFFLE [RS_254]
+                                                                        
SHUFFLE [RS_238]
                                                                           
PartitionCols:_col0
-                                                                          
Select Operator [SEL_253] (rows=143895019 width=239)
+                                                                          
Select Operator [SEL_237] (rows=143895019 width=239)
                                                                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
-                                                                            
Filter Operator [FIL_252] (rows=143895019 width=239)
-                                                                              
predicate:((ws_ship_addr_sk BETWEEN 
DynamicValue(RS_39_customer_address_ca_address_sk_min) AND 
DynamicValue(RS_39_customer_address_ca_address_sk_max) and 
in_bloom_filter(ws_ship_addr_sk, 
DynamicValue(RS_39_customer_address_ca_address_sk_bloom_filter))) and 
(ws_ship_date_sk BETWEEN DynamicValue(RS_36_date_dim_d_date_sk_min) AND 
DynamicValue(RS_36_date_dim_d_date_sk_max) and in_bloom_filter(ws_ship_date_sk, 
DynamicValue(RS_36_date_dim_d_date_sk_bloom_filter))) and (ws_web_site_sk 
BETWEEN DynamicValue(RS_42_web_site_web_site_sk_min) AND 
DynamicValue(RS_42_web_site_web_site_sk_max) and 
in_bloom_filter(ws_web_site_sk, 
DynamicValue(RS_42_web_site_web_site_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)
+                                                                            
Filter Operator [FIL_236] (rows=143895019 width=239)
+                                                                              
predicate:((ws_ship_addr_sk BETWEEN 
DynamicValue(RS_39_customer_address_ca_address_sk_min) AND 
DynamicValue(RS_39_customer_address_ca_address_sk_max) and 
in_bloom_filter(ws_ship_addr_sk, 
DynamicValue(RS_39_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=239)
                                                                                
 
default@web_sales,ws1,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_ship_date_sk","ws_ship_addr_sk","ws_web_site_sk","ws_order_number","ws_ext_ship_cost","ws_net_profit"]
-                                                                              
<-Reducer 12 [BROADCAST_EDGE] vectorized
+                                                                              
<-Reducer 13 [BROADCAST_EDGE] vectorized
                                                                                
 BROADCAST [RS_235]
                                                                                
   Group By Operator [GBY_234] (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_233]
                                                                                
       Group By Operator [GBY_232] (rows=1 width=12)
                                                                                
         
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
         Select Operator [SEL_231] (rows=8116 width=4)
+                                                                               
         Select Operator [SEL_231] (rows=784314 width=4)
                                                                                
           Output:["_col0"]
                                                                                
            Please refer to the previous Select Operator [SEL_229]
-                                                                              
<-Reducer 14 [BROADCAST_EDGE] vectorized
-                                                                               
 BROADCAST [RS_243]
-                                                                               
   Group By Operator [GBY_242] (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_241]
-                                                                               
       Group By Operator [GBY_240] (rows=1 width=12)
-                                                                               
         
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
         Select Operator [SEL_239] (rows=784314 width=4)
-                                                                               
           Output:["_col0"]
-                                                                               
            Please refer to the previous Select Operator [SEL_237]
-                                                                              
<-Reducer 16 [BROADCAST_EDGE] vectorized
-                                                                               
 BROADCAST [RS_251]
-                                                                               
   Group By Operator [GBY_250] (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_249]
-                                                                               
       Group By Operator [GBY_248] (rows=1 width=12)
-                                                                               
         
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
         Select Operator [SEL_247] (rows=12 width=4)
-                                                                               
           Output:["_col0"]
-                                                                               
            Please refer to the previous Select Operator [SEL_245]
-                                          <-Map 20 [SIMPLE_EDGE] vectorized
-                                            SHUFFLE [RS_263]
+                                                                      <-Map 11 
[SIMPLE_EDGE] vectorized
+                                                                        
SHUFFLE [RS_241]
+                                                                          
PartitionCols:_col0
+                                                                          
Select Operator [SEL_240] (rows=8116 width=98)
+                                                                            
Output:["_col0"]
+                                                                            
Filter Operator [FIL_239] (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 18 [SIMPLE_EDGE] vectorized
+                                            SHUFFLE [RS_253]
                                               PartitionCols:_col1
-                                              Select Operator [SEL_262] 
(rows=144002668 width=7)
+                                              Select Operator [SEL_252] 
(rows=144002668 width=7)
                                                 Output:["_col0","_col1"]
-                                                Filter Operator [FIL_261] 
(rows=144002668 width=7)
+                                                Filter Operator [FIL_251] 
(rows=144002668 width=7)
                                                   
predicate:(in_bloom_filter(ws_order_number, 
DynamicValue(RS_44_ws1_ws_order_number_bloom_filter)) and ws_order_number 
BETWEEN DynamicValue(RS_44_ws1_ws_order_number_min) AND 
DynamicValue(RS_44_ws1_ws_order_number_max))
                                                   TableScan [TS_23] 
(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_257]
-                                                       Please refer to the 
previous Group By Operator [GBY_255]
-                                  <-Map 21 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_264]
+                                                    BROADCAST [RS_247]
+                                                       Please refer to the 
previous Group By Operator [GBY_245]
+                                  <-Map 19 [SIMPLE_EDGE] vectorized
+                                    SHUFFLE [RS_254]
                                       PartitionCols:wr_order_number
                                       TableScan [TS_30] (rows=14398467 width=4)
                                         
default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_order_number"]
@@ -260,7 +236,7 @@ Stage-0
                                 PartitionCols:_col3
                                 Merge Join Operator [MERGEJOIN_226] 
(rows=482885639 width=227)
                                   
Conds:RS_44._col3=RS_45._col0(Inner),Output:["_col3","_col4","_col5"]
-                                <-Reducer 18 [ONE_TO_ONE_EDGE]
+                                <-Reducer 16 [ONE_TO_ONE_EDGE]
                                   FORWARD [RS_45]
                                     PartitionCols:_col0
                                      Please refer to the previous Select 
Operator [SEL_29]

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/constraints/query96.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query96.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query96.q.out
index 8942a90..27c26aa 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query96.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query96.q.out
@@ -41,12 +41,10 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 10 (BROADCAST_EDGE), Reducer 12 (BROADCAST_EDGE), Reducer 8 
(BROADCAST_EDGE)
-Reducer 10 <- Map 9 (CUSTOM_SIMPLE_EDGE)
-Reducer 12 <- Map 11 (CUSTOM_SIMPLE_EDGE)
+Map 1 <- Reducer 8 (BROADCAST_EDGE)
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 7 (SIMPLE_EDGE)
 Reducer 3 <- Map 9 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
-Reducer 4 <- Map 11 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
+Reducer 4 <- Map 10 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
 Reducer 5 <- Reducer 4 (CUSTOM_SIMPLE_EDGE)
 Reducer 6 <- Reducer 5 (SIMPLE_EDGE)
 Reducer 8 <- Map 7 (CUSTOM_SIMPLE_EDGE)
@@ -56,29 +54,29 @@ Stage-0
     limit:-1
     Stage-1
       Reducer 6 vectorized
-      File Output Operator [FS_109]
-        Limit [LIM_108] (rows=1 width=16)
+      File Output Operator [FS_99]
+        Limit [LIM_98] (rows=1 width=16)
           Number of rows:100
-          Select Operator [SEL_107] (rows=1 width=16)
+          Select Operator [SEL_97] (rows=1 width=16)
             Output:["_col0"]
           <-Reducer 5 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_106]
-              Select Operator [SEL_105] (rows=1 width=16)
+            SHUFFLE [RS_96]
+              Select Operator [SEL_95] (rows=1 width=16)
                 Output:["_col1"]
-                Group By Operator [GBY_104] (rows=1 width=8)
+                Group By Operator [GBY_94] (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_76] (rows=1084713 width=8)
-                        Conds:RS_18._col2=RS_95._col0(Inner)
-                      <-Map 11 [SIMPLE_EDGE] vectorized
-                        SHUFFLE [RS_95]
+                        Conds:RS_18._col2=RS_93._col0(Inner)
+                      <-Map 10 [SIMPLE_EDGE] vectorized
+                        SHUFFLE [RS_93]
                           PartitionCols:_col0
-                          Select Operator [SEL_94] (rows=155 width=4)
+                          Select Operator [SEL_92] (rows=155 width=4)
                             Output:["_col0"]
-                            Filter Operator [FIL_93] (rows=155 width=92)
+                            Filter Operator [FIL_91] (rows=155 width=92)
                               predicate:(s_store_name = 'ese')
                               TableScan [TS_9] (rows=1704 width=92)
                                 
default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name"]
@@ -86,13 +84,13 @@ Stage-0
                         SHUFFLE [RS_18]
                           PartitionCols:_col2
                           Merge Join Operator [MERGEJOIN_75] (rows=1477476 
width=0)
-                            
Conds:RS_15._col1=RS_87._col0(Inner),Output:["_col2"]
+                            
Conds:RS_15._col1=RS_90._col0(Inner),Output:["_col2"]
                           <-Map 9 [SIMPLE_EDGE] vectorized
-                            SHUFFLE [RS_87]
+                            SHUFFLE [RS_90]
                               PartitionCols:_col0
-                              Select Operator [SEL_86] (rows=655 width=4)
+                              Select Operator [SEL_89] (rows=655 width=4)
                                 Output:["_col0"]
-                                Filter Operator [FIL_85] (rows=655 width=8)
+                                Filter Operator [FIL_88] (rows=655 width=8)
                                   predicate:(hd_dep_count = 5)
                                   TableScan [TS_6] (rows=7200 width=8)
                                     
default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count"]
@@ -100,7 +98,7 @@ Stage-0
                             SHUFFLE [RS_15]
                               PartitionCols:_col1
                               Merge Join Operator [MERGEJOIN_74] 
(rows=16240953 width=0)
-                                
Conds:RS_103._col0=RS_79._col0(Inner),Output:["_col1","_col2"]
+                                
Conds:RS_87._col0=RS_79._col0(Inner),Output:["_col1","_col2"]
                               <-Map 7 [SIMPLE_EDGE] vectorized
                                 PARTITION_ONLY_SHUFFLE [RS_79]
                                   PartitionCols:_col0
@@ -111,36 +109,14 @@ Stage-0
                                       TableScan [TS_3] (rows=86400 width=12)
                                         
default@time_dim,time_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["t_time_sk","t_hour","t_minute"]
                               <-Map 1 [SIMPLE_EDGE] vectorized
-                                SHUFFLE [RS_103]
+                                SHUFFLE [RS_87]
                                   PartitionCols:_col0
-                                  Select Operator [SEL_102] (rows=501695814 
width=11)
+                                  Select Operator [SEL_86] (rows=501695814 
width=11)
                                     Output:["_col0","_col1","_col2"]
-                                    Filter Operator [FIL_101] (rows=501695814 
width=11)
-                                      predicate:((ss_hdemo_sk BETWEEN 
DynamicValue(RS_16_household_demographics_hd_demo_sk_min) AND 
DynamicValue(RS_16_household_demographics_hd_demo_sk_max) and 
in_bloom_filter(ss_hdemo_sk, 
DynamicValue(RS_16_household_demographics_hd_demo_sk_bloom_filter))) and 
(ss_sold_time_sk BETWEEN DynamicValue(RS_13_time_dim_t_time_sk_min) AND 
DynamicValue(RS_13_time_dim_t_time_sk_max) and in_bloom_filter(ss_sold_time_sk, 
DynamicValue(RS_13_time_dim_t_time_sk_bloom_filter))) and (ss_store_sk BETWEEN 
DynamicValue(RS_19_store_s_store_sk_min) AND 
DynamicValue(RS_19_store_s_store_sk_max) and in_bloom_filter(ss_store_sk, 
DynamicValue(RS_19_store_s_store_sk_bloom_filter))) and ss_hdemo_sk is not null 
and ss_sold_time_sk is not null and ss_store_sk is not null)
+                                    Filter Operator [FIL_85] (rows=501695814 
width=11)
+                                      predicate:((ss_sold_time_sk BETWEEN 
DynamicValue(RS_13_time_dim_t_time_sk_min) AND 
DynamicValue(RS_13_time_dim_t_time_sk_max) and in_bloom_filter(ss_sold_time_sk, 
DynamicValue(RS_13_time_dim_t_time_sk_bloom_filter))) and ss_hdemo_sk is not 
null and ss_sold_time_sk is not null and ss_store_sk is not null)
                                       TableScan [TS_0] (rows=575995635 
width=11)
                                         
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_time_sk","ss_hdemo_sk","ss_store_sk"]
-                                      <-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 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=655 width=4)
-                                                  Output:["_col0"]
-                                                   Please refer to the 
previous Select Operator [SEL_86]
-                                      <-Reducer 12 [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 11 [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=155 width=4)
-                                                  Output:["_col0"]
-                                                   Please refer to the 
previous Select Operator [SEL_94]
                                       <-Reducer 8 [BROADCAST_EDGE] vectorized
                                         BROADCAST [RS_84]
                                           Group By Operator [GBY_83] (rows=1 
width=12)

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/constraints/query98.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query98.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query98.q.out
index 3ffc379..d1e7d20 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query98.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query98.q.out
@@ -71,8 +71,7 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 10 (BROADCAST_EDGE), Reducer 8 (BROADCAST_EDGE)
-Reducer 10 <- Map 9 (CUSTOM_SIMPLE_EDGE)
+Map 1 <- Reducer 8 (BROADCAST_EDGE)
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 7 (SIMPLE_EDGE)
 Reducer 3 <- Map 9 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
 Reducer 4 <- Reducer 3 (SIMPLE_EDGE)
@@ -85,21 +84,21 @@ Stage-0
     limit:-1
     Stage-1
       Reducer 6 vectorized
-      File Output Operator [FS_84]
-        Select Operator [SEL_83] (rows=138600 width=701)
+      File Output Operator [FS_79]
+        Select Operator [SEL_78] (rows=138600 width=701)
           Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
         <-Reducer 5 [SIMPLE_EDGE] vectorized
-          SHUFFLE [RS_82]
-            Select Operator [SEL_81] (rows=138600 width=801)
+          SHUFFLE [RS_77]
+            Select Operator [SEL_76] (rows=138600 width=801)
               Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"]
-              PTF Operator [PTF_80] (rows=138600 width=689)
+              PTF Operator [PTF_75] (rows=138600 width=689)
                 Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS 
FIRST","partition by:":"_col1"}]
-                Select Operator [SEL_79] (rows=138600 width=689)
+                Select Operator [SEL_74] (rows=138600 width=689)
                   Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
                 <-Reducer 4 [SIMPLE_EDGE] vectorized
-                  SHUFFLE [RS_78]
+                  SHUFFLE [RS_73]
                     PartitionCols:_col1
-                    Group By Operator [GBY_77] (rows=138600 width=689)
+                    Group By Operator [GBY_72] (rows=138600 width=689)
                       
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2, KEY._col3, KEY._col4
                     <-Reducer 3 [SIMPLE_EDGE]
                       SHUFFLE [RS_17]
@@ -107,13 +106,13 @@ Stage-0
                         Group By Operator [GBY_16] (rows=138600 width=689)
                           
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9,
 _col8, _col5, _col6, _col7
                           Merge Join Operator [MERGEJOIN_57] (rows=18334631 
width=577)
-                            
Conds:RS_12._col1=RS_68._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"]
+                            
Conds:RS_12._col1=RS_71._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"]
                           <-Map 9 [SIMPLE_EDGE] vectorized
-                            SHUFFLE [RS_68]
+                            SHUFFLE [RS_71]
                               PartitionCols:_col0
-                              Select Operator [SEL_67] (rows=138600 width=581)
+                              Select Operator [SEL_70] (rows=138600 width=581)
                                 
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
-                                Filter Operator [FIL_66] (rows=138600 
width=581)
+                                Filter Operator [FIL_69] (rows=138600 
width=581)
                                   predicate:(i_category) IN ('Jewelry', 
'Sports', 'Books')
                                   TableScan [TS_6] (rows=462000 width=581)
                                     
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"]
@@ -121,7 +120,7 @@ Stage-0
                             SHUFFLE [RS_12]
                               PartitionCols:_col1
                               Merge Join Operator [MERGEJOIN_56] 
(rows=61115434 width=70)
-                                
Conds:RS_76._col0=RS_60._col0(Inner),Output:["_col1","_col2"]
+                                
Conds:RS_68._col0=RS_60._col0(Inner),Output:["_col1","_col2"]
                               <-Map 7 [SIMPLE_EDGE] vectorized
                                 PARTITION_ONLY_SHUFFLE [RS_60]
                                   PartitionCols:_col0
@@ -132,25 +131,14 @@ Stage-0
                                       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_76]
+                                SHUFFLE [RS_68]
                                   PartitionCols:_col0
-                                  Select Operator [SEL_75] (rows=550076554 
width=114)
+                                  Select Operator [SEL_67] (rows=550076554 
width=114)
                                     Output:["_col0","_col1","_col2"]
-                                    Filter Operator [FIL_74] (rows=550076554 
width=114)
-                                      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_10_date_dim_d_date_sk_min) AND 
DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) and ss_sold_date_sk is 
not null)
+                                    Filter Operator [FIL_66] (rows=550076554 
width=114)
+                                      predicate:((ss_sold_date_sk BETWEEN 
DynamicValue(RS_10_date_dim_d_date_sk_min) AND 
DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) and ss_sold_date_sk is 
not null)
                                       TableScan [TS_0] (rows=575995635 
width=114)
                                         
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"]
-                                      <-Reducer 10 [BROADCAST_EDGE] vectorized
-                                        BROADCAST [RS_73]
-                                          Group By Operator [GBY_72] (rows=1 
width=12)
-                                            
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                          <-Map 9 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                            SHUFFLE [RS_71]
-                                              Group By Operator [GBY_70] 
(rows=1 width=12)
-                                                
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                Select Operator [SEL_69] 
(rows=138600 width=4)
-                                                  Output:["_col0"]
-                                                   Please refer to the 
previous Select Operator [SEL_67]
                                       <-Reducer 8 [BROADCAST_EDGE] vectorized
                                         BROADCAST [RS_65]
                                           Group By Operator [GBY_64] (rows=1 
width=12)

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/constraints/query99.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query99.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query99.q.out
index e76bb8e..5f84036 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query99.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query99.q.out
@@ -81,31 +81,30 @@ 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 5 <- Map 13 (SIMPLE_EDGE), Reducer 4 (SIMPLE_EDGE)
+Reducer 3 <- Map 9 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
+Reducer 4 <- Map 11 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
+Reducer 5 <- Map 12 (SIMPLE_EDGE), 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_125]
-        Limit [LIM_124] (rows=100 width=590)
+      File Output Operator [FS_120]
+        Limit [LIM_119] (rows=100 width=590)
           Number of rows:100
-          Select Operator [SEL_123] (rows=3869553 width=590)
+          Select Operator [SEL_118] (rows=3869553 width=590)
             
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"]
           <-Reducer 6 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_122]
-              Select Operator [SEL_121] (rows=3869553 width=590)
+            SHUFFLE [RS_117]
+              Select Operator [SEL_116] (rows=3869553 width=590)
                 
Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"]
-                Group By Operator [GBY_120] (rows=3869553 width=406)
+                Group By Operator [GBY_115] (rows=3869553 width=406)
                   
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)"],keys:KEY._col0,
 KEY._col1, KEY._col2
                 <-Reducer 5 [SIMPLE_EDGE]
                   SHUFFLE [RS_26]
@@ -115,11 +114,11 @@ Stage-0
                       Top N Key Operator [TNK_53] (rows=15478212 width=386)
                         keys:_col13, _col11, _col15,sort order:+++,top n:100
                         Merge Join Operator [MERGEJOIN_97] (rows=15478212 
width=386)
-                          
Conds:RS_21._col1=RS_119._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col8","_col11","_col13","_col15"]
-                        <-Map 13 [SIMPLE_EDGE] vectorized
-                          SHUFFLE [RS_119]
+                          
Conds:RS_21._col1=RS_114._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col8","_col11","_col13","_col15"]
+                        <-Map 12 [SIMPLE_EDGE] vectorized
+                          SHUFFLE [RS_114]
                             PartitionCols:_col0
-                            Select Operator [SEL_118] (rows=60 width=102)
+                            Select Operator [SEL_113] (rows=60 width=102)
                               Output:["_col0","_col1"]
                               TableScan [TS_10] (rows=60 width=102)
                                 
default@call_center,call_center,Tbl:COMPLETE,Col:COMPLETE,Output:["cc_call_center_sk","cc_name"]
@@ -127,11 +126,11 @@ Stage-0
                           SHUFFLE [RS_21]
                             PartitionCols:_col1
                             Merge Join Operator [MERGEJOIN_96] (rows=15478212 
width=291)
-                              
Conds:RS_18._col3=RS_117._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col8","_col11","_col13"]
-                            <-Map 12 [SIMPLE_EDGE] vectorized
-                              SHUFFLE [RS_117]
+                              
Conds:RS_18._col3=RS_112._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col8","_col11","_col13"]
+                            <-Map 11 [SIMPLE_EDGE] vectorized
+                              SHUFFLE [RS_112]
                                 PartitionCols:_col0
-                                Select Operator [SEL_116] (rows=27 width=188)
+                                Select Operator [SEL_111] (rows=27 width=188)
                                   Output:["_col0","_col1"]
                                   TableScan [TS_8] (rows=27 width=104)
                                     
default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"]
@@ -139,11 +138,11 @@ Stage-0
                               SHUFFLE [RS_18]
                                 PartitionCols:_col3
                                 Merge Join Operator [MERGEJOIN_95] 
(rows=15478212 width=111)
-                                  
Conds:RS_15._col2=RS_107._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col11"]
-                                <-Map 10 [SIMPLE_EDGE] vectorized
-                                  SHUFFLE [RS_107]
+                                  
Conds:RS_15._col2=RS_99._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col11"]
+                                <-Map 9 [SIMPLE_EDGE] vectorized
+                                  SHUFFLE [RS_99]
                                     PartitionCols:_col0
-                                    Select Operator [SEL_106] (rows=1 width=88)
+                                    Select Operator [SEL_98] (rows=1 width=88)
                                       Output:["_col0","_col1"]
                                       TableScan [TS_6] (rows=1 width=88)
                                         
default@ship_mode,ship_mode,Tbl:COMPLETE,Col:COMPLETE,Output:["sm_ship_mode_sk","sm_type"]
@@ -151,45 +150,34 @@ Stage-0
                                   SHUFFLE [RS_15]
                                     PartitionCols:_col2
                                     Merge Join Operator [MERGEJOIN_94] 
(rows=46434637 width=31)
-                                      
Conds:RS_115._col0=RS_100._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"]
-                                    <-Map 8 [SIMPLE_EDGE] vectorized
-                                      PARTITION_ONLY_SHUFFLE [RS_100]
-                                        PartitionCols:_col0
-                                        Select Operator [SEL_99] (rows=317 
width=4)
-                                          Output:["_col0"]
-                                          Filter Operator [FIL_98] (rows=317 
width=8)
-                                            predicate:d_month_seq BETWEEN 1212 
AND 1223
-                                            TableScan [TS_3] (rows=73049 
width=8)
-                                              
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"]
+                                      
Conds:RS_107._col0=RS_110._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"]
                                     <-Map 1 [SIMPLE_EDGE] vectorized
-                                      SHUFFLE [RS_115]
+                                      SHUFFLE [RS_107]
                                         PartitionCols:_col0
-                                        Select Operator [SEL_114] 
(rows=282273729 width=35)
+                                        Select Operator [SEL_106] 
(rows=282273729 width=35)
                                           
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"]
-                                          Filter Operator [FIL_113] 
(rows=282273729 width=19)
-                                            predicate:((cs_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(cs_ship_date_sk, 
DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) and (cs_ship_mode_sk 
BETWEEN DynamicValue(RS_16_ship_mode_sm_ship_mode_sk_min) AND 
DynamicValue(RS_16_ship_mode_sm_ship_mode_sk_max) and 
in_bloom_filter(cs_ship_mode_sk, 
DynamicValue(RS_16_ship_mode_sm_ship_mode_sk_bloom_filter))) and 
cs_call_center_sk is not null and cs_ship_date_sk is not null and 
cs_ship_mode_sk is not null and cs_warehouse_sk is not null)
+                                          Filter Operator [FIL_105] 
(rows=282273729 width=19)
+                                            predicate:((cs_ship_mode_sk 
BETWEEN DynamicValue(RS_16_ship_mode_sm_ship_mode_sk_min) AND 
DynamicValue(RS_16_ship_mode_sm_ship_mode_sk_max) and 
in_bloom_filter(cs_ship_mode_sk, 
DynamicValue(RS_16_ship_mode_sm_ship_mode_sk_bloom_filter))) and 
cs_call_center_sk is not null and cs_ship_date_sk is not null and 
cs_ship_mode_sk is not null and cs_warehouse_sk is not null)
                                             TableScan [TS_0] (rows=287989836 
width=19)
                                               
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_date_sk","cs_call_center_sk","cs_ship_mode_sk","cs_warehouse_sk"]
-                                            <-Reducer 11 [BROADCAST_EDGE] 
vectorized
-                                              BROADCAST [RS_112]
-                                                Group By Operator [GBY_111] 
(rows=1 width=12)
+                                            <-Reducer 10 [BROADCAST_EDGE] 
vectorized
+                                              BROADCAST [RS_104]
+                                                Group By Operator [GBY_103] 
(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_110]
-                                                    Group By Operator 
[GBY_109] (rows=1 width=12)
+                                                <-Map 9 [CUSTOM_SIMPLE_EDGE] 
vectorized
+                                                  SHUFFLE [RS_102]
+                                                    Group By Operator 
[GBY_101] (rows=1 width=12)
                                                       
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                      Select Operator 
[SEL_108] (rows=1 width=4)
+                                                      Select Operator 
[SEL_100] (rows=1 width=4)
                                                         Output:["_col0"]
-                                                         Please refer to the 
previous Select Operator [SEL_106]
-                                            <-Reducer 9 [BROADCAST_EDGE] 
vectorized
-                                              BROADCAST [RS_105]
-                                                Group By Operator [GBY_104] 
(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_103]
-                                                    Group By Operator 
[GBY_102] (rows=1 width=12)
-                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                      Select Operator 
[SEL_101] (rows=317 width=4)
-                                                        Output:["_col0"]
-                                                         Please refer to the 
previous Select Operator [SEL_99]
+                                                         Please refer to the 
previous Select Operator [SEL_98]
+                                    <-Map 8 [SIMPLE_EDGE] vectorized
+                                      SHUFFLE [RS_110]
+                                        PartitionCols:_col0
+                                        Select Operator [SEL_109] (rows=317 
width=4)
+                                          Output:["_col0"]
+                                          Filter Operator [FIL_108] (rows=317 
width=8)
+                                            predicate:d_month_seq BETWEEN 1212 
AND 1223
+                                            TableScan [TS_3] (rows=73049 
width=8)
+                                              
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"]
 

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/query10.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/perf/tez/query10.q.out 
b/ql/src/test/results/clientpositive/perf/tez/query10.q.out
index 4fc8123..210144d 100644
--- a/ql/src/test/results/clientpositive/perf/tez/query10.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/query10.q.out
@@ -133,24 +133,21 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 14 <- Reducer 11 (BROADCAST_EDGE), Reducer 17 (BROADCAST_EDGE)
-Map 24 <- Reducer 10 (BROADCAST_EDGE), Reducer 20 (BROADCAST_EDGE)
-Map 25 <- Reducer 23 (BROADCAST_EDGE), Reducer 9 (BROADCAST_EDGE)
+Map 13 <- Reducer 16 (BROADCAST_EDGE)
+Map 21 <- Reducer 10 (BROADCAST_EDGE)
+Map 22 <- Reducer 9 (BROADCAST_EDGE)
 Reducer 10 <- Reducer 4 (CUSTOM_SIMPLE_EDGE)
-Reducer 11 <- Reducer 3 (CUSTOM_SIMPLE_EDGE)
-Reducer 15 <- Map 14 (SIMPLE_EDGE), Map 16 (SIMPLE_EDGE)
-Reducer 17 <- Map 16 (CUSTOM_SIMPLE_EDGE)
-Reducer 18 <- Map 16 (SIMPLE_EDGE), Map 24 (SIMPLE_EDGE)
-Reducer 19 <- Reducer 18 (SIMPLE_EDGE)
-Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 12 (SIMPLE_EDGE)
-Reducer 20 <- Map 16 (CUSTOM_SIMPLE_EDGE)
-Reducer 21 <- Map 16 (SIMPLE_EDGE), Map 25 (SIMPLE_EDGE)
-Reducer 22 <- Reducer 21 (SIMPLE_EDGE)
-Reducer 23 <- Map 16 (CUSTOM_SIMPLE_EDGE)
-Reducer 3 <- Map 13 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
-Reducer 4 <- Reducer 15 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
-Reducer 5 <- Reducer 19 (ONE_TO_ONE_EDGE), Reducer 4 (ONE_TO_ONE_EDGE)
-Reducer 6 <- Reducer 22 (ONE_TO_ONE_EDGE), Reducer 5 (ONE_TO_ONE_EDGE)
+Reducer 14 <- Map 13 (SIMPLE_EDGE), Map 15 (SIMPLE_EDGE)
+Reducer 16 <- Map 15 (CUSTOM_SIMPLE_EDGE)
+Reducer 17 <- Map 15 (SIMPLE_EDGE), Map 21 (SIMPLE_EDGE)
+Reducer 18 <- Reducer 17 (SIMPLE_EDGE)
+Reducer 19 <- Map 15 (SIMPLE_EDGE), Map 22 (SIMPLE_EDGE)
+Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 11 (SIMPLE_EDGE)
+Reducer 20 <- Reducer 19 (SIMPLE_EDGE)
+Reducer 3 <- Map 12 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
+Reducer 4 <- Reducer 14 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
+Reducer 5 <- Reducer 18 (ONE_TO_ONE_EDGE), Reducer 4 (ONE_TO_ONE_EDGE)
+Reducer 6 <- Reducer 20 (ONE_TO_ONE_EDGE), Reducer 5 (ONE_TO_ONE_EDGE)
 Reducer 7 <- Reducer 6 (SIMPLE_EDGE)
 Reducer 8 <- Reducer 7 (SIMPLE_EDGE)
 Reducer 9 <- Reducer 5 (CUSTOM_SIMPLE_EDGE)
@@ -160,16 +157,16 @@ Stage-0
     limit:100
     Stage-1
       Reducer 8 vectorized
-      File Output Operator [FS_237]
-        Limit [LIM_236] (rows=1 width=419)
+      File Output Operator [FS_225]
+        Limit [LIM_224] (rows=1 width=419)
           Number of rows:100
-          Select Operator [SEL_235] (rows=1 width=419)
+          Select Operator [SEL_223] (rows=1 width=419)
             
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"]
           <-Reducer 7 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_234]
-              Select Operator [SEL_233] (rows=1 width=419)
+            SHUFFLE [RS_222]
+              Select Operator [SEL_221] (rows=1 width=419)
                 
Output:["_col0","_col1","_col2","_col3","_col4","_col6","_col8","_col10","_col12"]
-                Group By Operator [GBY_232] (rows=1 width=379)
+                Group By Operator [GBY_220] (rows=1 width=379)
                   
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["count(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7
                 <-Reducer 6 [SIMPLE_EDGE]
                   SHUFFLE [RS_67]
@@ -183,23 +180,61 @@ Stage-0
                           Filter Operator [FIL_64] (rows=58 width=379)
                             predicate:(_col15 is not null or _col17 is not 
null)
                             Merge Join Operator [MERGEJOIN_181] (rows=58 
width=379)
-                              Conds:RS_61._col0=RS_231._col0(Left 
Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col15","_col17"]
+                              Conds:RS_61._col0=RS_219._col0(Left 
Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col15","_col17"]
                             <-Reducer 5 [ONE_TO_ONE_EDGE]
                               PARTITION_ONLY_SHUFFLE [RS_61]
                                 PartitionCols:_col0
                                 Merge Join Operator [MERGEJOIN_180] (rows=58 
width=379)
-                                  Conds:RS_58._col0=RS_221._col0(Left 
Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col15"]
+                                  Conds:RS_58._col0=RS_211._col0(Left 
Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col15"]
                                 <-Reducer 4 [ONE_TO_ONE_EDGE]
                                   FORWARD [RS_58]
                                     PartitionCols:_col0
                                     Merge Join Operator [MERGEJOIN_179] 
(rows=22703 width=375)
                                       Conds:RS_55._col0=RS_56._col0(Left 
Semi),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"]
+                                    <-Reducer 14 [SIMPLE_EDGE]
+                                      SHUFFLE [RS_56]
+                                        PartitionCols:_col0
+                                        Group By Operator [GBY_54] 
(rows=155827 width=2)
+                                          Output:["_col0"],keys:_col0
+                                          Select Operator [SEL_18] 
(rows=57825495 width=2)
+                                            Output:["_col0"]
+                                            Merge Join Operator 
[MERGEJOIN_176] (rows=57825495 width=2)
+                                              
Conds:RS_203._col0=RS_193._col0(Inner),Output:["_col1"]
+                                            <-Map 15 [SIMPLE_EDGE] vectorized
+                                              SHUFFLE [RS_193]
+                                                PartitionCols:_col0
+                                                Select Operator [SEL_192] 
(rows=201 width=4)
+                                                  Output:["_col0"]
+                                                  Filter Operator [FIL_191] 
(rows=201 width=12)
+                                                    predicate:((d_year = 2002) 
and d_date_sk is not null and d_moy BETWEEN 4 AND 7)
+                                                    TableScan [TS_12] 
(rows=73049 width=12)
+                                                      
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
+                                            <-Map 13 [SIMPLE_EDGE] vectorized
+                                              SHUFFLE [RS_203]
+                                                PartitionCols:_col0
+                                                Select Operator [SEL_202] 
(rows=525327388 width=7)
+                                                  Output:["_col0","_col1"]
+                                                  Filter Operator [FIL_201] 
(rows=525327388 width=7)
+                                                    
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_customer_sk is not 
null and ss_sold_date_sk is not null)
+                                                    TableScan [TS_9] 
(rows=575995635 width=7)
+                                                      
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk"]
+                                                    <-Reducer 16 
[BROADCAST_EDGE] vectorized
+                                                      BROADCAST [RS_200]
+                                                        Group By Operator 
[GBY_199] (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_198]
+                                                            Group By Operator 
[GBY_197] (rows=1 width=12)
+                                                              
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
+                                                              Select Operator 
[SEL_194] (rows=201 width=4)
+                                                                
Output:["_col0"]
+                                                                 Please refer 
to the previous Select Operator [SEL_192]
                                     <-Reducer 3 [SIMPLE_EDGE]
                                       SHUFFLE [RS_55]
                                         PartitionCols:_col0
                                         Merge Join Operator [MERGEJOIN_175] 
(rows=228127 width=375)
                                           
Conds:RS_50._col1=RS_190._col0(Inner),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"]
-                                        <-Map 13 [SIMPLE_EDGE] vectorized
+                                        <-Map 12 [SIMPLE_EDGE] vectorized
                                           SHUFFLE [RS_190]
                                             PartitionCols:_col0
                                             Select Operator [SEL_189] 
(rows=1861800 width=375)
@@ -222,7 +257,7 @@ Stage-0
                                                     
predicate:(c_current_addr_sk is not null and c_current_cdemo_sk is not null and 
c_customer_sk is not null)
                                                     TableScan [TS_0] 
(rows=80000000 width=11)
                                                       
default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk"]
-                                            <-Map 12 [SIMPLE_EDGE] vectorized
+                                            <-Map 11 [SIMPLE_EDGE] vectorized
                                               SHUFFLE [RS_187]
                                                 PartitionCols:_col0
                                                 Select Operator [SEL_186] 
(rows=116550 width=102)
@@ -231,85 +266,36 @@ Stage-0
                                                     predicate:((ca_county) IN 
('Walker County', 'Richland County', 'Gaines County', 'Douglas County', 'Dona 
Ana County') and ca_address_sk is not null)
                                                     TableScan [TS_3] 
(rows=40000000 width=102)
                                                       
default@customer_address,ca,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county"]
-                                    <-Reducer 15 [SIMPLE_EDGE]
-                                      SHUFFLE [RS_56]
-                                        PartitionCols:_col0
-                                        Group By Operator [GBY_54] 
(rows=155827 width=2)
-                                          Output:["_col0"],keys:_col0
-                                          Select Operator [SEL_18] 
(rows=57825495 width=2)
-                                            Output:["_col0"]
-                                            Merge Join Operator 
[MERGEJOIN_176] (rows=57825495 width=2)
-                                              
Conds:RS_211._col0=RS_193._col0(Inner),Output:["_col1"]
-                                            <-Map 16 [SIMPLE_EDGE] vectorized
-                                              PARTITION_ONLY_SHUFFLE [RS_193]
-                                                PartitionCols:_col0
-                                                Select Operator [SEL_192] 
(rows=201 width=4)
-                                                  Output:["_col0"]
-                                                  Filter Operator [FIL_191] 
(rows=201 width=12)
-                                                    predicate:((d_year = 2002) 
and d_date_sk is not null and d_moy BETWEEN 4 AND 7)
-                                                    TableScan [TS_12] 
(rows=73049 width=12)
-                                                      
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
-                                            <-Map 14 [SIMPLE_EDGE] vectorized
-                                              SHUFFLE [RS_211]
-                                                PartitionCols:_col0
-                                                Select Operator [SEL_210] 
(rows=525327388 width=7)
-                                                  Output:["_col0","_col1"]
-                                                  Filter Operator [FIL_209] 
(rows=525327388 width=7)
-                                                    predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_55_c_c_customer_sk_min) AND 
DynamicValue(RS_55_c_c_customer_sk_max) and in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_55_c_c_customer_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_customer_sk is not 
null and ss_sold_date_sk is not null)
-                                                    TableScan [TS_9] 
(rows=575995635 width=7)
-                                                      
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk"]
-                                                    <-Reducer 11 
[BROADCAST_EDGE] vectorized
-                                                      BROADCAST [RS_208]
-                                                        Group By Operator 
[GBY_207] (rows=1 width=12)
-                                                          
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                        <-Reducer 3 
[CUSTOM_SIMPLE_EDGE]
-                                                          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=228127 width=4)
-                                                                
Output:["_col0"]
-                                                                 Please refer 
to the previous Merge Join Operator [MERGEJOIN_175]
-                                                    <-Reducer 17 
[BROADCAST_EDGE] vectorized
-                                                      BROADCAST [RS_206]
-                                                        Group By Operator 
[GBY_205] (rows=1 width=12)
-                                                          
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                        <-Map 16 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                          
PARTITION_ONLY_SHUFFLE [RS_202]
-                                                            Group By Operator 
[GBY_199] (rows=1 width=12)
-                                                              
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                              Select Operator 
[SEL_194] (rows=201 width=4)
-                                                                
Output:["_col0"]
-                                                                 Please refer 
to the previous Select Operator [SEL_192]
-                                <-Reducer 19 [ONE_TO_ONE_EDGE] vectorized
-                                  FORWARD [RS_221]
+                                <-Reducer 18 [ONE_TO_ONE_EDGE] vectorized
+                                  FORWARD [RS_211]
                                     PartitionCols:_col0
-                                    Select Operator [SEL_220] (rows=155827 
width=7)
+                                    Select Operator [SEL_210] (rows=155827 
width=7)
                                       Output:["_col0","_col1"]
-                                      Group By Operator [GBY_219] (rows=155827 
width=3)
+                                      Group By Operator [GBY_209] (rows=155827 
width=3)
                                         Output:["_col0"],keys:KEY._col0
-                                      <-Reducer 18 [SIMPLE_EDGE]
+                                      <-Reducer 17 [SIMPLE_EDGE]
                                         SHUFFLE [RS_30]
                                           PartitionCols:_col0
                                           Group By Operator [GBY_29] 
(rows=155827 width=3)
                                             Output:["_col0"],keys:_col1
                                             Merge Join Operator 
[MERGEJOIN_177] (rows=15843227 width=3)
-                                              
Conds:RS_218._col0=RS_195._col0(Inner),Output:["_col1"]
-                                            <-Map 16 [SIMPLE_EDGE] vectorized
-                                              PARTITION_ONLY_SHUFFLE [RS_195]
+                                              
Conds:RS_208._col0=RS_195._col0(Inner),Output:["_col1"]
+                                            <-Map 15 [SIMPLE_EDGE] vectorized
+                                              SHUFFLE [RS_195]
                                                 PartitionCols:_col0
                                                  Please refer to the previous 
Select Operator [SEL_192]
-                                            <-Map 24 [SIMPLE_EDGE] vectorized
-                                              SHUFFLE [RS_218]
+                                            <-Map 21 [SIMPLE_EDGE] vectorized
+                                              SHUFFLE [RS_208]
                                                 PartitionCols:_col0
-                                                Select Operator [SEL_217] 
(rows=143930993 width=7)
+                                                Select Operator [SEL_207] 
(rows=143930993 width=7)
                                                   Output:["_col0","_col1"]
-                                                  Filter Operator [FIL_216] 
(rows=143930993 width=7)
-                                                    
predicate:((ws_bill_customer_sk BETWEEN DynamicValue(RS_58_c_c_customer_sk_min) 
AND DynamicValue(RS_58_c_c_customer_sk_max) and 
in_bloom_filter(ws_bill_customer_sk, 
DynamicValue(RS_58_c_c_customer_sk_bloom_filter))) and (ws_sold_date_sk BETWEEN 
DynamicValue(RS_26_date_dim_d_date_sk_min) AND 
DynamicValue(RS_26_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_26_date_dim_d_date_sk_bloom_filter))) and ws_bill_customer_sk 
is not null and ws_sold_date_sk is not null)
+                                                  Filter Operator [FIL_206] 
(rows=143930993 width=7)
+                                                    
predicate:((ws_bill_customer_sk BETWEEN DynamicValue(RS_58_c_c_customer_sk_min) 
AND DynamicValue(RS_58_c_c_customer_sk_max) and 
in_bloom_filter(ws_bill_customer_sk, 
DynamicValue(RS_58_c_c_customer_sk_bloom_filter))) and ws_bill_customer_sk is 
not null and ws_sold_date_sk is not null)
                                                     TableScan [TS_19] 
(rows=144002668 width=7)
                                                       
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk"]
                                                     <-Reducer 10 
[BROADCAST_EDGE] vectorized
-                                                      BROADCAST [RS_215]
-                                                        Group By Operator 
[GBY_214] (rows=1 width=12)
+                                                      BROADCAST [RS_205]
+                                                        Group By Operator 
[GBY_204] (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]
                                                           FORWARD [RS_151]
@@ -318,58 +304,36 @@ Stage-0
                                                               Select Operator 
[SEL_149] (rows=22703 width=4)
                                                                 
Output:["_col0"]
                                                                  Please refer 
to the previous Merge Join Operator [MERGEJOIN_179]
-                                                    <-Reducer 20 
[BROADCAST_EDGE] vectorized
-                                                      BROADCAST [RS_213]
-                                                        Group By Operator 
[GBY_212] (rows=1 width=12)
-                                                          
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                        <-Map 16 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                          
PARTITION_ONLY_SHUFFLE [RS_203]
-                                                            Group By Operator 
[GBY_200] (rows=1 width=12)
-                                                              
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                              Select Operator 
[SEL_196] (rows=201 width=4)
-                                                                
Output:["_col0"]
-                                                                 Please refer 
to the previous Select Operator [SEL_192]
-                            <-Reducer 22 [ONE_TO_ONE_EDGE] vectorized
-                              FORWARD [RS_231]
+                            <-Reducer 20 [ONE_TO_ONE_EDGE] vectorized
+                              FORWARD [RS_219]
                                 PartitionCols:_col0
-                                Select Operator [SEL_230] (rows=154725 width=7)
+                                Select Operator [SEL_218] (rows=154725 width=7)
                                   Output:["_col0","_col1"]
-                                  Group By Operator [GBY_229] (rows=154725 
width=3)
+                                  Group By Operator [GBY_217] (rows=154725 
width=3)
                                     Output:["_col0"],keys:KEY._col0
-                                  <-Reducer 21 [SIMPLE_EDGE]
+                                  <-Reducer 19 [SIMPLE_EDGE]
                                     SHUFFLE [RS_44]
                                       PartitionCols:_col0
                                       Group By Operator [GBY_43] (rows=154725 
width=3)
                                         Output:["_col0"],keys:_col1
                                         Merge Join Operator [MERGEJOIN_178] 
(rows=31162251 width=3)
-                                          
Conds:RS_228._col0=RS_197._col0(Inner),Output:["_col1"]
-                                        <-Map 16 [SIMPLE_EDGE] vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_197]
+                                          
Conds:RS_216._col0=RS_196._col0(Inner),Output:["_col1"]
+                                        <-Map 15 [SIMPLE_EDGE] vectorized
+                                          SHUFFLE [RS_196]
                                             PartitionCols:_col0
                                              Please refer to the previous 
Select Operator [SEL_192]
-                                        <-Map 25 [SIMPLE_EDGE] vectorized
-                                          SHUFFLE [RS_228]
+                                        <-Map 22 [SIMPLE_EDGE] vectorized
+                                          SHUFFLE [RS_216]
                                             PartitionCols:_col0
-                                            Select Operator [SEL_227] 
(rows=285115246 width=7)
+                                            Select Operator [SEL_215] 
(rows=285115246 width=7)
                                               Output:["_col0","_col1"]
-                                              Filter Operator [FIL_226] 
(rows=285115246 width=7)
-                                                
predicate:((cs_ship_customer_sk BETWEEN DynamicValue(RS_61_c_c_customer_sk_min) 
AND DynamicValue(RS_61_c_c_customer_sk_max) and 
in_bloom_filter(cs_ship_customer_sk, 
DynamicValue(RS_61_c_c_customer_sk_bloom_filter))) and (cs_sold_date_sk BETWEEN 
DynamicValue(RS_40_date_dim_d_date_sk_min) AND 
DynamicValue(RS_40_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_40_date_dim_d_date_sk_bloom_filter))) and cs_ship_customer_sk 
is not null and cs_sold_date_sk is not null)
+                                              Filter Operator [FIL_214] 
(rows=285115246 width=7)
+                                                
predicate:((cs_ship_customer_sk BETWEEN DynamicValue(RS_61_c_c_customer_sk_min) 
AND DynamicValue(RS_61_c_c_customer_sk_max) and 
in_bloom_filter(cs_ship_customer_sk, 
DynamicValue(RS_61_c_c_customer_sk_bloom_filter))) and cs_ship_customer_sk is 
not null and cs_sold_date_sk is not null)
                                                 TableScan [TS_33] 
(rows=287989836 width=7)
                                                   
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_customer_sk"]
-                                                <-Reducer 23 [BROADCAST_EDGE] 
vectorized
-                                                  BROADCAST [RS_223]
-                                                    Group By Operator 
[GBY_222] (rows=1 width=12)
-                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                    <-Map 16 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                      PARTITION_ONLY_SHUFFLE 
[RS_204]
-                                                        Group By Operator 
[GBY_201] (rows=1 width=12)
-                                                          
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                          Select Operator 
[SEL_198] (rows=201 width=4)
-                                                            Output:["_col0"]
-                                                             Please refer to 
the previous Select Operator [SEL_192]
                                                 <-Reducer 9 [BROADCAST_EDGE] 
vectorized
-                                                  BROADCAST [RS_225]
-                                                    Group By Operator 
[GBY_224] (rows=1 width=12)
+                                                  BROADCAST [RS_213]
+                                                    Group By Operator 
[GBY_212] (rows=1 width=12)
                                                       
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                                     <-Reducer 5 
[CUSTOM_SIMPLE_EDGE]
                                                       PARTITION_ONLY_SHUFFLE 
[RS_166]

Reply via email to