http://git-wip-us.apache.org/repos/asf/hive/blob/5553c59e/ql/src/test/results/clientpositive/perf/tez/constraints/query54.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query54.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query54.q.out
index 21193d6..eed94ae 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query54.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query54.q.out
@@ -1,7 +1,7 @@
-Warning: Shuffle Join MERGEJOIN[264][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 2' is a cross product
-Warning: Shuffle Join MERGEJOIN[273][tables = [$hdt$_0, $hdt$_1, $hdt$_2, 
$hdt$_3, $hdt$_4]] in Stage 'Reducer 5' is a cross product
-Warning: Shuffle Join MERGEJOIN[272][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 14' is a cross product
-Warning: Shuffle Join MERGEJOIN[274][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 6' is a cross product
+Warning: Shuffle Join MERGEJOIN[269][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 2' is a cross product
+Warning: Shuffle Join MERGEJOIN[278][tables = [$hdt$_0, $hdt$_1, $hdt$_2, 
$hdt$_3, $hdt$_4, $hdt$_5]] in Stage 'Reducer 6' is a cross product
+Warning: Shuffle Join MERGEJOIN[277][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 15' is a cross product
+Warning: Shuffle Join MERGEJOIN[279][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 7' is a cross product
 PREHOOK: query: explain
 with my_customers as (
  select distinct c_customer_sk
@@ -133,30 +133,30 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 21 (BROADCAST_EDGE)
-Map 23 <- Reducer 31 (BROADCAST_EDGE), Reducer 33 (BROADCAST_EDGE), Union 24 
(CONTAINS)
-Map 29 <- Reducer 31 (BROADCAST_EDGE), Reducer 33 (BROADCAST_EDGE), Union 24 
(CONTAINS)
-Reducer 11 <- Map 10 (SIMPLE_EDGE)
-Reducer 12 <- Reducer 11 (CUSTOM_SIMPLE_EDGE)
-Reducer 13 <- Map 10 (SIMPLE_EDGE)
-Reducer 14 <- Reducer 13 (CUSTOM_SIMPLE_EDGE), Reducer 16 (CUSTOM_SIMPLE_EDGE)
-Reducer 15 <- Map 10 (SIMPLE_EDGE)
-Reducer 16 <- Reducer 15 (CUSTOM_SIMPLE_EDGE)
-Reducer 19 <- Map 18 (SIMPLE_EDGE), Map 22 (SIMPLE_EDGE)
-Reducer 2 <- Map 1 (CUSTOM_SIMPLE_EDGE), Reducer 12 (CUSTOM_SIMPLE_EDGE)
-Reducer 20 <- Reducer 19 (SIMPLE_EDGE), Reducer 28 (SIMPLE_EDGE)
-Reducer 21 <- Reducer 20 (CUSTOM_SIMPLE_EDGE)
-Reducer 25 <- Map 30 (SIMPLE_EDGE), Union 24 (SIMPLE_EDGE)
-Reducer 26 <- Map 32 (SIMPLE_EDGE), Reducer 25 (SIMPLE_EDGE)
-Reducer 27 <- Map 34 (SIMPLE_EDGE), Reducer 26 (SIMPLE_EDGE)
-Reducer 28 <- Reducer 27 (SIMPLE_EDGE)
-Reducer 3 <- Map 17 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
-Reducer 31 <- Map 30 (CUSTOM_SIMPLE_EDGE)
-Reducer 33 <- Map 32 (CUSTOM_SIMPLE_EDGE)
-Reducer 4 <- Reducer 20 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
-Reducer 5 <- Reducer 11 (CUSTOM_SIMPLE_EDGE), Reducer 4 (CUSTOM_SIMPLE_EDGE)
-Reducer 6 <- Reducer 14 (CUSTOM_SIMPLE_EDGE), Reducer 5 (CUSTOM_SIMPLE_EDGE)
-Reducer 7 <- Reducer 6 (SIMPLE_EDGE)
+Map 1 <- Reducer 24 (BROADCAST_EDGE)
+Map 18 <- Reducer 27 (BROADCAST_EDGE), Reducer 29 (BROADCAST_EDGE), Union 19 
(CONTAINS)
+Map 25 <- Reducer 27 (BROADCAST_EDGE), Reducer 29 (BROADCAST_EDGE), Union 19 
(CONTAINS)
+Reducer 10 <- Reducer 9 (SIMPLE_EDGE)
+Reducer 12 <- Map 11 (SIMPLE_EDGE)
+Reducer 13 <- Reducer 12 (CUSTOM_SIMPLE_EDGE)
+Reducer 14 <- Map 11 (SIMPLE_EDGE)
+Reducer 15 <- Reducer 14 (CUSTOM_SIMPLE_EDGE), Reducer 17 (CUSTOM_SIMPLE_EDGE)
+Reducer 16 <- Map 11 (SIMPLE_EDGE)
+Reducer 17 <- Reducer 16 (CUSTOM_SIMPLE_EDGE)
+Reducer 2 <- Map 1 (CUSTOM_SIMPLE_EDGE), Reducer 13 (CUSTOM_SIMPLE_EDGE)
+Reducer 20 <- Map 26 (SIMPLE_EDGE), Union 19 (SIMPLE_EDGE)
+Reducer 21 <- Map 28 (SIMPLE_EDGE), Reducer 20 (SIMPLE_EDGE)
+Reducer 22 <- Map 30 (SIMPLE_EDGE), Reducer 21 (SIMPLE_EDGE)
+Reducer 23 <- Reducer 22 (SIMPLE_EDGE)
+Reducer 24 <- Reducer 23 (CUSTOM_SIMPLE_EDGE)
+Reducer 27 <- Map 26 (CUSTOM_SIMPLE_EDGE)
+Reducer 29 <- Map 28 (CUSTOM_SIMPLE_EDGE)
+Reducer 3 <- Reducer 2 (SIMPLE_EDGE), Reducer 23 (SIMPLE_EDGE)
+Reducer 33 <- Map 32 (SIMPLE_EDGE), Map 34 (SIMPLE_EDGE)
+Reducer 4 <- Map 31 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
+Reducer 5 <- Reducer 33 (SIMPLE_EDGE), Reducer 4 (SIMPLE_EDGE)
+Reducer 6 <- Reducer 12 (CUSTOM_SIMPLE_EDGE), Reducer 5 (CUSTOM_SIMPLE_EDGE)
+Reducer 7 <- Reducer 15 (CUSTOM_SIMPLE_EDGE), Reducer 6 (CUSTOM_SIMPLE_EDGE)
 Reducer 8 <- Reducer 7 (SIMPLE_EDGE)
 Reducer 9 <- Reducer 8 (SIMPLE_EDGE)
 
@@ -164,28 +164,28 @@ Stage-0
   Fetch Operator
     limit:100
     Stage-1
-      Reducer 9 vectorized
-      File Output Operator [FS_354]
-        Limit [LIM_353] (rows=1 width=16)
+      Reducer 10 vectorized
+      File Output Operator [FS_361]
+        Limit [LIM_360] (rows=1 width=16)
           Number of rows:100
-          Select Operator [SEL_352] (rows=1 width=16)
+          Select Operator [SEL_359] (rows=1 width=16)
             Output:["_col0","_col1","_col2"]
-          <-Reducer 8 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_351]
-              Select Operator [SEL_350] (rows=1 width=16)
+          <-Reducer 9 [SIMPLE_EDGE] vectorized
+            SHUFFLE [RS_358]
+              Select Operator [SEL_357] (rows=1 width=16)
                 Output:["_col0","_col1","_col2"]
-                Group By Operator [GBY_349] (rows=1 width=12)
+                Group By Operator [GBY_356] (rows=1 width=12)
                   
Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0
-                <-Reducer 7 [SIMPLE_EDGE] vectorized
-                  SHUFFLE [RS_348]
+                <-Reducer 8 [SIMPLE_EDGE] vectorized
+                  SHUFFLE [RS_355]
                     PartitionCols:_col0
-                    Group By Operator [GBY_347] (rows=1 width=12)
+                    Group By Operator [GBY_354] (rows=1 width=12)
                       
Output:["_col0","_col1"],aggregations:["count()"],keys:_col0
-                      Select Operator [SEL_346] (rows=1 width=116)
+                      Select Operator [SEL_353] (rows=1 width=116)
                         Output:["_col0"]
-                        Group By Operator [GBY_345] (rows=1 width=116)
+                        Group By Operator [GBY_352] (rows=1 width=116)
                           
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
-                        <-Reducer 6 [SIMPLE_EDGE]
+                        <-Reducer 7 [SIMPLE_EDGE]
                           SHUFFLE [RS_118]
                             PartitionCols:_col0
                             Group By Operator [GBY_117] (rows=312 width=116)
@@ -196,244 +196,242 @@ Stage-0
                                   predicate:_col2 BETWEEN _col3 AND _col4
                                   Select Operator [SEL_114] (rows=5618315000 
width=127)
                                     
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                    Merge Join Operator [MERGEJOIN_274] 
(rows=5618315000 width=127)
+                                    Merge Join Operator [MERGEJOIN_279] 
(rows=5618315000 width=127)
                                       
Conds:(Inner),Output:["_col0","_col2","_col6","_col13","_col15"]
-                                    <-Reducer 14 [CUSTOM_SIMPLE_EDGE]
+                                    <-Reducer 15 [CUSTOM_SIMPLE_EDGE]
                                       PARTITION_ONLY_SHUFFLE [RS_111]
-                                        Merge Join Operator [MERGEJOIN_272] 
(rows=25 width=4)
+                                        Merge Join Operator [MERGEJOIN_277] 
(rows=25 width=4)
                                           Conds:(Right Outer),Output:["_col0"]
-                                        <-Reducer 13 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_336]
-                                            Group By Operator [GBY_335] 
(rows=25 width=4)
+                                        <-Reducer 14 [CUSTOM_SIMPLE_EDGE] 
vectorized
+                                          PARTITION_ONLY_SHUFFLE [RS_343]
+                                            Group By Operator [GBY_342] 
(rows=25 width=4)
                                               Output:["_col0"],keys:KEY._col0
-                                            <-Map 10 [SIMPLE_EDGE] vectorized
-                                              SHUFFLE [RS_322]
+                                            <-Map 11 [SIMPLE_EDGE] vectorized
+                                              SHUFFLE [RS_323]
                                                 PartitionCols:_col0
-                                                Group By Operator [GBY_319] 
(rows=25 width=4)
+                                                Group By Operator [GBY_320] 
(rows=25 width=4)
                                                   Output:["_col0"],keys:_col0
-                                                  Select Operator [SEL_316] 
(rows=50 width=12)
+                                                  Select Operator [SEL_317] 
(rows=50 width=12)
                                                     Output:["_col0"]
-                                                    Filter Operator [FIL_314] 
(rows=50 width=12)
+                                                    Filter Operator [FIL_315] 
(rows=50 width=12)
                                                       predicate:((d_moy = 3) 
and (d_year = 1999))
                                                       TableScan [TS_26] 
(rows=73049 width=12)
                                                         
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"]
-                                        <-Reducer 16 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_344]
-                                            Select Operator [SEL_343] (rows=1 
width=8)
-                                              Filter Operator [FIL_342] 
(rows=1 width=8)
+                                        <-Reducer 17 [CUSTOM_SIMPLE_EDGE] 
vectorized
+                                          PARTITION_ONLY_SHUFFLE [RS_351]
+                                            Select Operator [SEL_350] (rows=1 
width=8)
+                                              Filter Operator [FIL_349] 
(rows=1 width=8)
                                                 
predicate:(sq_count_check(_col0) <= 1)
-                                                Group By Operator [GBY_341] 
(rows=1 width=8)
+                                                Group By Operator [GBY_348] 
(rows=1 width=8)
                                                   
Output:["_col0"],aggregations:["count(VALUE._col0)"]
-                                                <-Reducer 15 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                  PARTITION_ONLY_SHUFFLE 
[RS_340]
-                                                    Group By Operator 
[GBY_339] (rows=1 width=8)
+                                                <-Reducer 16 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                  PARTITION_ONLY_SHUFFLE 
[RS_347]
+                                                    Group By Operator 
[GBY_346] (rows=1 width=8)
                                                       
Output:["_col0"],aggregations:["count()"]
-                                                      Select Operator 
[SEL_338] (rows=25 width=4)
-                                                        Group By Operator 
[GBY_337] (rows=25 width=4)
+                                                      Select Operator 
[SEL_345] (rows=25 width=4)
+                                                        Group By Operator 
[GBY_344] (rows=25 width=4)
                                                           
Output:["_col0"],keys:KEY._col0
-                                                        <-Map 10 [SIMPLE_EDGE] 
vectorized
-                                                          SHUFFLE [RS_323]
+                                                        <-Map 11 [SIMPLE_EDGE] 
vectorized
+                                                          SHUFFLE [RS_324]
                                                             PartitionCols:_col0
-                                                            Group By Operator 
[GBY_320] (rows=25 width=4)
+                                                            Group By Operator 
[GBY_321] (rows=25 width=4)
                                                               
Output:["_col0"],keys:_col0
-                                                              Select Operator 
[SEL_317] (rows=50 width=12)
+                                                              Select Operator 
[SEL_318] (rows=50 width=12)
                                                                 
Output:["_col0"]
-                                                                 Please refer 
to the previous Filter Operator [FIL_314]
-                                    <-Reducer 5 [CUSTOM_SIMPLE_EDGE]
+                                                                 Please refer 
to the previous Filter Operator [FIL_315]
+                                    <-Reducer 6 [CUSTOM_SIMPLE_EDGE]
                                       PARTITION_ONLY_SHUFFLE [RS_112]
                                         Select Operator [SEL_107] 
(rows=224732600 width=119)
                                           
Output:["_col0","_col4","_col11","_col13"]
-                                          Merge Join Operator [MERGEJOIN_273] 
(rows=224732600 width=119)
-                                            Conds:(Left 
Outer),Output:["_col2","_col5","_col11","_col13"]
-                                          <-Reducer 11 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                            PARTITION_ONLY_SHUFFLE [RS_326]
-                                              Group By Operator [GBY_324] 
(rows=25 width=4)
+                                          Merge Join Operator [MERGEJOIN_278] 
(rows=224732600 width=119)
+                                            Conds:(Left 
Outer),Output:["_col2","_col4","_col7","_col13"]
+                                          <-Reducer 12 [CUSTOM_SIMPLE_EDGE] 
vectorized
+                                            PARTITION_ONLY_SHUFFLE [RS_327]
+                                              Group By Operator [GBY_325] 
(rows=25 width=4)
                                                 Output:["_col0"],keys:KEY._col0
-                                              <-Map 10 [SIMPLE_EDGE] vectorized
-                                                SHUFFLE [RS_321]
+                                              <-Map 11 [SIMPLE_EDGE] vectorized
+                                                SHUFFLE [RS_322]
                                                   PartitionCols:_col0
-                                                  Group By Operator [GBY_318] 
(rows=25 width=4)
+                                                  Group By Operator [GBY_319] 
(rows=25 width=4)
                                                     Output:["_col0"],keys:_col0
-                                                    Select Operator [SEL_315] 
(rows=50 width=12)
+                                                    Select Operator [SEL_316] 
(rows=50 width=12)
                                                       Output:["_col0"]
-                                                       Please refer to the 
previous Filter Operator [FIL_314]
-                                          <-Reducer 4 [CUSTOM_SIMPLE_EDGE]
+                                                       Please refer to the 
previous Filter Operator [FIL_315]
+                                          <-Reducer 5 [CUSTOM_SIMPLE_EDGE]
                                             PARTITION_ONLY_SHUFFLE [RS_104]
-                                              Merge Join Operator 
[MERGEJOIN_271] (rows=8989304 width=8)
-                                                
Conds:RS_101._col1=RS_102._col5(Inner),Output:["_col2","_col5","_col11"]
-                                              <-Reducer 20 [SIMPLE_EDGE]
+                                              Merge Join Operator 
[MERGEJOIN_276] (rows=8989304 width=8)
+                                                
Conds:RS_101._col5=RS_102._col0(Inner),Output:["_col2","_col4","_col7"]
+                                              <-Reducer 33 [SIMPLE_EDGE]
                                                 SHUFFLE [RS_102]
-                                                  PartitionCols:_col5
-                                                  Merge Join Operator 
[MERGEJOIN_270] (rows=55046 width=4)
-                                                    
Conds:RS_83._col0=RS_308._col1(Inner),Output:["_col5"]
-                                                  <-Reducer 19 [SIMPLE_EDGE]
-                                                    SHUFFLE [RS_83]
-                                                      PartitionCols:_col0
-                                                      Merge Join Operator 
[MERGEJOIN_266] (rows=39720279 width=4)
-                                                        Conds:RS_287._col1, 
_col2=RS_290._col0, _col1(Inner),Output:["_col0"]
-                                                      <-Map 18 [SIMPLE_EDGE] 
vectorized
-                                                        SHUFFLE [RS_287]
-                                                          PartitionCols:_col1, 
_col2
-                                                          Select Operator 
[SEL_286] (rows=40000000 width=188)
-                                                            
Output:["_col0","_col1","_col2"]
-                                                            Filter Operator 
[FIL_285] (rows=40000000 width=188)
-                                                              
predicate:(ca_county is not null and ca_state is not null)
-                                                              TableScan 
[TS_43] (rows=40000000 width=188)
-                                                                
default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state"]
-                                                      <-Map 22 [SIMPLE_EDGE] 
vectorized
-                                                        SHUFFLE [RS_290]
-                                                          PartitionCols:_col0, 
_col1
-                                                          Select Operator 
[SEL_289] (rows=1704 width=184)
-                                                            
Output:["_col0","_col1"]
-                                                            Filter Operator 
[FIL_288] (rows=1704 width=184)
-                                                              
predicate:(s_county is not null and s_state is not null)
-                                                              TableScan 
[TS_46] (rows=1704 width=184)
-                                                                
default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_county","s_state"]
-                                                  <-Reducer 28 [SIMPLE_EDGE] 
vectorized
-                                                    SHUFFLE [RS_308]
-                                                      PartitionCols:_col1
-                                                      Select Operator 
[SEL_307] (rows=55046 width=8)
+                                                  PartitionCols:_col0
+                                                  Merge Join Operator 
[MERGEJOIN_275] (rows=39720279 width=4)
+                                                    Conds:RS_338._col1, 
_col2=RS_341._col0, _col1(Inner),Output:["_col0"]
+                                                  <-Map 32 [SIMPLE_EDGE] 
vectorized
+                                                    SHUFFLE [RS_338]
+                                                      PartitionCols:_col1, 
_col2
+                                                      Select Operator 
[SEL_337] (rows=40000000 width=188)
+                                                        
Output:["_col0","_col1","_col2"]
+                                                        Filter Operator 
[FIL_336] (rows=40000000 width=188)
+                                                          predicate:(ca_county 
is not null and ca_state is not null)
+                                                          TableScan [TS_74] 
(rows=40000000 width=188)
+                                                            
default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state"]
+                                                  <-Map 34 [SIMPLE_EDGE] 
vectorized
+                                                    SHUFFLE [RS_341]
+                                                      PartitionCols:_col0, 
_col1
+                                                      Select Operator 
[SEL_340] (rows=1704 width=184)
                                                         
Output:["_col0","_col1"]
-                                                        Group By Operator 
[GBY_306] (rows=55046 width=8)
-                                                          
Output:["_col0","_col1"],keys:KEY._col0, KEY._col1
-                                                        <-Reducer 27 
[SIMPLE_EDGE]
-                                                          SHUFFLE [RS_77]
-                                                            
PartitionCols:_col0, _col1
-                                                            Group By Operator 
[GBY_76] (rows=55046 width=8)
-                                                              
Output:["_col0","_col1"],keys:_col6, _col5
-                                                              Merge Join 
Operator [MERGEJOIN_269] (rows=110092 width=8)
-                                                                
Conds:RS_72._col1=RS_305._col0(Inner),Output:["_col5","_col6"]
-                                                              <-Map 34 
[SIMPLE_EDGE] vectorized
-                                                                SHUFFLE 
[RS_305]
-                                                                  
PartitionCols:_col0
-                                                                  Select 
Operator [SEL_304] (rows=80000000 width=8)
-                                                                    
Output:["_col0","_col1"]
-                                                                    Filter 
Operator [FIL_303] (rows=80000000 width=8)
-                                                                      
predicate:c_current_addr_sk is not null
-                                                                      
TableScan [TS_63] (rows=80000000 width=8)
-                                                                        
default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"]
-                                                              <-Reducer 26 
[SIMPLE_EDGE]
-                                                                SHUFFLE [RS_72]
-                                                                  
PartitionCols:_col1
-                                                                  Merge Join 
Operator [MERGEJOIN_268] (rows=110092 width=0)
-                                                                    
Conds:RS_69._col2=RS_299._col0(Inner),Output:["_col1"]
-                                                                  <-Map 32 
[SIMPLE_EDGE] vectorized
-                                                                    
PARTITION_ONLY_SHUFFLE [RS_299]
-                                                                      
PartitionCols:_col0
-                                                                      Select 
Operator [SEL_298] (rows=453 width=4)
-                                                                        
Output:["_col0"]
-                                                                        Filter 
Operator [FIL_297] (rows=453 width=186)
-                                                                          
predicate:((i_category = 'Jewelry') and (i_class = 'consignment'))
-                                                                          
TableScan [TS_60] (rows=462000 width=186)
-                                                                            
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"]
-                                                                  <-Reducer 25 
[SIMPLE_EDGE]
-                                                                    SHUFFLE 
[RS_69]
-                                                                      
PartitionCols:_col2
-                                                                      Merge 
Join Operator [MERGEJOIN_267] (rows=11665117 width=7)
-                                                                        
Conds:Union 24._col0=RS_293._col0(Inner),Output:["_col1","_col2"]
-                                                                      <-Map 30 
[SIMPLE_EDGE] vectorized
-                                                                        
PARTITION_ONLY_SHUFFLE [RS_293]
-                                                                          
PartitionCols:_col0
-                                                                          
Select Operator [SEL_292] (rows=50 width=4)
-                                                                            
Output:["_col0"]
-                                                                            
Filter Operator [FIL_291] (rows=50 width=12)
-                                                                              
predicate:((d_moy = 3) and (d_year = 1999))
-                                                                              
TableScan [TS_57] (rows=73049 width=12)
-                                                                               
 
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
-                                                                      <-Union 
24 [SIMPLE_EDGE]
-                                                                        <-Map 
23 [CONTAINS] vectorized
-                                                                          
Reduce Output Operator [RS_363]
-                                                                            
PartitionCols:_col0
-                                                                            
Select Operator [SEL_362] (rows=285117831 width=11)
-                                                                              
Output:["_col0","_col1","_col2"]
-                                                                              
Filter Operator [FIL_361] (rows=285117831 width=11)
-                                                                               
 predicate:((cs_item_sk BETWEEN DynamicValue(RS_70_item_i_item_sk_min) AND 
DynamicValue(RS_70_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, 
DynamicValue(RS_70_item_i_item_sk_bloom_filter))) and (cs_sold_date_sk BETWEEN 
DynamicValue(RS_67_date_dim_d_date_sk_min) AND 
DynamicValue(RS_67_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_67_date_dim_d_date_sk_bloom_filter))) and cs_bill_customer_sk 
is not null and cs_sold_date_sk is not null)
-                                                                               
 TableScan [TS_275] (rows=287989836 width=11)
-                                                                               
   Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk"]
-                                                                               
 <-Reducer 31 [BROADCAST_EDGE] vectorized
-                                                                               
   BROADCAST [RS_356]
-                                                                               
     Group By Operator [GBY_355] (rows=1 width=12)
-                                                                               
       
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
     <-Map 30 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
       PARTITION_ONLY_SHUFFLE [RS_296]
-                                                                               
         Group By Operator [GBY_295] (rows=1 width=12)
-                                                                               
           
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
           Select Operator [SEL_294] (rows=50 width=4)
-                                                                               
             Output:["_col0"]
-                                                                               
              Please refer to the previous Select Operator [SEL_292]
-                                                                               
 <-Reducer 33 [BROADCAST_EDGE] vectorized
-                                                                               
   BROADCAST [RS_359]
-                                                                               
     Group By Operator [GBY_358] (rows=1 width=12)
-                                                                               
       
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
     <-Map 32 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
       PARTITION_ONLY_SHUFFLE [RS_302]
-                                                                               
         Group By Operator [GBY_301] (rows=1 width=12)
-                                                                               
           
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
           Select Operator [SEL_300] (rows=453 width=4)
-                                                                               
             Output:["_col0"]
-                                                                               
              Please refer to the previous Select Operator [SEL_298]
-                                                                        <-Map 
29 [CONTAINS] vectorized
-                                                                          
Reduce Output Operator [RS_366]
-                                                                            
PartitionCols:_col0
-                                                                            
Select Operator [SEL_365] (rows=143930993 width=11)
-                                                                              
Output:["_col0","_col1","_col2"]
-                                                                              
Filter Operator [FIL_364] (rows=143930993 width=11)
-                                                                               
 predicate:((ws_item_sk BETWEEN DynamicValue(RS_70_item_i_item_sk_min) AND 
DynamicValue(RS_70_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_70_item_i_item_sk_bloom_filter))) and (ws_sold_date_sk BETWEEN 
DynamicValue(RS_67_date_dim_d_date_sk_min) AND 
DynamicValue(RS_67_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_67_date_dim_d_date_sk_bloom_filter))) and ws_bill_customer_sk 
is not null and ws_sold_date_sk is not null)
-                                                                               
 TableScan [TS_280] (rows=144002668 width=11)
-                                                                               
   Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk"]
-                                                                               
 <-Reducer 31 [BROADCAST_EDGE] vectorized
-                                                                               
   BROADCAST [RS_357]
-                                                                               
      Please refer to the previous Group By Operator [GBY_355]
-                                                                               
 <-Reducer 33 [BROADCAST_EDGE] vectorized
-                                                                               
   BROADCAST [RS_360]
-                                                                               
      Please refer to the previous Group By Operator [GBY_358]
-                                              <-Reducer 3 [SIMPLE_EDGE]
+                                                        Filter Operator 
[FIL_339] (rows=1704 width=184)
+                                                          predicate:(s_county 
is not null and s_state is not null)
+                                                          TableScan [TS_77] 
(rows=1704 width=184)
+                                                            
default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_county","s_state"]
+                                              <-Reducer 4 [SIMPLE_EDGE]
                                                 SHUFFLE [RS_101]
-                                                  PartitionCols:_col1
-                                                  Merge Join Operator 
[MERGEJOIN_265] (rows=525327388 width=114)
-                                                    
Conds:RS_98._col0=RS_334._col0(Inner),Output:["_col1","_col2","_col5"]
-                                                  <-Map 17 [SIMPLE_EDGE] 
vectorized
-                                                    SHUFFLE [RS_334]
+                                                  PartitionCols:_col5
+                                                  Merge Join Operator 
[MERGEJOIN_274] (rows=8989304 width=12)
+                                                    
Conds:RS_98._col0=RS_335._col0(Inner),Output:["_col2","_col4","_col5","_col7"]
+                                                  <-Map 31 [SIMPLE_EDGE] 
vectorized
+                                                    SHUFFLE [RS_335]
                                                       PartitionCols:_col0
-                                                      Select Operator 
[SEL_333] (rows=73049 width=8)
+                                                      Select Operator 
[SEL_334] (rows=73049 width=8)
                                                         
Output:["_col0","_col1"]
-                                                        TableScan [TS_41] 
(rows=73049 width=8)
+                                                        TableScan [TS_72] 
(rows=73049 width=8)
                                                           
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"]
-                                                  <-Reducer 2 [SIMPLE_EDGE]
+                                                  <-Reducer 3 [SIMPLE_EDGE]
                                                     SHUFFLE [RS_98]
                                                       PartitionCols:_col0
-                                                      Merge Join Operator 
[MERGEJOIN_264] (rows=525327388 width=114)
-                                                        
Conds:(Inner),Output:["_col0","_col1","_col2"]
-                                                      <-Map 1 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                        PARTITION_ONLY_SHUFFLE 
[RS_313]
-                                                          Select Operator 
[SEL_312] (rows=525327388 width=114)
-                                                            
Output:["_col0","_col1","_col2"]
-                                                            Filter Operator 
[FIL_311] (rows=525327388 width=114)
-                                                              
predicate:((ss_customer_sk BETWEEN 
DynamicValue(RS_102_customer_c_customer_sk_min) AND 
DynamicValue(RS_102_customer_c_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_102_customer_c_customer_sk_bloom_filter))) and ss_customer_sk 
is not null and ss_sold_date_sk is not null)
-                                                              TableScan 
[TS_23] (rows=575995635 width=114)
-                                                                
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_sales_price"]
-                                                              <-Reducer 21 
[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=1000000)"]
-                                                                  <-Reducer 20 
[CUSTOM_SIMPLE_EDGE]
-                                                                    SHUFFLE 
[RS_184]
-                                                                      Group By 
Operator [GBY_183] (rows=1 width=12)
-                                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                        Select 
Operator [SEL_182] (rows=55046 width=8)
+                                                      Merge Join Operator 
[MERGEJOIN_273] (rows=8989304 width=8)
+                                                        
Conds:RS_95._col1=RS_306._col0(Inner),Output:["_col0","_col2","_col4","_col5"]
+                                                      <-Reducer 23 
[SIMPLE_EDGE] vectorized
+                                                        SHUFFLE [RS_306]
+                                                          PartitionCols:_col0
+                                                          Group By Operator 
[GBY_305] (rows=55046 width=8)
+                                                            
Output:["_col0","_col1"],keys:KEY._col0, KEY._col1
+                                                          <-Reducer 22 
[SIMPLE_EDGE]
+                                                            SHUFFLE [RS_69]
+                                                              
PartitionCols:_col0, _col1
+                                                              Group By 
Operator [GBY_68] (rows=55046 width=8)
+                                                                
Output:["_col0","_col1"],keys:_col5, _col6
+                                                                Merge Join 
Operator [MERGEJOIN_272] (rows=110092 width=8)
+                                                                  
Conds:RS_64._col1=RS_304._col0(Inner),Output:["_col5","_col6"]
+                                                                <-Map 30 
[SIMPLE_EDGE] vectorized
+                                                                  SHUFFLE 
[RS_304]
+                                                                    
PartitionCols:_col0
+                                                                    Select 
Operator [SEL_303] (rows=80000000 width=8)
+                                                                      
Output:["_col0","_col1"]
+                                                                      Filter 
Operator [FIL_302] (rows=80000000 width=8)
+                                                                        
predicate:c_current_addr_sk is not null
+                                                                        
TableScan [TS_55] (rows=80000000 width=8)
+                                                                          
default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"]
+                                                                <-Reducer 21 
[SIMPLE_EDGE]
+                                                                  SHUFFLE 
[RS_64]
+                                                                    
PartitionCols:_col1
+                                                                    Merge Join 
Operator [MERGEJOIN_271] (rows=110092 width=0)
+                                                                      
Conds:RS_61._col2=RS_298._col0(Inner),Output:["_col1"]
+                                                                    <-Map 28 
[SIMPLE_EDGE] vectorized
+                                                                      
PARTITION_ONLY_SHUFFLE [RS_298]
+                                                                        
PartitionCols:_col0
+                                                                        Select 
Operator [SEL_297] (rows=453 width=4)
                                                                           
