http://git-wip-us.apache.org/repos/asf/hive/blob/f8b4c869/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 0210163..21193d6 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[270][tables = [$hdt$_0, $hdt$_1, $hdt$_2, 
$hdt$_3]] in Stage 'Reducer 4' is a cross product
-Warning: Shuffle Join MERGEJOIN[271][tables = [$hdt$_0, $hdt$_1, $hdt$_2, 
$hdt$_3, $hdt$_4]] in Stage 'Reducer 5' is a cross product
-Warning: Shuffle Join MERGEJOIN[269][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 32' is a cross product
-Warning: Shuffle Join MERGEJOIN[272][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 6' is a cross product
+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
 PREHOOK: query: explain
 with my_customers as (
  select distinct c_customer_sk
@@ -133,29 +133,29 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 14 (BROADCAST_EDGE)
-Map 16 <- Reducer 24 (BROADCAST_EDGE), Reducer 26 (BROADCAST_EDGE), Union 17 
(CONTAINS)
-Map 22 <- Reducer 24 (BROADCAST_EDGE), Reducer 26 (BROADCAST_EDGE), Union 17 
(CONTAINS)
-Reducer 12 <- Map 11 (SIMPLE_EDGE), Map 15 (SIMPLE_EDGE)
-Reducer 13 <- Reducer 12 (SIMPLE_EDGE), Reducer 21 (SIMPLE_EDGE)
-Reducer 14 <- Reducer 13 (CUSTOM_SIMPLE_EDGE)
-Reducer 18 <- Map 23 (SIMPLE_EDGE), Union 17 (SIMPLE_EDGE)
-Reducer 19 <- Map 25 (SIMPLE_EDGE), Reducer 18 (SIMPLE_EDGE)
-Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE)
-Reducer 20 <- Map 27 (SIMPLE_EDGE), Reducer 19 (SIMPLE_EDGE)
-Reducer 21 <- Reducer 20 (SIMPLE_EDGE)
-Reducer 24 <- Map 23 (CUSTOM_SIMPLE_EDGE)
-Reducer 26 <- Map 25 (CUSTOM_SIMPLE_EDGE)
-Reducer 29 <- Map 28 (SIMPLE_EDGE)
-Reducer 3 <- Reducer 13 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
-Reducer 30 <- Reducer 29 (CUSTOM_SIMPLE_EDGE)
-Reducer 31 <- Map 28 (SIMPLE_EDGE)
-Reducer 32 <- Reducer 31 (CUSTOM_SIMPLE_EDGE), Reducer 34 (CUSTOM_SIMPLE_EDGE)
-Reducer 33 <- Map 28 (SIMPLE_EDGE)
-Reducer 34 <- Reducer 33 (CUSTOM_SIMPLE_EDGE)
-Reducer 4 <- Reducer 3 (CUSTOM_SIMPLE_EDGE), Reducer 30 (CUSTOM_SIMPLE_EDGE)
-Reducer 5 <- Reducer 29 (CUSTOM_SIMPLE_EDGE), Reducer 4 (CUSTOM_SIMPLE_EDGE)
-Reducer 6 <- Reducer 32 (CUSTOM_SIMPLE_EDGE), Reducer 5 (CUSTOM_SIMPLE_EDGE)
+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)
 Reducer 8 <- Reducer 7 (SIMPLE_EDGE)
 Reducer 9 <- Reducer 8 (SIMPLE_EDGE)
@@ -165,25 +165,25 @@ Stage-0
     limit:100
     Stage-1
       Reducer 9 vectorized
-      File Output Operator [FS_352]
-        Limit [LIM_351] (rows=1 width=16)
+      File Output Operator [FS_354]
+        Limit [LIM_353] (rows=1 width=16)
           Number of rows:100
-          Select Operator [SEL_350] (rows=1 width=16)
+          Select Operator [SEL_352] (rows=1 width=16)
             Output:["_col0","_col1","_col2"]
           <-Reducer 8 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_349]
-              Select Operator [SEL_348] (rows=1 width=16)
+            SHUFFLE [RS_351]
+              Select Operator [SEL_350] (rows=1 width=16)
                 Output:["_col0","_col1","_col2"]
-                Group By Operator [GBY_347] (rows=1 width=12)
+                Group By Operator [GBY_349] (rows=1 width=12)
                   
Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0
                 <-Reducer 7 [SIMPLE_EDGE] vectorized
