http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/constraints/query61.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query61.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query61.q.out
index 95a2a74..5625306 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query61.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query61.q.out
@@ -104,40 +104,34 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 12 <- Reducer 18 (BROADCAST_EDGE), Reducer 24 (BROADCAST_EDGE), Reducer 27 
(BROADCAST_EDGE), Reducer 7 (BROADCAST_EDGE)
-Map 30 <- Reducer 10 (BROADCAST_EDGE), Reducer 22 (BROADCAST_EDGE), Reducer 25 
(BROADCAST_EDGE), Reducer 28 (BROADCAST_EDGE)
-Reducer 10 <- Reducer 2 (CUSTOM_SIMPLE_EDGE)
-Reducer 13 <- Map 12 (SIMPLE_EDGE), Map 17 (SIMPLE_EDGE)
+Map 10 <- Reducer 16 (BROADCAST_EDGE)
+Map 24 <- Reducer 20 (BROADCAST_EDGE)
+Reducer 11 <- Map 10 (SIMPLE_EDGE), Map 15 (SIMPLE_EDGE)
+Reducer 12 <- Map 21 (SIMPLE_EDGE), Reducer 11 (SIMPLE_EDGE)
+Reducer 13 <- Map 22 (SIMPLE_EDGE), Reducer 12 (SIMPLE_EDGE)
 Reducer 14 <- Map 23 (SIMPLE_EDGE), Reducer 13 (SIMPLE_EDGE)
-Reducer 15 <- Map 26 (SIMPLE_EDGE), Reducer 14 (SIMPLE_EDGE)
-Reducer 16 <- Map 29 (SIMPLE_EDGE), Reducer 15 (SIMPLE_EDGE)
-Reducer 18 <- Map 17 (CUSTOM_SIMPLE_EDGE)
-Reducer 19 <- Map 17 (SIMPLE_EDGE), Map 30 (SIMPLE_EDGE)
-Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 11 (SIMPLE_EDGE)
-Reducer 20 <- Map 23 (SIMPLE_EDGE), Reducer 19 (SIMPLE_EDGE)
-Reducer 21 <- Map 26 (SIMPLE_EDGE), Reducer 20 (SIMPLE_EDGE)
-Reducer 22 <- Map 17 (CUSTOM_SIMPLE_EDGE)
-Reducer 24 <- Map 23 (CUSTOM_SIMPLE_EDGE)
-Reducer 25 <- Map 23 (CUSTOM_SIMPLE_EDGE)
-Reducer 27 <- Map 26 (CUSTOM_SIMPLE_EDGE)
-Reducer 28 <- Map 26 (CUSTOM_SIMPLE_EDGE)
-Reducer 3 <- Reducer 16 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
+Reducer 16 <- Map 15 (CUSTOM_SIMPLE_EDGE)
+Reducer 17 <- Map 15 (SIMPLE_EDGE), Map 24 (SIMPLE_EDGE)
+Reducer 18 <- Map 21 (SIMPLE_EDGE), Reducer 17 (SIMPLE_EDGE)
+Reducer 19 <- Map 22 (SIMPLE_EDGE), Reducer 18 (SIMPLE_EDGE)
+Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 9 (SIMPLE_EDGE)
+Reducer 20 <- Map 15 (CUSTOM_SIMPLE_EDGE)
+Reducer 3 <- Reducer 14 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
 Reducer 4 <- Reducer 3 (CUSTOM_SIMPLE_EDGE)
-Reducer 5 <- Reducer 4 (CUSTOM_SIMPLE_EDGE), Reducer 9 (CUSTOM_SIMPLE_EDGE)
+Reducer 5 <- Reducer 4 (CUSTOM_SIMPLE_EDGE), Reducer 8 (CUSTOM_SIMPLE_EDGE)
 Reducer 6 <- Reducer 5 (SIMPLE_EDGE)