Output:["_col0"]
-                                                                           
Please refer to the previous Merge Join Operator [MERGEJOIN_270]
-                                                      <-Reducer 12 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                        PARTITION_ONLY_SHUFFLE 
[RS_332]
-                                                          Select Operator 
[SEL_331] (rows=1 width=8)
-                                                            Filter Operator 
[FIL_330] (rows=1 width=8)
-                                                              
predicate:(sq_count_check(_col0) <= 1)
-                                                              Group By 
Operator [GBY_329] (rows=1 width=8)
-                                                                
Output:["_col0"],aggregations:["count(VALUE._col0)"]
-                                                              <-Reducer 11 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                
PARTITION_ONLY_SHUFFLE [RS_328]
-                                                                  Group By 
Operator [GBY_327] (rows=1 width=8)
-                                                                    
Output:["_col0"],aggregations:["count()"]
-                                                                    Select 
Operator [SEL_325] (rows=25 width=4)
-                                                                       Please 
refer to the previous Group By Operator [GBY_324]
+                                                                          
Filter Operator [FIL_296] (rows=453 width=186)
+                                                                            
predicate:((i_category = 'Jewelry') and (i_class = 'consignment'))
+                                                                            
TableScan [TS_52] (rows=462000 width=186)
+                                                                              
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"]
+                                                                    <-Reducer 
20 [SIMPLE_EDGE]
+                                                                      SHUFFLE 
[RS_61]
+                                                                        
PartitionCols:_col2
+                                                                        Merge 
Join Operator [MERGEJOIN_270] (rows=11665117 width=7)
+                                                                          
Conds:Union 19._col0=RS_292._col0(Inner),Output:["_col1","_col2"]
+                                                                        <-Map 
26 [SIMPLE_EDGE] vectorized
+                                                                          
PARTITION_ONLY_SHUFFLE [RS_292]
+                                                                            
PartitionCols:_col0
+                                                                            
Select Operator [SEL_291] (rows=50 width=4)
+                                                                              
Output:["_col0"]
+                                                                              
Filter Operator [FIL_290] (rows=50 width=12)
+                                                                               
 predicate:((d_moy = 3) and (d_year = 1999))