-                  SHUFFLE [RS_346]
+                  SHUFFLE [RS_348]
                     PartitionCols:_col0
-                    Group By Operator [GBY_345] (rows=1 width=12)
+                    Group By Operator [GBY_347] (rows=1 width=12)
                       
Output:["_col0","_col1"],aggregations:["count()"],keys:_col0
-                      Select Operator [SEL_344] (rows=1 width=116)
+                      Select Operator [SEL_346] (rows=1 width=116)
                         Output:["_col0"]
-                        Group By Operator [GBY_343] (rows=1 width=116)
+                        Group By Operator [GBY_345] (rows=1 width=116)
                           
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
                         <-Reducer 6 [SIMPLE_EDGE]
                           SHUFFLE [RS_118]
@@ -196,17 +196,17 @@ 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_272] 
(rows=5618315000 width=127)
+                                    Merge Join Operator [MERGEJOIN_274] 
(rows=5618315000 width=127)
                                       
Conds:(Inner),Output:["_col0","_col2","_col6","_col13","_col15"]
-                                    <-Reducer 32 [CUSTOM_SIMPLE_EDGE]
+                                    <-Reducer 14 [CUSTOM_SIMPLE_EDGE]
                                       PARTITION_ONLY_SHUFFLE [RS_111]
-                                        Merge Join Operator [MERGEJOIN_269] 
(rows=25 width=4)
+                                        Merge Join Operator [MERGEJOIN_272] 
(rows=25 width=4)
                                           Conds:(Right Outer),Output:["_col0"]
-                                        <-Reducer 31 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_334]
-                                            Group By Operator [GBY_333] 
(rows=25 width=4)
+                                        <-Reducer 13 [CUSTOM_SIMPLE_EDGE] 
vectorized
+                                          PARTITION_ONLY_SHUFFLE [RS_336]
+                                            Group By Operator [GBY_335] 
(rows=25 width=4)
                                               Output:["_col0"],keys:KEY._col0
-                                            <-Map 28 [SIMPLE_EDGE] vectorized
+                                            <-Map 10 [SIMPLE_EDGE] vectorized
                                               SHUFFLE [RS_322]
                                                 PartitionCols:_col0
                                                 Group By Operator [GBY_319] 
(rows=25 width=4)
@@ -215,23 +215,23 @@ Stage-0
                                                     Output:["_col0"]
                                                     Filter Operator [FIL_314] 
(rows=50 width=12)
                                                       predicate:((d_moy = 3) 
and (d_year = 1999))
-                                                      TableScan [TS_72] 
(rows=73049 width=12)
+                                                      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 34 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_342]
-                                            Select Operator [SEL_341] (rows=1 
width=8)
-                                              Filter Operator [FIL_340] 
(rows=1 width=8)
+                                        <-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)
                                                 
predicate:(sq_count_check(_col0) <= 1)
-                                                Group By Operator [GBY_339] 
(rows=1 width=8)
+                                                Group By Operator [GBY_341] 
(rows=1 width=8)
                                                   
Output:["_col0"],aggregations:["count(VALUE._col0)"]
-                                                <-Reducer 33 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                  PARTITION_ONLY_SHUFFLE 
[RS_338]
-                                                    Group By Operator 
[GBY_337] (rows=1 width=8)
+                                                <-Reducer 15 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                  PARTITION_ONLY_SHUFFLE 
[RS_340]
+                                                    Group By Operator 
[GBY_339] (rows=1 width=8)
                                                       
Output:["_col0"],aggregations:["count()"]
-                                                      Select Operator 
[SEL_336] (rows=25 width=4)
-                                                        Group By Operator 
[GBY_335] (rows=25 width=4)
+                                                      Select Operator 
[SEL_338] (rows=25 width=4)
+                                                        Group By Operator 
[GBY_337] (rows=25 width=4)
                                                           
Output:["_col0"],keys:KEY._col0
-                                                        <-Map 28 [SIMPLE_EDGE] 
vectorized
+                                                        <-Map 10 [SIMPLE_EDGE] 
vectorized
                                                           SHUFFLE [RS_323]
                                                             PartitionCols:_col0
                                                             Group By Operator 