-Reducer 7 <- Reducer 2 (CUSTOM_SIMPLE_EDGE)
-Reducer 8 <- Reducer 2 (SIMPLE_EDGE), Reducer 21 (SIMPLE_EDGE)
-Reducer 9 <- Reducer 8 (CUSTOM_SIMPLE_EDGE)
+Reducer 7 <- Reducer 19 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
+Reducer 8 <- Reducer 7 (CUSTOM_SIMPLE_EDGE)
 
 Stage-0
   Fetch Operator
     limit:100
     Stage-1
       Reducer 6 vectorized
-      File Output Operator [FS_334]
-        Limit [LIM_333] (rows=1 width=336)
+      File Output Operator [FS_310]
+        Limit [LIM_309] (rows=1 width=336)
           Number of rows:100
-          Select Operator [SEL_332] (rows=1 width=336)
+          Select Operator [SEL_308] (rows=1 width=336)
             Output:["_col0","_col1","_col2"]
           <-Reducer 5 [SIMPLE_EDGE]
             SHUFFLE [RS_88]
@@ -146,8 +140,8 @@ Stage-0
                 Merge Join Operator [MERGEJOIN_266] (rows=1 width=224)
                   Conds:(Inner),Output:["_col0","_col1"]
                 <-Reducer 4 [CUSTOM_SIMPLE_EDGE] vectorized
-                  PARTITION_ONLY_SHUFFLE [RS_318]
-                    Group By Operator [GBY_317] (rows=1 width=112)
+                  PARTITION_ONLY_SHUFFLE [RS_300]
+                    Group By Operator [GBY_299] (rows=1 width=112)
                       Output:["_col0"],aggregations:["sum(VALUE._col0)"]
                     <-Reducer 3 [CUSTOM_SIMPLE_EDGE]
                       PARTITION_ONLY_SHUFFLE [RS_42]
@@ -169,7 +163,7 @@ Stage-0
                                       predicate:c_current_addr_sk is not null
                                       TableScan [TS_0] (rows=80000000 width=8)
                                         
default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"]
-                              <-Map 11 [SIMPLE_EDGE] vectorized
+                              <-Map 9 [SIMPLE_EDGE] vectorized
                                 SHUFFLE [RS_272]
                                   PartitionCols:_col0
                                   Select Operator [SEL_271] (rows=8000000 
width=4)
@@ -178,54 +172,54 @@ Stage-0
                                       predicate:(ca_gmt_offset = -7)
                                       TableScan [TS_3] (rows=40000000 
width=112)
                                         
default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"]
-                          <-Reducer 16 [SIMPLE_EDGE]
+                          <-Reducer 14 [SIMPLE_EDGE]
                             SHUFFLE [RS_38]
                               PartitionCols:_col2
                               Merge Join Operator [MERGEJOIN_259] 
(rows=2526982 width=0)
-                                
Conds:RS_30._col4=RS_316._col0(Inner),Output:["_col2","_col5"]
-                              <-Map 29 [SIMPLE_EDGE] vectorized
-                                SHUFFLE [RS_316]
+                                
Conds:RS_30._col4=RS_298._col0(Inner),Output:["_col2","_col5"]
+                              <-Map 23 [SIMPLE_EDGE] vectorized
+                                SHUFFLE [RS_298]
                                   PartitionCols:_col0
-                                  Select Operator [SEL_315] (rows=2300 width=4)
+                                  Select Operator [SEL_297] (rows=2300 width=4)
                                     Output:["_col0"]
-                                    Filter Operator [FIL_314] (rows=2300 
width=259)
+                                    Filter Operator [FIL_296] (rows=2300 
width=259)
                                       predicate:((p_channel_dmail = 'Y') or 
(p_channel_email = 'Y') or (p_channel_tv = 'Y'))
                                       TableScan [TS_18] (rows=2300 width=259)
                                         
default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk","p_channel_dmail","p_channel_email","p_channel_tv"]
-                              <-Reducer 15 [SIMPLE_EDGE]
+                              <-Reducer 13 [SIMPLE_EDGE]
                                 SHUFFLE [RS_30]
                                   PartitionCols:_col4
                                   Merge Join Operator [MERGEJOIN_258] 