+                                                                               
 TableScan [TS_49] (rows=73049 width=12)
+                                                                               
   
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
+                                                                        
<-Union 19 [SIMPLE_EDGE]
+                                                                          
<-Map 18 [CONTAINS] vectorized
+                                                                            
Reduce Output Operator [RS_370]
+                                                                              
PartitionCols:_col0
+                                                                              
Select Operator [SEL_369] (rows=285117831 width=11)
+                                                                               
 Output:["_col0","_col1","_col2"]
+                                                                               
 Filter Operator [FIL_368] (rows=285117831 width=11)
+                                                                               
   predicate:((cs_item_sk BETWEEN DynamicValue(RS_62_item_i_item_sk_min) AND 
DynamicValue(RS_62_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, 
DynamicValue(RS_62_item_i_item_sk_bloom_filter))) and (cs_sold_date_sk BETWEEN 
DynamicValue(RS_59_date_dim_d_date_sk_min) AND 
DynamicValue(RS_59_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_59_date_dim_d_date_sk_bloom_filter))) and cs_bill_customer_sk 
is not null and cs_sold_date_sk is not null)
+                                                                               
   TableScan [TS_280] (rows=287989836 width=11)
+                                                                               
     Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk"]
+                                                                               
   <-Reducer 27 [BROADCAST_EDGE] vectorized