[GBY_320] (rows=25 width=4)
@@ -243,13 +243,13 @@ Stage-0
                                       PARTITION_ONLY_SHUFFLE [RS_112]
                                         Select Operator [SEL_107] 
(rows=224732600 width=119)
                                           
Output:["_col0","_col4","_col11","_col13"]
-                                          Merge Join Operator [MERGEJOIN_271] 
(rows=224732600 width=119)
-                                            Conds:(Left 
Outer),Output:["_col2","_col4","_col10","_col13"]
-                                          <-Reducer 29 [CUSTOM_SIMPLE_EDGE] 
vectorized
+                                          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)
                                                 Output:["_col0"],keys:KEY._col0
-                                              <-Map 28 [SIMPLE_EDGE] vectorized
+                                              <-Map 10 [SIMPLE_EDGE] vectorized
                                                 SHUFFLE [RS_321]
                                                   PartitionCols:_col0
                                                   Group By Operator [GBY_318] 
(rows=25 width=4)
@@ -259,181 +259,181 @@ Stage-0
                                                        Please refer to the 
previous Filter Operator [FIL_314]
                                           <-Reducer 4 [CUSTOM_SIMPLE_EDGE]
                                             PARTITION_ONLY_SHUFFLE [RS_104]
-                                              Merge Join Operator 
[MERGEJOIN_270] (rows=8989304 width=8)
-                                                
Conds:(Inner),Output:["_col2","_col4","_col10"]
-                                              <-Reducer 3 [CUSTOM_SIMPLE_EDGE]
-                                                PARTITION_ONLY_SHUFFLE [RS_101]
-                                                  Merge Join Operator 
[MERGEJOIN_268] (rows=8989304 width=8)
-                                                    
Conds:RS_98._col1=RS_99._col5(Inner),Output:["_col2","_col4","_col10"]
-                                                  <-Reducer 13 [SIMPLE_EDGE]
-                                                    SHUFFLE [RS_99]
-                                                      PartitionCols:_col5
-                                                      Merge Join Operator 
[MERGEJOIN_267] (rows=55046 width=4)
-                                                        
Conds:RS_68._col0=RS_306._col1(Inner),Output:["_col5"]
-                                                      <-Reducer 12 
[SIMPLE_EDGE]
-                                                        SHUFFLE [RS_68]
-                                                          PartitionCols:_col0
-                                                          Merge Join Operator 
[MERGEJOIN_263] (rows=39720279 width=4)
-                                                            
Conds:RS_285._col1, _col2=RS_288._col0, _col1(Inner),Output:["_col0"]
-                                                          <-Map 11 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_285]
-                                                              
PartitionCols:_col1, _col2
-                                                              Select Operator 
[SEL_284] (rows=40000000 width=188)
-                                                                
Output:["_col0","_col1","_col2"]
-                                                                Filter 
Operator [FIL_283] (rows=40000000 width=188)
-                                                                  
predicate:(ca_county is not null and ca_state is not null)
-                                                                  TableScan 
[TS_28] (rows=40000000 width=188)
-                                                                    
default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state"]
-                                                          <-Map 15 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_288]
-                                                              
PartitionCols:_col0, _col1
-                                                              Select Operator 
[SEL_287] (rows=1704 width=184)
-                                                                
Output:["_col0","_col1"]
-                                                                Filter 
Operator [FIL_286] (rows=1704 width=184)
-                                                                  
predicate:(s_county is not null and s_state is not null)
-                                                                  TableScan 
[TS_31] (rows=1704 width=184)
-                                                                    
default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_county","s_state"]
-                                                      <-Reducer 21 
[SIMPLE_EDGE] vectorized
-                                                        SHUFFLE [RS_306]
-                                                          PartitionCols:_col1
-                                                          Select Operator 
[SEL_305] (rows=55046 width=8)
+                                              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]
+                                                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"]
-                                                            Group By Operator 
[GBY_304] (rows=55046 width=8)
-                                                              
Output:["_col0","_col1"],keys:KEY._col0, KEY._col1
-                                                            <-Reducer 20 
[SIMPLE_EDGE]
-                                                              SHUFFLE [RS_62]
-                                                                
PartitionCols:_col0, _col1
-                                                                Group By 
Operator [GBY_61] (rows=55046 width=8)
-                                                                  
Output:["_col0","_col1"],keys:_col6, _col5
-                                                                  Merge Join 
Operator [MERGEJOIN_266] (rows=110092 width=8)
-                                                                    
Conds:RS_57._col1=RS_303._col0(Inner),Output:["_col5","_col6"]
-                                                                  <-Map 27 
[SIMPLE_EDGE] vectorized
-                                                                    SHUFFLE 
[RS_303]
+                                                            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)
+                                                        
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_302] (rows=80000000 width=8)
-                                                                        
Output:["_col0","_col1"]
-                                                                        Filter 
Operator [FIL_301] (rows=80000000 width=8)
-                                                                          
predicate:c_current_addr_sk is not null
-                                                                          
TableScan [TS_48] (rows=80000000 width=8)
-                                                                            
default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"]
-                                                                  <-Reducer 19 
[SIMPLE_EDGE]
-                                                                    SHUFFLE 
[RS_57]
-                                                                      
PartitionCols:_col1
-                                                                      Merge 
Join Operator [MERGEJOIN_265] (rows=110092 width=0)
-                                                                        
Conds:RS_54._col2=RS_297._col0(Inner),Output:["_col1"]
-                                                                      <-Map 25 
[SIMPLE_EDGE] vectorized
-                                                                        
PARTITION_ONLY_SHUFFLE [RS_297]
+                                                                      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_296] (rows=453 width=4)
+                                                                          
Select Operator [SEL_292] (rows=50 width=4)
                                                                             