(rows=2526982 width=0)
-                                    
Conds:RS_27._col3=RS_299._col0(Inner),Output:["_col2","_col4","_col5"]
-                                  <-Map 26 [SIMPLE_EDGE] vectorized
-                                    PARTITION_ONLY_SHUFFLE [RS_299]
+                                    
Conds:RS_27._col3=RS_294._col0(Inner),Output:["_col2","_col4","_col5"]
+                                  <-Map 22 [SIMPLE_EDGE] vectorized
+                                    SHUFFLE [RS_294]
                                       PartitionCols:_col0
-                                      Select Operator [SEL_298] (rows=341 
width=4)
+                                      Select Operator [SEL_293] (rows=341 
width=4)
                                         Output:["_col0"]
-                                        Filter Operator [FIL_297] (rows=341 
width=115)
+                                        Filter Operator [FIL_292] (rows=341 
width=115)
                                           predicate:(s_gmt_offset = -7)
                                           TableScan [TS_15] (rows=1704 
width=115)
                                             
default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_gmt_offset"]
-                                  <-Reducer 14 [SIMPLE_EDGE]
+                                  <-Reducer 12 [SIMPLE_EDGE]
                                     SHUFFLE [RS_27]
                                       PartitionCols:_col3
                                       Merge Join Operator [MERGEJOIN_257] 
(rows=12627499 width=0)
-                                        
Conds:RS_24._col1=RS_287._col0(Inner),Output:["_col2","_col3","_col4","_col5"]
-                                      <-Map 23 [SIMPLE_EDGE] vectorized
-                                        PARTITION_ONLY_SHUFFLE [RS_287]
+                                        
Conds:RS_24._col1=RS_290._col0(Inner),Output:["_col2","_col3","_col4","_col5"]
+                                      <-Map 21 [SIMPLE_EDGE] vectorized
+                                        SHUFFLE [RS_290]
                                           PartitionCols:_col0
-                                          Select Operator [SEL_286] 
(rows=46200 width=4)
+                                          Select Operator [SEL_289] 
(rows=46200 width=4)
                                             Output:["_col0"]
-                                            Filter Operator [FIL_285] 
(rows=46200 width=94)
+                                            Filter Operator [FIL_288] 
(rows=46200 width=94)
                                               predicate:(i_category = 
'Electronics')
                                               TableScan [TS_12] (rows=462000 
width=94)
                                                 
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category"]
-                                      <-Reducer 13 [SIMPLE_EDGE]
+                                      <-Reducer 11 [SIMPLE_EDGE]
                                         SHUFFLE [RS_24]
                                           PartitionCols:_col1
                                           Merge Join Operator [MERGEJOIN_256] 
(rows=13119234 width=4)
-                                            
Conds:RS_313._col0=RS_275._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"]
-                                          <-Map 17 [SIMPLE_EDGE] vectorized
+                                            
Conds:RS_287._col0=RS_275._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"]
+                                          <-Map 15 [SIMPLE_EDGE] vectorized
                                             PARTITION_ONLY_SHUFFLE [RS_275]
                                               PartitionCols:_col0
                                               Select Operator [SEL_274] 
(rows=50 width=4)
@@ -234,64 +228,31 @@ Stage-0
                                                   predicate:((d_moy = 11) and 
(d_year = 1999))
                                                   TableScan [TS_9] (rows=73049 
width=12)
                                                     
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
-                                          <-Map 12 [SIMPLE_EDGE] vectorized
-                                            SHUFFLE [RS_313]
+                                          <-Map 10 [SIMPLE_EDGE] vectorized
+                                            SHUFFLE [RS_287]
                                               PartitionCols:_col0