+                                                                               
     BROADCAST [RS_363]
+                                                                               
       Group By Operator [GBY_362] (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_295]
+                                                                               
           Group By Operator [GBY_294] (rows=1 width=12)
+                                                                               
             
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
+                                                                               
             Select Operator [SEL_293] (rows=50 width=4)
+                                                                               
               Output:["_col0"]
+                                                                               
                Please refer to the previous Select Operator [SEL_291]
+                                                                               
   <-Reducer 29 [BROADCAST_EDGE] vectorized
+                                                                               
     BROADCAST [RS_366]
+                                                                               
       Group By Operator [GBY_365] (rows=1 width=12)
+                                                                               
         
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
+                                                                               
       <-Map 28 [CUSTOM_SIMPLE_EDGE] vectorized
+                                                                               
         PARTITION_ONLY_SHUFFLE [RS_301]
+                                                                               
           Group By Operator [GBY_300] (rows=1 width=12)
+                                                                               
             
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
+                                                                               
             Select Operator [SEL_299] (rows=453 width=4)
+                                                                               
               Output:["_col0"]
+                                                                               
                Please refer to the previous Select Operator [SEL_297]
+                                                                          
<-Map 25 [CONTAINS] vectorized
+                                                                            
Reduce Output Operator [RS_373]
+                                                                              
PartitionCols:_col0
+                                                                              
Select Operator [SEL_372] (rows=143930993 width=11)
+                                                                               
 Output:["_col0","_col1","_col2"]