Output:["_col0"]
-                                                                            
Filter Operator [FIL_295] (rows=453 width=186)
-                                                                              
predicate:((i_category = 'Jewelry') and (i_class = 'consignment'))
-                                                                              
TableScan [TS_45] (rows=462000 width=186)
-                                                                               
 
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"]
-                                                                      
<-Reducer 18 [SIMPLE_EDGE]
-                                                                        
SHUFFLE [RS_54]
-                                                                          
PartitionCols:_col2
-                                                                          
Merge Join Operator [MERGEJOIN_264] (rows=11665117 width=7)
-                                                                            
Conds:Union 17._col0=RS_291._col0(Inner),Output:["_col1","_col2"]
-                                                                          
<-Map 23 [SIMPLE_EDGE] vectorized
-                                                                            
PARTITION_ONLY_SHUFFLE [RS_291]
-                                                                              
PartitionCols:_col0
-                                                                              
Select Operator [SEL_290] (rows=50 width=4)
-                                                                               
 Output:["_col0"]
-                                                                               
 Filter Operator [FIL_289] (rows=50 width=12)
-                                                                               
   predicate:((d_moy = 3) and (d_year = 1999))
-                                                                               
   TableScan [TS_42] (rows=73049 width=12)
-                                                                               
     
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
-                                                                          
<-Union 17 [SIMPLE_EDGE]
-                                                                            
<-Map 16 [CONTAINS] vectorized
-                                                                              
Reduce Output Operator [RS_361]
-                                                                               
 PartitionCols:_col0
-                                                                               
 Select Operator [SEL_360] (rows=285117831 width=11)
-                                                                               
   Output:["_col0","_col1","_col2"]
-                                                                               
   Filter Operator [FIL_359] (rows=285117831 width=11)