-                                              Select Operator [SEL_312] 
(rows=479120970 width=126)
+                                              Select Operator [SEL_286] 
(rows=479120970 width=126)
                                                 
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
-                                                Filter Operator [FIL_311] 
(rows=479120970 width=126)
-                                                  predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_37_customer_c_customer_sk_min) AND 
DynamicValue(RS_37_customer_c_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_37_customer_c_customer_sk_bloom_filter))) and (ss_item_sk 
BETWEEN DynamicValue(RS_25_item_i_item_sk_min) AND 
DynamicValue(RS_25_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, 
DynamicValue(RS_25_item_i_item_sk_bloom_filter))) and (ss_sold_date_sk BETWEEN 
DynamicValue(RS_22_date_dim_d_date_sk_min) AND 
DynamicValue(RS_22_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_22_date_dim_d_date_sk_bloom_filter))) and (ss_store_sk BETWEEN 
DynamicValue(RS_28_store_s_store_sk_min) AND 
DynamicValue(RS_28_store_s_store_sk_max) and in_bloom_filter(ss_store_sk, 
DynamicValue(RS_28_store_s_store_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_promo_sk is not null and ss_sold_date_sk is not null and 
ss_store_sk is not null)
+                                                Filter Operator [FIL_285] 
(rows=479120970 width=126)
+                                                  predicate:((ss_sold_date_sk 
BETWEEN DynamicValue(RS_22_date_dim_d_date_sk_min) AND 
DynamicValue(RS_22_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_22_date_dim_d_date_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_promo_sk is not null and ss_sold_date_sk is not null and 
ss_store_sk is not null)
                                                   TableScan [TS_6] 
(rows=575995635 width=126)
                                                     
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_promo_sk","ss_ext_sales_price"]
-                                                  <-Reducer 18 
[BROADCAST_EDGE] vectorized
+                                                  <-Reducer 16 
[BROADCAST_EDGE] vectorized
                                                     BROADCAST [RS_284]
                                                       Group By Operator 
[GBY_283] (rows=1 width=12)
                                                         
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                      <-Map 17 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                      <-Map 15 
[CUSTOM_SIMPLE_EDGE] vectorized
                                                         PARTITION_ONLY_SHUFFLE 
[RS_281]
                                                           Group By Operator 
[GBY_279] (rows=1 width=12)
                                                             
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
                                                             Select Operator 
[SEL_276] (rows=50 width=4)
                                                               Output:["_col0"]
                                                                Please refer to 
the previous Select Operator [SEL_274]
-                                                  <-Reducer 24 
[BROADCAST_EDGE] vectorized
-                                                    BROADCAST [RS_296]
-                                                      Group By Operator 
[GBY_295] (rows=1 width=12)
-                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                      <-Map 23 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                        PARTITION_ONLY_SHUFFLE 
[RS_293]
-                                                          Group By Operator 
[GBY_291] (rows=1 width=12)
-                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                            Select Operator 
[SEL_288] (rows=46200 width=4)
-                                                              Output:["_col0"]
-                                                               Please refer to 
the previous Select Operator [SEL_286]
-                                                  <-Reducer 27 
[BROADCAST_EDGE] vectorized
-                                                    BROADCAST [RS_308]
-                                                      Group By Operator 
[GBY_307] (rows=1 width=12)
-                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                      <-Map 26 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                        PARTITION_ONLY_SHUFFLE 
[RS_305]
-                                                          Group By Operator 
[GBY_303] (rows=1 width=12)
-                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                            Select Operator 
[SEL_300] (rows=341 width=4)
-                                                              Output:["_col0"]
-                                                               Please refer to 
the previous Select Operator [SEL_298]
-                                                  <-Reducer 7 [BROADCAST_EDGE] 
vectorized
-                                                    BROADCAST [RS_310]
-                                                      Group By Operator 
[GBY_309] (rows=1 width=12)
-                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=14591048)"]
-                                                      <-Reducer 2 
[CUSTOM_SIMPLE_EDGE]
-                                                        SHUFFLE [RS_182]
-                                                          Group By Operator 
[GBY_181] (rows=1 width=12)
-                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=14591048)"]
-                                                            Select Operator 
[SEL_180] (rows=16000001 width=4)
-                                                              Output:["_col0"]
-                                                               Please refer to 
the previous Merge Join Operator [MERGEJOIN_255]
-                <-Reducer 9 [CUSTOM_SIMPLE_EDGE] vectorized
-                  PARTITION_ONLY_SHUFFLE [RS_331]
-                    Group By Operator [GBY_330] (rows=1 width=112)
+                <-Reducer 8 [CUSTOM_SIMPLE_EDGE] vectorized
+                  PARTITION_ONLY_SHUFFLE [RS_307]
+                    Group By Operator [GBY_306] (rows=1 width=112)
                       Output:["_col0"],aggregations:["sum(VALUE._col0)"]
-                    <-Reducer 8 [CUSTOM_SIMPLE_EDGE]
+                    <-Reducer 7 [CUSTOM_SIMPLE_EDGE]
                       PARTITION_ONLY_SHUFFLE [RS_81]
                         Group By Operator [GBY_80] (rows=1 width=112)
                           Output:["_col0"],aggregations:["sum(_col7)"]
@@ -301,84 +262,51 @@ Stage-0
                             SHUFFLE [RS_76]
                               PartitionCols:_col0
                                Please refer to the previous Merge Join 
Operator [MERGEJOIN_255]
-                          <-Reducer 21 [SIMPLE_EDGE]
+                          <-Reducer 19 [SIMPLE_EDGE]
                             SHUFFLE [RS_77]
                               PartitionCols:_col2
                               Merge Join Operator [MERGEJOIN_263] 
(rows=2646038 width=0)
-                                
Conds:RS_69._col3=RS_301._col0(Inner),Output:["_col2","_col4"]
-                              <-Map 26 [SIMPLE_EDGE] vectorized
-                                PARTITION_ONLY_SHUFFLE [RS_301]
+                                
Conds:RS_69._col3=RS_295._col0(Inner),Output:["_col2","_col4"]
+                              <-Map 22 [SIMPLE_EDGE] vectorized
+                                SHUFFLE [RS_295]
                                   PartitionCols:_col0
-                                   Please refer to the previous Select 
Operator [SEL_298]
-                              <-Reducer 20 [SIMPLE_EDGE]
+                                   Please refer to the previous Select 
Operator [SEL_293]
+                              <-Reducer 18 [SIMPLE_EDGE]
                                 SHUFFLE [RS_69]
                                   PartitionCols:_col3
                                   Merge Join Operator [MERGEJOIN_262] 
(rows=13222427 width=0)
-                                    
Conds:RS_66._col1=RS_289._col0(Inner),Output:["_col2","_col3","_col4"]
-                                  <-Map 23 [SIMPLE_EDGE] vectorized
-                                    PARTITION_ONLY_SHUFFLE [RS_289]
+                                    
Conds:RS_66._col1=RS_291._col0(Inner),Output:["_col2","_col3","_col4"]
+                                  <-Map 21 [SIMPLE_EDGE] vectorized
+                                    SHUFFLE [RS_291]
                                       PartitionCols:_col0
-                                       Please refer to the previous Select 
Operator [SEL_286]
-                                  <-Reducer 19 [SIMPLE_EDGE]
+                                       Please refer to the previous Select 
Operator [SEL_289]
+                                  <-Reducer 17 [SIMPLE_EDGE]
                                     SHUFFLE [RS_66]
                                       PartitionCols:_col1
                                       Merge Join Operator [MERGEJOIN_261] 
(rows=13737330 width=4)
-                                        
Conds:RS_329._col0=RS_277._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
-                                      <-Map 17 [SIMPLE_EDGE] vectorized
+                                        
Conds:RS_305._col0=RS_277._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
+                                      <-Map 15 [SIMPLE_EDGE] vectorized
                                         PARTITION_ONLY_SHUFFLE [RS_277]
                                           PartitionCols:_col0
                                            Please refer to the previous Select 
Operator [SEL_274]
-                                      <-Map 30 [SIMPLE_EDGE] vectorized
-                                        SHUFFLE [RS_329]
+                                      <-Map 24 [SIMPLE_EDGE] vectorized
+                                        SHUFFLE [RS_305]
                                           PartitionCols:_col0
-                                          Select Operator [SEL_328] 
(rows=501694138 width=122)
+                                          Select Operator [SEL_304] 
(rows=501694138 width=122)
                                             
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                            Filter Operator [FIL_327] 
(rows=501694138 width=122)
-                                              predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_76_customer_c_customer_sk_min) AND 
DynamicValue(RS_76_customer_c_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_76_customer_c_customer_sk_bloom_filter))) and (ss_item_sk 
BETWEEN DynamicValue(RS_67_item_i_item_sk_min) AND 
DynamicValue(RS_67_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, 
DynamicValue(RS_67_item_i_item_sk_bloom_filter))) and (ss_sold_date_sk BETWEEN 
DynamicValue(RS_64_date_dim_d_date_sk_min) AND 
DynamicValue(RS_64_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_64_date_dim_d_date_sk_bloom_filter))) and (ss_store_sk BETWEEN 
DynamicValue(RS_70_store_s_store_sk_min) AND 
DynamicValue(RS_70_store_s_store_sk_max) and in_bloom_filter(ss_store_sk, 
DynamicValue(RS_70_store_s_store_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_sold_date_sk is not null and ss_store_sk is not null)
+                                            Filter Operator [FIL_303] 
(rows=501694138 width=122)
+                                              predicate:((ss_sold_date_sk 
BETWEEN DynamicValue(RS_64_date_dim_d_date_sk_min) AND 
DynamicValue(RS_64_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_64_date_dim_d_date_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_sold_date_sk is not null and ss_store_sk is not null)
                                               TableScan [TS_51] 
(rows=575995635 width=122)
                                                 
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ext_sales_price"]
-                                              <-Reducer 10 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_326]
-                                                  Group By Operator [GBY_325] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=14591048)"]
-                                                  <-Reducer 2 
[CUSTOM_SIMPLE_EDGE]
-                                                    SHUFFLE [RS_237]
-                                                      Group By Operator 
[GBY_236] (rows=1 width=12)
-                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=14591048)"]
-                                                        Select Operator 
[SEL_235] (rows=16000001 width=4)
-                                                          Output:["_col0"]
-                                                           Please refer to the 
previous Merge Join Operator [MERGEJOIN_255]
-                                              <-Reducer 22 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_320]
-                                                  Group By Operator [GBY_319] 
(rows=1 width=12)
+                                              <-Reducer 20 [BROADCAST_EDGE] 
vectorized
+                                                BROADCAST [RS_302]
+                                                  Group By Operator [GBY_301] 
(rows=1 width=12)
                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                  <-Map 17 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                  <-Map 15 