+                                                                               
 Filter Operator [FIL_371] (rows=143930993 width=11)
+                                                                               
   predicate:((ws_item_sk BETWEEN DynamicValue(RS_62_item_i_item_sk_min) AND 
DynamicValue(RS_62_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_62_item_i_item_sk_bloom_filter))) and (ws_sold_date_sk BETWEEN 
DynamicValue(RS_59_date_dim_d_date_sk_min) AND 
DynamicValue(RS_59_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_59_date_dim_d_date_sk_bloom_filter))) and ws_bill_customer_sk 
is not null and ws_sold_date_sk is not null)
+                                                                               
   TableScan [TS_285] (rows=144002668 width=11)
+                                                                               
     Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk"]
+                                                                               
   <-Reducer 27 [BROADCAST_EDGE] vectorized
+                                                                               
     BROADCAST [RS_364]
+                                                                               
        Please refer to the previous Group By Operator [GBY_362]
+                                                                               
   <-Reducer 29 [BROADCAST_EDGE] vectorized
+                                                                               
     BROADCAST [RS_367]
+                                                                               
        Please refer to the previous Group By Operator [GBY_365]
+                                                      <-Reducer 2 [SIMPLE_EDGE]
+                                                        SHUFFLE [RS_95]
+                                                          PartitionCols:_col1
+                                                          Merge Join Operator 
[MERGEJOIN_269] (rows=525327388 width=114)
+                                                            
Conds:(Inner),Output:["_col0","_col1","_col2"]
+                                                          <-Map 1 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                            
PARTITION_ONLY_SHUFFLE [RS_314]
+                                                              Select Operator 
[SEL_313] (rows=525327388 width=114)
+                                                                
Output:["_col0","_col1","_col2"]
+                                                                Filter 
Operator [FIL_312] (rows=525327388 width=114)
+                                                                  
predicate:((ss_customer_sk BETWEEN 
DynamicValue(RS_96_customer_c_customer_sk_min) AND 
DynamicValue(RS_96_customer_c_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_96_customer_c_customer_sk_bloom_filter))) and ss_customer_sk is 
not null and ss_sold_date_sk is not null)
+                                                                  TableScan 
[TS_23] (rows=575995635 width=114)
+                                                                    
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_sales_price"]
+                                                                  <-Reducer 24 
[BROADCAST_EDGE] vectorized
+                                                                    BROADCAST 
[RS_311]
+                                                                      Group By 
Operator [GBY_310] (rows=1 width=12)
+                                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
+                                                                      
<-Reducer 23 [CUSTOM_SIMPLE_EDGE] vectorized
+                                                                        
SHUFFLE [RS_309]
+                                                                          
Group By Operator [GBY_308] (rows=1 width=12)
+                                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
+                                                                            
Select Operator [SEL_307] (rows=55046 width=4)
+                                                                              
Output:["_col0"]
+                                                                               
Please refer to the previous Group By Operator [GBY_305]
+                                                          <-Reducer 13 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                            
PARTITION_ONLY_SHUFFLE [RS_333]
+                                                              Select Operator 
[SEL_332] (rows=1 width=8)
+                                                                Filter 
Operator [FIL_331] (rows=1 width=8)
+                                                                  
predicate:(sq_count_check(_col0) <= 1)
+                                                                  Group By 
Operator [GBY_330] (rows=1 width=8)
+                                                                    
Output:["_col0"],aggregations:["count(VALUE._col0)"]
+                                                                  <-Reducer 12 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                                    
PARTITION_ONLY_SHUFFLE [RS_329]
+                                                                      Group By 
Operator [GBY_328] (rows=1 width=8)
+                                                                        
Output:["_col0"],aggregations:["count()"]
+                                                                        Select 
Operator [SEL_326] (rows=25 width=4)
+                                                                           
Please refer to the previous Group By Operator [GBY_325]
 