-                                                                               
     predicate:((cs_item_sk BETWEEN DynamicValue(RS_55_item_i_item_sk_min) AND 
DynamicValue(RS_55_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, 
DynamicValue(RS_55_item_i_item_sk_bloom_filter))) and (cs_sold_date_sk BETWEEN 
DynamicValue(RS_52_date_dim_d_date_sk_min) AND 
DynamicValue(RS_52_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_52_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_273] (rows=287989836 width=11)
-                                                                               
       Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk"]
-                                                                               
     <-Reducer 24 [BROADCAST_EDGE] vectorized
-                                                                               
       BROADCAST [RS_354]
-                                                                               
         Group By Operator [GBY_353] (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_293] (rows=1 width=12)
-                                                                               
               
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
               Select Operator [SEL_292] (rows=50 width=4)
-                                                                               
                 Output:["_col0"]
-                                                                               
                  Please refer to the previous Select Operator [SEL_290]
-                                                                               
     <-Reducer 26 [BROADCAST_EDGE] vectorized
-                                                                               
       BROADCAST [RS_357]
-                                                                               
         Group By Operator [GBY_356] (rows=1 width=12)
-                                                                               
           
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
         <-Map 25 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
           PARTITION_ONLY_SHUFFLE [RS_300]
-                                                                               
             Group By Operator [GBY_299] (rows=1 width=12)
-                                                                               
               
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
               Select Operator [SEL_298] (rows=453 width=4)
-                                                                               
                 Output:["_col0"]
-                                                                               
                  Please refer to the previous Select Operator [SEL_296]
-                                                                            
<-Map 22 [CONTAINS] vectorized
-                                                                              
Reduce Output Operator [RS_364]
-                                                                               
 PartitionCols:_col0
-                                                                               
 Select Operator [SEL_363] (rows=143930993 width=11)
-                                                                               
   Output:["_col0","_col1","_col2"]
-                                                                               
   Filter Operator [FIL_362] (rows=143930993 width=11)
-                                                                               
     predicate:((ws_item_sk BETWEEN DynamicValue(RS_55_item_i_item_sk_min) AND 
DynamicValue(RS_55_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_55_item_i_item_sk_bloom_filter))) and (ws_sold_date_sk BETWEEN 
DynamicValue(RS_52_date_dim_d_date_sk_min) AND 
DynamicValue(RS_52_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_52_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_278] (rows=144002668 width=11)
-                                                                               
       Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk"]
-                                                                               
     <-Reducer 24 [BROADCAST_EDGE] vectorized
-                                                                               
       BROADCAST [RS_355]
-                                                                               
          Please refer to the previous Group By Operator [GBY_353]
-                                                                               
     <-Reducer 26 [BROADCAST_EDGE] vectorized
-                                                                               
       BROADCAST [RS_358]
-                                                                               
          Please refer to the previous Group By Operator [GBY_356]
+                                                                            
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]
+                                                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:_col0
+                                                      Select Operator 
[SEL_333] (rows=73049 width=8)
+                                                        
Output:["_col0","_col1"]
+                                                        TableScan [TS_41] 
(rows=73049 width=8)
+                                                          
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"]
                                                   <-Reducer 2 [SIMPLE_EDGE]
                                                     SHUFFLE [RS_98]
-                                                      PartitionCols:_col1
-                                                      Merge Join Operator 
[MERGEJOIN_262] (rows=525327388 width=114)
-                                                        
Conds:RS_311._col0=RS_313._col0(Inner),Output:["_col1","_col2","_col4"]
-                                                      <-Map 1 [SIMPLE_EDGE] 
vectorized
-                                                        SHUFFLE [RS_311]
-                                                          PartitionCols:_col0
-                                                          Select Operator 
[SEL_310] (rows=525327388 width=114)
+                                                      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_309] (rows=525327388 width=114)
-                                                              
predicate:((ss_customer_sk BETWEEN 
DynamicValue(RS_99_customer_c_customer_sk_min) AND 
DynamicValue(RS_99_customer_c_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_99_customer_c_customer_sk_bloom_filter))) and ss_customer_sk is 
not null and ss_sold_date_sk is not null)
+                                                            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 14 
[BROADCAST_EDGE] vectorized
-                                                                BROADCAST 
[RS_308]
-                                                                  Group By 
Operator [GBY_307] (rows=1 width=12)
+                                                              <-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 13 
[CUSTOM_SIMPLE_EDGE]
-                                                                    SHUFFLE 
[RS_182]
-                                                                      Group By 
Operator [GBY_181] (rows=1 width=12)
+                                                                  <-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_180] (rows=55046 width=8)
+                                                                        Select 
Operator [SEL_182] (rows=55046 width=8)
                                                                           
Output:["_col0"]
-                                                                           
Please refer to the previous Merge Join Operator [MERGEJOIN_267]
-                                                      <-Map 10 [SIMPLE_EDGE] 
vectorized
-                                                        SHUFFLE [RS_313]
-                                                          PartitionCols:_col0
-                                                          Select Operator 
[SEL_312] (rows=73049 width=8)
-                                                            
Output:["_col0","_col1"]
-                                                            TableScan [TS_26] 
(rows=73049 width=8)
-                                                              
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"]
-                                              <-Reducer 30 
[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 29 
[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]
+                                                                           
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]
 

Reply via email to