[CUSTOM_SIMPLE_EDGE] vectorized
                                                     PARTITION_ONLY_SHUFFLE 
[RS_282]
                                                       Group By Operator 
[GBY_280] (rows=1 width=12)
                                                         
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
                                                         Select Operator 
[SEL_278] (rows=50 width=4)
                                                           Output:["_col0"]
                                                            Please refer to the 
previous Select Operator [SEL_274]
-                                              <-Reducer 25 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_322]
-                                                  Group By Operator [GBY_321] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                  <-Map 23 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_294]
-                                                      Group By Operator 
[GBY_292] (rows=1 width=12)
-                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                        Select Operator 
[SEL_290] (rows=46200 width=4)
-                                                          Output:["_col0"]
-                                                           Please refer to the 
previous Select Operator [SEL_286]
-                                              <-Reducer 28 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_324]
-                                                  Group By Operator [GBY_323] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                  <-Map 26 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_306]
-                                                      Group By Operator 
[GBY_304] (rows=1 width=12)
-                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                        Select Operator 
[SEL_302] (rows=341 width=4)
-                                                          Output:["_col0"]
-                                                           Please refer to the 
previous Select Operator [SEL_298]
 

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/constraints/query63.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query63.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query63.q.out
index 4f730b8..5620b81 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query63.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query63.q.out
@@ -67,23 +67,22 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 7 (BROADCAST_EDGE), Reducer 9 (BROADCAST_EDGE)
+Map 1 <- Reducer 7 (BROADCAST_EDGE)
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 6 (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 7 <- Map 6 (CUSTOM_SIMPLE_EDGE)
-Reducer 9 <- Map 8 (CUSTOM_SIMPLE_EDGE)
 
 Stage-0
   Fetch Operator
     limit:100
     Stage-1
       Reducer 5 vectorized
-      File Output Operator [FS_86]
-        Limit [LIM_85] (rows=65 width=228)
+      File Output Operator [FS_81]
+        Limit [LIM_80] (rows=65 width=228)
           Number of rows:100
-          Select Operator [SEL_84] (rows=65 width=228)
+          Select Operator [SEL_79] (rows=65 width=228)
             Output:["_col0","_col1","_col2"]
           <-Reducer 4 [SIMPLE_EDGE]
             SHUFFLE [RS_27]
@@ -105,13 +104,13 @@ Stage-0
                             Group By Operator [GBY_16] (rows=130 width=120)
                               
Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col4, _col6
                               Merge Join Operator [MERGEJOIN_62] (rows=98800 
width=8)
-                                
Conds:RS_12._col0=RS_73._col0(Inner),Output:["_col2","_col4","_col6"]
+                                
Conds:RS_12._col0=RS_76._col0(Inner),Output:["_col2","_col4","_col6"]
                               <-Map 8 [SIMPLE_EDGE] vectorized
-                                PARTITION_ONLY_SHUFFLE [RS_73]
+                                SHUFFLE [RS_76]
                                   PartitionCols:_col0
-                                  Select Operator [SEL_72] (rows=317 width=8)
+                                  Select Operator [SEL_75] (rows=317 width=8)
                                     Output:["_col0","_col1"]
-                                    Filter Operator [FIL_71] (rows=317 
width=12)
+                                    Filter Operator [FIL_74] (rows=317 
width=12)
                                       predicate:(d_month_seq) IN (1212, 1213, 
1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223)
                                       TableScan [TS_6] (rows=73049 width=12)
                                         
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_moy"]
@@ -119,7 +118,7 @@ Stage-0
                                 SHUFFLE [RS_12]
                                   PartitionCols:_col0
                                   Merge Join Operator [MERGEJOIN_61] 
(rows=569118 width=4)
-                                    
Conds:RS_81._col1=RS_65._col0(Inner),Output:["_col0","_col2","_col4"]
+                                    
Conds:RS_73._col1=RS_65._col0(Inner),Output:["_col0","_col2","_col4"]
                                   <-Map 6 [SIMPLE_EDGE] vectorized
                                     PARTITION_ONLY_SHUFFLE [RS_65]
                                       PartitionCols:_col0
@@ -130,12 +129,12 @@ Stage-0
                                           TableScan [TS_3] (rows=462000 
width=289)
                                             
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_manager_id"]
                                   <-Map 1 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_81]