http://git-wip-us.apache.org/repos/asf/hive/blob/5553c59e/ql/src/test/results/clientpositive/perf/tez/constraints/query57.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query57.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query57.q.out
index 484a302..69aeaae 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query57.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query57.q.out
@@ -142,19 +142,19 @@ Stage-0
                       Filter Operator [FIL_302] (rows=87441185 width=408)
                         predicate:rank_window_0 is not null
                         PTF Operator [PTF_300] (rows=87441185 width=408)
-                          Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS 
LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4"}]
+                          Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS 
LAST, _col1 ASC NULLS LAST","partition by:":"_col4, _col3, _col2"}]
                           Select Operator [SEL_299] (rows=87441185 width=408)
                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
                           <-Reducer 5 [SIMPLE_EDGE] vectorized
                             SHUFFLE [RS_297]
-                              PartitionCols:_col1, _col0, _col4
+                              PartitionCols:_col4, _col3, _col2
                               Group By Operator [GBY_296] (rows=87441185 
width=408)
                                 
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2, KEY._col3, KEY._col4
                               <-Reducer 4 [SIMPLE_EDGE]
                                 SHUFFLE [RS_93]
                                   PartitionCols:_col0, _col1, _col2, _col3, 
_col4
                                   Group By Operator [GBY_92] (rows=87441185 
width=408)
-                                    
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col3)"],keys:_col10,
 _col11, _col5, _col6, _col8
+                                    
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col3)"],keys:_col5,
 _col6, _col8, _col10, _col11
                                     Merge Join Operator [MERGEJOIN_276] 
(rows=87441185 width=406)
                                       
Conds:RS_88._col2=RS_295._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col10","_col11"]
                                     <-Map 15 [SIMPLE_EDGE] vectorized
@@ -227,7 +227,7 @@ Stage-0
                           Filter Operator [FIL_303] (rows=87441185 width=408)
                             predicate:rank_window_0 is not null
                             PTF Operator [PTF_301] (rows=87441185 width=408)
-                              Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS 
LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4"}]
+                              Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS 
LAST, _col1 ASC NULLS LAST","partition by:":"_col4, _col3, _col2"}]
                                Please refer to the previous Select Operator 
[SEL_299]
                     <-Reducer 11 [SIMPLE_EDGE] vectorized
                       SHUFFLE [RS_318]
@@ -239,22 +239,22 @@ Stage-0
                             Select Operator [SEL_315] (rows=260242 width=520)
                               
Output:["rank_window_1","_col0","_col1","_col2","_col3","_col4","_col5","_col6"]
                               Filter Operator [FIL_314] (rows=260242 width=520)
-                                predicate:((_col0 > 0) and (_col3 = 2000) and 
rank_window_1 is not null)
+                                predicate:((_col0 > 0) and (_col1 = 2000) and 
rank_window_1 is not null)
                                 PTF Operator [PTF_313] (rows=87441185 
width=520)
-                                  Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col3 ASC NULLS 
LAST, _col4 ASC NULLS LAST","partition by:":"_col2, _col1, _col5"}]
+                                  Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS 
LAST, _col2 ASC NULLS LAST","partition by:":"_col5, _col4, _col3"}]
                                   Select Operator [SEL_312] (rows=87441185 
width=520)
                                     
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"]
                                   <-Reducer 10 [SIMPLE_EDGE] vectorized
                                     SHUFFLE [RS_311]
-                                      PartitionCols:_col1, _col0, _col4
+                                      PartitionCols:_col4, _col3, _col2
                                       Select Operator [SEL_310] (rows=87441185 
width=408)
                                         
Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5"]
                                         PTF Operator [PTF_309] (rows=87441185 
width=408)
-                                          Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS 
FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col2 ASC NULLS 
FIRST","partition by:":"_col1, _col0, _col4, _col2"}]
+                                          Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col4 ASC NULLS 
FIRST, _col3 ASC NULLS FIRST, _col2 ASC NULLS FIRST, _col0 ASC NULLS 
FIRST","partition by:":"_col4, _col3, _col2, _col0"}]
                                           Select Operator [SEL_308] 
(rows=87441185 width=408)
                                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
                                           <-Reducer 5 [SIMPLE_EDGE] vectorized
                                             SHUFFLE [RS_298]
-                                              PartitionCols:_col1, _col0, 
_col4, _col2
+                                              PartitionCols:_col4, _col3, 
_col2, _col0
                                                Please refer to the previous 
Group By Operator [GBY_296]
 

Reply via email to