+                                    SHUFFLE [RS_73]
                                       PartitionCols:_col1
-                                      Select Operator [SEL_80] (rows=525329897 
width=114)
+                                      Select Operator [SEL_72] (rows=525329897 
width=114)
                                         Output:["_col0","_col1","_col2"]
-                                        Filter Operator [FIL_79] 
(rows=525329897 width=118)
-                                          predicate:((ss_item_sk BETWEEN 
DynamicValue(RS_10_item_i_item_sk_min) AND 
DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, 
DynamicValue(RS_10_item_i_item_sk_bloom_filter))) and (ss_sold_date_sk BETWEEN 
DynamicValue(RS_13_date_dim_d_date_sk_min) AND 
DynamicValue(RS_13_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) and ss_sold_date_sk is 
not null and ss_store_sk is not null)
+                                        Filter Operator [FIL_71] 
(rows=525329897 width=118)
+                                          predicate:((ss_item_sk BETWEEN 
DynamicValue(RS_10_item_i_item_sk_min) AND 
DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, 
DynamicValue(RS_10_item_i_item_sk_bloom_filter))) 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 7 [BROADCAST_EDGE] 
vectorized
@@ -149,15 +148,4 @@ Stage-0
                                                     Select Operator [SEL_66] 
(rows=52 width=4)
                                                       Output:["_col0"]
                                                        Please refer to the 
previous Select Operator [SEL_64]
-                                          <-Reducer 9 [BROADCAST_EDGE] 
vectorized
-                                            BROADCAST [RS_78]
-                                              Group By Operator [GBY_77] 
(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_76]
-                                                  Group By Operator [GBY_75] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                    Select Operator [SEL_74] 
(rows=317 width=4)
-                                                      Output:["_col0"]
-                                                       Please refer to the 
previous Select Operator [SEL_72]
 

Reply via email to