http://git-wip-us.apache.org/repos/asf/hive/blob/0f7163fa/ql/src/test/results/clientpositive/perf/tez/query54.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/perf/tez/query54.q.out 
b/ql/src/test/results/clientpositive/perf/tez/query54.q.out
index c889ce1..e48e27e 100644
--- a/ql/src/test/results/clientpositive/perf/tez/query54.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/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[272][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 6' is a cross product
-Warning: Shuffle Join MERGEJOIN[273][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 7' is a cross product
+Warning: Shuffle Join MERGEJOIN[277][tables = [$hdt$_1, $hdt$_2, $hdt$_3, 
$hdt$_0, $hdt$_4]] in Stage 'Reducer 5' is a cross product
+Warning: Shuffle Join MERGEJOIN[279][tables = [$hdt$_1, $hdt$_2, $hdt$_3, 
$hdt$_0, $hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 7' is a cross product
+Warning: Shuffle Join MERGEJOIN[280][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 8' is a cross product
+Warning: Shuffle Join MERGEJOIN[281][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 9' is a cross product
 PREHOOK: query: explain
 with my_customers as (
  select distinct c_customer_sk
@@ -115,321 +115,324 @@ POSTHOOK: type: QUERY
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 12 (BROADCAST_EDGE)
-Map 17 <- Reducer 25 (BROADCAST_EDGE), Reducer 27 (BROADCAST_EDGE), Reducer 29 
(BROADCAST_EDGE), Union 18 (CONTAINS)
-Map 23 <- Reducer 25 (BROADCAST_EDGE), Reducer 27 (BROADCAST_EDGE), Union 18 
(CONTAINS)
+Map 14 <- Reducer 22 (BROADCAST_EDGE), Reducer 24 (BROADCAST_EDGE), Reducer 26 
(BROADCAST_EDGE), Union 15 (CONTAINS)
+Map 20 <- Reducer 22 (BROADCAST_EDGE), Reducer 24 (BROADCAST_EDGE), Union 15 
(CONTAINS)
+Map 27 <- Reducer 26 (BROADCAST_EDGE), Reducer 35 (BROADCAST_EDGE)
 Reducer 10 <- Reducer 9 (SIMPLE_EDGE)
-Reducer 12 <- Map 11 (CUSTOM_SIMPLE_EDGE)
-Reducer 14 <- Map 13 (SIMPLE_EDGE), Map 16 (SIMPLE_EDGE)
-Reducer 15 <- Reducer 14 (SIMPLE_EDGE), Reducer 22 (SIMPLE_EDGE)
-Reducer 19 <- Map 24 (SIMPLE_EDGE), Union 18 (SIMPLE_EDGE)
-Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 11 (SIMPLE_EDGE)
-Reducer 20 <- Map 26 (SIMPLE_EDGE), Reducer 19 (SIMPLE_EDGE)
-Reducer 21 <- Map 28 (SIMPLE_EDGE), Reducer 20 (SIMPLE_EDGE)
-Reducer 22 <- Reducer 21 (SIMPLE_EDGE)
-Reducer 25 <- Map 24 (CUSTOM_SIMPLE_EDGE)
-Reducer 27 <- Map 26 (CUSTOM_SIMPLE_EDGE)
-Reducer 29 <- Map 28 (CUSTOM_SIMPLE_EDGE)
-Reducer 3 <- Reducer 15 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
-Reducer 31 <- Map 30 (SIMPLE_EDGE)
+Reducer 11 <- Reducer 10 (SIMPLE_EDGE)
+Reducer 12 <- Reducer 11 (SIMPLE_EDGE)
+Reducer 16 <- Map 21 (SIMPLE_EDGE), Union 15 (SIMPLE_EDGE)
+Reducer 17 <- Map 23 (SIMPLE_EDGE), Reducer 16 (SIMPLE_EDGE)
+Reducer 18 <- Map 25 (SIMPLE_EDGE), Reducer 17 (SIMPLE_EDGE)
+Reducer 19 <- Reducer 18 (SIMPLE_EDGE)
+Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 13 (SIMPLE_EDGE)
+Reducer 22 <- Map 21 (CUSTOM_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 19 (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 33 <- Map 30 (SIMPLE_EDGE)
-Reducer 34 <- Reducer 33 (CUSTOM_SIMPLE_EDGE)
-Reducer 35 <- Map 30 (SIMPLE_EDGE)
-Reducer 4 <- Reducer 3 (CUSTOM_SIMPLE_EDGE), Reducer 32 (CUSTOM_SIMPLE_EDGE)
-Reducer 5 <- Reducer 31 (CUSTOM_SIMPLE_EDGE), Reducer 4 (CUSTOM_SIMPLE_EDGE)
-Reducer 6 <- Reducer 34 (CUSTOM_SIMPLE_EDGE), Reducer 5 (CUSTOM_SIMPLE_EDGE)
-Reducer 7 <- Reducer 35 (CUSTOM_SIMPLE_EDGE), Reducer 6 (CUSTOM_SIMPLE_EDGE)
-Reducer 8 <- Reducer 7 (SIMPLE_EDGE)
-Reducer 9 <- Reducer 8 (SIMPLE_EDGE)
+Reducer 33 <- Map 28 (SIMPLE_EDGE)
+Reducer 35 <- Map 34 (CUSTOM_SIMPLE_EDGE)
+Reducer 4 <- Map 27 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
+Reducer 5 <- Reducer 30 (CUSTOM_SIMPLE_EDGE), Reducer 4 (CUSTOM_SIMPLE_EDGE)
+Reducer 6 <- Map 34 (SIMPLE_EDGE), Reducer 5 (SIMPLE_EDGE)
+Reducer 7 <- Reducer 29 (CUSTOM_SIMPLE_EDGE), Reducer 6 (CUSTOM_SIMPLE_EDGE)
+Reducer 8 <- Reducer 32 (CUSTOM_SIMPLE_EDGE), Reducer 7 (CUSTOM_SIMPLE_EDGE)
+Reducer 9 <- Reducer 33 (CUSTOM_SIMPLE_EDGE), Reducer 8 (CUSTOM_SIMPLE_EDGE)
 
 Stage-0
   Fetch Operator
     limit:100
     Stage-1
-      Reducer 10 vectorized
-      File Output Operator [FS_360]
-        Limit [LIM_359] (rows=100 width=158)
+      Reducer 12 vectorized
+      File Output Operator [FS_371]
+        Limit [LIM_370] (rows=100 width=158)
           Number of rows:100
-          Select Operator [SEL_358] (rows=1614130953450400 width=158)
+          Select Operator [SEL_369] (rows=1614130953450400 width=158)
             Output:["_col0","_col1","_col2"]
-          <-Reducer 9 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_357]
-              Select Operator [SEL_356] (rows=1614130953450400 width=158)
+          <-Reducer 11 [SIMPLE_EDGE] vectorized
+            SHUFFLE [RS_368]
+              Select Operator [SEL_367] (rows=1614130953450400 width=158)
                 Output:["_col0","_col1","_col2"]
-                Group By Operator [GBY_355] (rows=1614130953450400 width=158)
+                Group By Operator [GBY_366] (rows=1614130953450400 width=158)
                   
Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0
-                <-Reducer 8 [SIMPLE_EDGE] vectorized
-                  SHUFFLE [RS_354]
+                <-Reducer 10 [SIMPLE_EDGE] vectorized
+                  SHUFFLE [RS_365]
                     PartitionCols:_col0
-                    Group By Operator [GBY_353] (rows=3228261906900801 
width=158)
+                    Group By Operator [GBY_364] (rows=3228261906900801 
width=158)
                       
Output:["_col0","_col1"],aggregations:["count()"],keys:_col0
-                      Select Operator [SEL_352] (rows=3228261906900801 
width=158)
+                      Select Operator [SEL_363] (rows=3228261906900801 
width=158)
                         Output:["_col0"]
-                        Group By Operator [GBY_351] (rows=3228261906900801 
width=158)
+                        Group By Operator [GBY_362] (rows=3228261906900801 
width=158)
                           
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
-                        <-Reducer 7 [SIMPLE_EDGE]
-                          SHUFFLE [RS_119]
+                        <-Reducer 9 [SIMPLE_EDGE]
+                          SHUFFLE [RS_118]
                             PartitionCols:_col0
-                            Group By Operator [GBY_118] (rows=6456523813801603 
width=158)
+                            Group By Operator [GBY_117] (rows=6456523813801603 
width=158)
                               
Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0
-                              Select Operator [SEL_117] (rows=6456523813801603 
width=158)
+                              Select Operator [SEL_116] (rows=6456523813801603 
width=158)
                                 Output:["_col0","_col1"]
-                                Filter Operator [FIL_116] 
(rows=6456523813801603 width=158)
+                                Filter Operator [FIL_115] 
(rows=6456523813801603 width=158)
                                   predicate:_col2 BETWEEN _col3 AND _col4
-                                  Merge Join Operator [MERGEJOIN_273] 
(rows=58108714324214428 width=158)
+                                  Merge Join Operator [MERGEJOIN_281] 
(rows=58108714324214428 width=158)
                                     Conds:(Left 
Outer),Output:["_col0","_col1","_col2","_col3","_col4"]
-                                  <-Reducer 35 [CUSTOM_SIMPLE_EDGE] vectorized
-                                    PARTITION_ONLY_SHUFFLE [RS_350]
-                                      Group By Operator [GBY_349] (rows=9131 
width=1119)
+                                  <-Reducer 33 [CUSTOM_SIMPLE_EDGE] vectorized
+                                    PARTITION_ONLY_SHUFFLE [RS_361]
+                                      Group By Operator [GBY_360] (rows=9131 
width=1119)
                                         Output:["_col0"],keys:KEY._col0
-                                      <-Map 30 [SIMPLE_EDGE] vectorized
-                                        SHUFFLE [RS_331]
+                                      <-Map 28 [SIMPLE_EDGE] vectorized
+                                        SHUFFLE [RS_342]
                                           PartitionCols:_col0
-                                          Group By Operator [GBY_328] 
(rows=18262 width=1119)
+                                          Group By Operator [GBY_339] 
(rows=18262 width=1119)
                                             Output:["_col0"],keys:_col0
-                                            Select Operator [SEL_325] 
(rows=18262 width=1119)
+                                            Select Operator [SEL_336] 
(rows=18262 width=1119)
                                               Output:["_col0"]
-                                              Filter Operator [FIL_322] 
(rows=18262 width=1119)
+                                              Filter Operator [FIL_333] 
(rows=18262 width=1119)
                                                 predicate:((d_moy = 3) and 
(d_year = 1999))
-                                                TableScan [TS_50] (rows=73049 
width=1119)
+                                                TableScan [TS_40] (rows=73049 
width=1119)
                                                   
default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_month_seq","d_year","d_moy"]
-                                  <-Reducer 6 [CUSTOM_SIMPLE_EDGE]
-                                    PARTITION_ONLY_SHUFFLE [RS_113]
-                                      Select Operator [SEL_104] 
(rows=6363893803988 width=1226)
+                                  <-Reducer 8 [CUSTOM_SIMPLE_EDGE]
+                                    PARTITION_ONLY_SHUFFLE [RS_112]
+                                      Select Operator [SEL_103] 
(rows=6363893803988 width=1226)
                                         
Output:["_col0","_col1","_col2","_col3"]
-                                        Merge Join Operator [MERGEJOIN_272] 
(rows=6363893803988 width=1226)
+                                        Merge Join Operator [MERGEJOIN_280] 
(rows=6363893803988 width=1226)
                                           
Conds:(Inner),Output:["_col0","_col4","_col11","_col13"]
-                                        <-Reducer 34 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_348]
-                                            Select Operator [SEL_347] (rows=1 
width=8)
-                                              Filter Operator [FIL_346] 
(rows=1 width=8)
+                                        <-Reducer 32 [CUSTOM_SIMPLE_EDGE] 
vectorized
+                                          PARTITION_ONLY_SHUFFLE [RS_359]
+                                            Select Operator [SEL_358] (rows=1 
width=8)
+                                              Filter Operator [FIL_357] 
(rows=1 width=8)
                                                 
predicate:(sq_count_check(_col0) <= 1)
-                                                Group By Operator [GBY_345] 
(rows=1 width=8)
+                                                Group By Operator [GBY_356] 
(rows=1 width=8)
                                                   
Output:["_col0"],aggregations:["count(VALUE._col0)"]
-                                                <-Reducer 33 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                  PARTITION_ONLY_SHUFFLE 
[RS_344]
-                                                    Group By Operator 
[GBY_343] (rows=1 width=8)
+                                                <-Reducer 31 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                  PARTITION_ONLY_SHUFFLE 
[RS_355]
+                                                    Group By Operator 
[GBY_354] (rows=1 width=8)
                                                       
Output:["_col0"],aggregations:["count()"]
-                                                      Select Operator 
[SEL_342] (rows=9131 width=1119)
-                                                        Group By Operator 
[GBY_341] (rows=9131 width=1119)
+                                                      Select Operator 
[SEL_353] (rows=9131 width=1119)
+                                                        Group By Operator 
[GBY_352] (rows=9131 width=1119)
                                                           
Output:["_col0"],keys:KEY._col0
-                                                        <-Map 30 [SIMPLE_EDGE] 
vectorized
-                                                          SHUFFLE [RS_330]
+                                                        <-Map 28 [SIMPLE_EDGE] 
vectorized
+                                                          SHUFFLE [RS_341]
                                                             PartitionCols:_col0
-                                                            Group By Operator 
[GBY_327] (rows=18262 width=1119)
+                                                            Group By Operator 
[GBY_338] (rows=18262 width=1119)
                                                               
Output:["_col0"],keys:_col0
-                                                              Select Operator 
[SEL_324] (rows=18262 width=1119)
+                                                              Select Operator 
[SEL_335] (rows=18262 width=1119)
                                                                 
Output:["_col0"]
-                                                                 Please refer 
to the previous Filter Operator [FIL_322]
-                                        <-Reducer 5 [CUSTOM_SIMPLE_EDGE]
-                                          PARTITION_ONLY_SHUFFLE [RS_101]
-                                            Select Operator [SEL_85] 
(rows=6363893803988 width=1217)
+                                                                 Please refer 
to the previous Filter Operator [FIL_333]
+                                        <-Reducer 7 [CUSTOM_SIMPLE_EDGE]
+                                          PARTITION_ONLY_SHUFFLE [RS_100]
+                                            Select Operator [SEL_84] 
(rows=6363893803988 width=1217)
                                               
Output:["_col0","_col4","_col11","_col13"]
-                                              Merge Join Operator 
[MERGEJOIN_271] (rows=6363893803988 width=1217)
-                                                Conds:(Left 
Outer),Output:["_col2","_col4","_col10","_col13"]
-                                              <-Reducer 31 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                PARTITION_ONLY_SHUFFLE [RS_334]
-                                                  Group By Operator [GBY_332] 
(rows=9131 width=1119)
+                                              Merge Join Operator 
[MERGEJOIN_279] (rows=6363893803988 width=1217)
+                                                Conds:(Left 
Outer),Output:["_col5","_col9","_col12","_col13"]
+                                              <-Reducer 29 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                PARTITION_ONLY_SHUFFLE [RS_345]
+                                                  Group By Operator [GBY_343] 
(rows=9131 width=1119)
                                                     
Output:["_col0"],keys:KEY._col0
-                                                  <-Map 30 [SIMPLE_EDGE] 
vectorized
-                                                    SHUFFLE [RS_329]
+                                                  <-Map 28 [SIMPLE_EDGE] 
vectorized
+                                                    SHUFFLE [RS_340]
                                                       PartitionCols:_col0
-                                                      Group By Operator 
[GBY_326] (rows=18262 width=1119)
+                                                      Group By Operator 
[GBY_337] (rows=18262 width=1119)
                                                         
Output:["_col0"],keys:_col0
-                                                        Select Operator 
[SEL_323] (rows=18262 width=1119)
+                                                        Select Operator 
[SEL_334] (rows=18262 width=1119)
                                                           Output:["_col0"]
-                                                           Please refer to the 
previous Filter Operator [FIL_322]
-                                              <-Reducer 4 [CUSTOM_SIMPLE_EDGE]
-                                                PARTITION_ONLY_SHUFFLE [RS_82]
-                                                  Merge Join Operator 
[MERGEJOIN_270] (rows=696954748 width=97)
-                                                    
Conds:(Inner),Output:["_col2","_col4","_col10"]
-                                                  <-Reducer 3 
[CUSTOM_SIMPLE_EDGE]
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_79]
-                                                      Merge Join Operator 
[MERGEJOIN_269] (rows=696954748 width=88)
-                                                        
Conds:RS_76._col1=RS_77._col5(Inner),Output:["_col2","_col4","_col10"]
-                                                      <-Reducer 15 
[SIMPLE_EDGE]
-                                                        SHUFFLE [RS_77]
-                                                          PartitionCols:_col5
-                                                          Merge Join Operator 
[MERGEJOIN_268] (rows=316240138 width=135)
-                                                            
Conds:RS_46._col0=RS_321._col1(Inner),Output:["_col5"]
-                                                          <-Reducer 14 
[SIMPLE_EDGE]
-                                                            SHUFFLE [RS_46]
-                                                              
PartitionCols:_col0
-                                                              Merge Join 
Operator [MERGEJOIN_264] (rows=44000000 width=1014)
-                                                                
Conds:RS_297._col1, _col2=RS_300._col0, _col1(Inner),Output:["_col0"]
-                                                              <-Map 13 
[SIMPLE_EDGE] vectorized
-                                                                SHUFFLE 
[RS_297]
-                                                                  
PartitionCols:_col1, _col2
-                                                                  Select 
Operator [SEL_296] (rows=40000000 width=1014)
-                                                                    
Output:["_col0","_col1","_col2"]
-                                                                    Filter 
Operator [FIL_295] (rows=40000000 width=1014)
-                                                                      
predicate:(ca_address_sk is not null and ca_county is not null and ca_state is 
not null)
-                                                                      
TableScan [TS_6] (rows=40000000 width=1014)
-                                                                        
default@customer_address,customer_address,Tbl:COMPLETE,Col:NONE,Output:["ca_address_sk","ca_county","ca_state"]
-                                                              <-Map 16 
[SIMPLE_EDGE] vectorized
-                                                                SHUFFLE 
[RS_300]
-                                                                  
PartitionCols:_col0, _col1
-                                                                  Select 
Operator [SEL_299] (rows=1704 width=1910)
-                                                                    
Output:["_col0","_col1"]
-                                                                    Filter 
Operator [FIL_298] (rows=1704 width=1910)
-                                                                      
predicate:(s_county is not null and s_state is not null)
-                                                                      
TableScan [TS_9] (rows=1704 width=1910)
-                                                                        
default@store,store,Tbl:COMPLETE,Col:NONE,Output:["s_county","s_state"]
-                                                          <-Reducer 22 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_321]
+                                                           Please refer to the 
previous Filter Operator [FIL_333]
+                                              <-Reducer 6 [CUSTOM_SIMPLE_EDGE]
+                                                PARTITION_ONLY_SHUFFLE [RS_81]
+                                                  Merge Join Operator 
[MERGEJOIN_278] (rows=696954748 width=97)
+                                                    
Conds:RS_78._col7=RS_324._col0(Inner),Output:["_col5","_col9","_col12"]
+                                                  <-Map 34 [SIMPLE_EDGE] 
vectorized
+                                                    SHUFFLE [RS_324]
+                                                      PartitionCols:_col0
+                                                      Select Operator 
[SEL_323] (rows=73049 width=1119)
+                                                        
Output:["_col0","_col1"]
+                                                        Filter Operator 
[FIL_322] (rows=73049 width=1119)
+                                                          predicate:d_date_sk 
is not null
+                                                          TableScan [TS_55] 
(rows=73049 width=1119)
+                                                            
default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_month_seq"]
+                                                  <-Reducer 5 [SIMPLE_EDGE]
+                                                    SHUFFLE [RS_78]
+                                                      PartitionCols:_col7
+                                                      Merge Join Operator 
[MERGEJOIN_277] (rows=633595212 width=97)
+                                                        
Conds:(Inner),Output:["_col5","_col7","_col9"]
+                                                      <-Reducer 30 
[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_348] (rows=1 width=8)
+                                                                
Output:["_col0"],aggregations:["count(VALUE._col0)"]
+                                                              <-Reducer 29 
[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_344] (rows=9131 width=1119)
+                                                                       Please 
refer to the previous Group By Operator [GBY_343]
+                                                      <-Reducer 4 
[CUSTOM_SIMPLE_EDGE]
+                                                        PARTITION_ONLY_SHUFFLE 
[RS_75]
+                                                          Merge Join Operator 
[MERGEJOIN_276] (rows=633595212 width=88)
+                                                            
Conds:RS_72._col5=RS_332._col1(Inner),Output:["_col5","_col7","_col9"]
+                                                          <-Map 27 
[SIMPLE_EDGE] vectorized
+                                                            SHUFFLE [RS_332]
                                                               
PartitionCols:_col1
-                                                              Select Operator 
[SEL_320] (rows=287491029 width=135)
-                                                                
Output:["_col0","_col1"]
-                                                                Group By 
Operator [GBY_319] (rows=287491029 width=135)
-                                                                  
Output:["_col0","_col1"],keys:KEY._col0, KEY._col1
-                                                                <-Reducer 21 
[SIMPLE_EDGE]
-                                                                  SHUFFLE 
[RS_40]
-                                                                    
PartitionCols:_col0, _col1
-                                                                    Group By 
Operator [GBY_39] (rows=574982058 width=135)
-                                                                      
Output:["_col0","_col1"],keys:_col10, _col9
-                                                                      Merge 
Join Operator [MERGEJOIN_267] (rows=574982058 width=135)
-                                                                        
Conds:RS_35._col1=RS_315._col0(Inner),Output:["_col9","_col10"]
-                                                                      <-Map 28 
[SIMPLE_EDGE] vectorized
-                                                                        
PARTITION_ONLY_SHUFFLE [RS_315]
-                                                                          
PartitionCols:_col0
-                                                                          
Select Operator [SEL_314] (rows=80000000 width=860)
-                                                                            
Output:["_col0","_col1"]
-                                                                            
Filter Operator [FIL_313] (rows=80000000 width=860)
-                                                                              
predicate:(c_current_addr_sk is not null and c_customer_sk is not null)
-                                                                              
TableScan [TS_26] (rows=80000000 width=860)
-                                                                               
 
default@customer,customer,Tbl:COMPLETE,Col:NONE,Output:["c_customer_sk","c_current_addr_sk"]
-                                                                      
<-Reducer 20 [SIMPLE_EDGE]
-                                                                        
SHUFFLE [RS_35]
-                                                                          
PartitionCols:_col1
-                                                                          
Merge Join Operator [MERGEJOIN_266] (rows=522710951 width=135)
-                                                                            
Conds:RS_32._col2=RS_309._col0(Inner),Output:["_col1"]
-                                                                          
<-Map 26 [SIMPLE_EDGE] vectorized
-                                                                            
PARTITION_ONLY_SHUFFLE [RS_309]
-                                                                              
PartitionCols:_col0
-                                                                              
Select Operator [SEL_308] (rows=115500 width=1436)
-                                                                               
 Output:["_col0"]
-                                                                               
 Filter Operator [FIL_307] (rows=115500 width=1436)
-                                                                               
   predicate:((i_category = 'Jewelry') and (i_class = 'consignment') and 
i_item_sk is not null)
-                                                                               
   TableScan [TS_23] (rows=462000 width=1436)
-                                                                               
     
default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_sk","i_class","i_category"]
-                                                                          
<-Reducer 19 [SIMPLE_EDGE]
-                                                                            
SHUFFLE [RS_32]
-                                                                              
PartitionCols:_col2
-                                                                              
Merge Join Operator [MERGEJOIN_265] (rows=475191764 width=135)
-                                                                               
 Conds:Union 18._col0=RS_303._col0(Inner),Output:["_col1","_col2"]
-                                                                              
<-Map 24 [SIMPLE_EDGE] vectorized
-                                                                               
 PARTITION_ONLY_SHUFFLE [RS_303]
-                                                                               
   PartitionCols:_col0
-                                                                               
   Select Operator [SEL_302] (rows=18262 width=1119)
-                                                                               
     Output:["_col0"]
-                                                                               
     Filter Operator [FIL_301] (rows=18262 width=1119)
-                                                                               
       predicate:((d_moy = 3) and (d_year = 1999) and d_date_sk is not null)
-                                                                               
       TableScan [TS_20] (rows=73049 width=1119)
-                                                                               
         
default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_moy"]
-                                                                              
<-Union 18 [SIMPLE_EDGE]
-                                                                               
 <-Map 17 [CONTAINS] vectorized
-                                                                               
   Reduce Output Operator [RS_371]
-                                                                               
     PartitionCols:_col0
-                                                                               
     Select Operator [SEL_370] (rows=287989836 width=135)
-                                                                               
       Output:["_col0","_col1","_col2"]
-                                                                               
       Filter Operator [FIL_369] (rows=287989836 width=135)
-                                                                               
         predicate:((cs_bill_customer_sk BETWEEN 
DynamicValue(RS_36_customer_c_customer_sk_min) AND 
DynamicValue(RS_36_customer_c_customer_sk_max) and 
in_bloom_filter(cs_bill_customer_sk, 
DynamicValue(RS_36_customer_c_customer_sk_bloom_filter))) and (cs_item_sk 
BETWEEN DynamicValue(RS_33_item_i_item_sk_min) AND 
DynamicValue(RS_33_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, 
DynamicValue(RS_33_item_i_item_sk_bloom_filter))) and (cs_sold_date_sk BETWEEN 
DynamicValue(RS_30_date_dim_d_date_sk_min) AND 
DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) and cs_bill_customer_sk 
is not null and cs_item_sk is not null and cs_sold_date_sk is not null)
-                                                                               
         TableScan [TS_274] (rows=287989836 width=135)
-                                                                               
           Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk"]
-                                                                               
         <-Reducer 25 [BROADCAST_EDGE] vectorized
-                                                                               
           BROADCAST [RS_362]
-                                                                               
             Group By Operator [GBY_361] (rows=1 width=12)
-                                                                               
               
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
             <-Map 24 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
               PARTITION_ONLY_SHUFFLE [RS_306]
-                                                                               
                 Group By Operator [GBY_305] (rows=1 width=12)
-                                                                               
                   
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
                   Select Operator [SEL_304] (rows=18262 width=1119)
-                                                                               
                     Output:["_col0"]
-                                                                               
                      Please refer to the previous Select Operator [SEL_302]
-                                                                               
         <-Reducer 27 [BROADCAST_EDGE] vectorized
-                                                                               
           BROADCAST [RS_365]
-                                                                               
             Group By Operator [GBY_364] (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_312]
-                                                                               
                 Group By Operator [GBY_311] (rows=1 width=12)
-                                                                               
                   
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
                   Select Operator [SEL_310] (rows=115500 width=1436)
-                                                                               
                     Output:["_col0"]
-                                                                               
                      Please refer to the previous Select Operator [SEL_308]
-                                                                               
         <-Reducer 29 [BROADCAST_EDGE] vectorized
-                                                                               
           BROADCAST [RS_368]
-                                                                               
             Group By Operator [GBY_367] (rows=1 width=12)
-                                                                               
               
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=80000000)"]
-                                                                               
             <-Map 28 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
               PARTITION_ONLY_SHUFFLE [RS_318]
-                                                                               
                 Group By Operator [GBY_317] (rows=1 width=12)
-                                                                               
                   
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=80000000)"]
-                                                                               
                   Select Operator [SEL_316] (rows=80000000 width=860)
-                                                                               
                     Output:["_col0"]
-                                                                               
                      Please refer to the previous Select Operator [SEL_314]
-                                                                               
 <-Map 23 [CONTAINS] vectorized
-                                                                               
   Reduce Output Operator [RS_374]
-                                                                               
     PartitionCols:_col0
-                                                                               
     Select Operator [SEL_373] (rows=144002668 width=135)
-                                                                               
       Output:["_col0","_col1","_col2"]
-                                                                               
       Filter Operator [FIL_372] (rows=144002668 width=135)
-                                                                               
         predicate:((ws_item_sk BETWEEN DynamicValue(RS_33_item_i_item_sk_min) 
AND DynamicValue(RS_33_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_33_item_i_item_sk_bloom_filter))) and (ws_sold_date_sk BETWEEN 
DynamicValue(RS_30_date_dim_d_date_sk_min) AND 
DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) and ws_bill_customer_sk 
is not null and ws_item_sk is not null and ws_sold_date_sk is not null)
-                                                                               
         TableScan [TS_279] (rows=144002668 width=135)
-                                                                               
           Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk"]
-                                                                               
         <-Reducer 25 [BROADCAST_EDGE] vectorized
-                                                                               
           BROADCAST [RS_363]
-                                                                               
              Please refer to the previous Group By Operator [GBY_361]
-                                                                               
         <-Reducer 27 [BROADCAST_EDGE] vectorized
-                                                                               
           BROADCAST [RS_366]
-                                                                               
              Please refer to the previous Group By Operator [GBY_364]
-                                                      <-Reducer 2 [SIMPLE_EDGE]
-                                                        SHUFFLE [RS_76]
-                                                          PartitionCols:_col1
-                                                          Merge Join Operator 
[MERGEJOIN_263] (rows=633595212 width=88)
-                                                            
Conds:RS_294._col0=RS_286._col0(Inner),Output:["_col1","_col2","_col4"]
-                                                          <-Map 11 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_286]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_285] (rows=73049 width=1119)
-                                                                
Output:["_col0","_col1"]
-                                                                Filter 
Operator [FIL_284] (rows=73049 width=1119)
-                                                                  
predicate:d_date_sk is not null
-                                                                  TableScan 
[TS_3] (rows=73049 width=1119)
-                                                                    
default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_month_seq"]
-                                                          <-Map 1 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_294]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_293] (rows=575995635 width=88)
+                                                              Select Operator 
[SEL_331] (rows=575995635 width=88)
                                                                 
Output:["_col0","_col1","_col2"]
-                                                                Filter 
Operator [FIL_292] (rows=575995635 width=88)
-                                                                  
predicate:((ss_sold_date_sk BETWEEN DynamicValue(RS_74_date_dim_d_date_sk_min) 
AND DynamicValue(RS_74_date_dim_d_date_sk_max) and 
in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_74_date_dim_d_date_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_sold_date_sk is not null)
-                                                                  TableScan 
[TS_0] (rows=575995635 width=88)
+                                                                Filter 
Operator [FIL_330] (rows=575995635 width=88)
+                                                                  
predicate:((ss_customer_sk BETWEEN 
DynamicValue(RS_30_customer_c_customer_sk_min) AND 
DynamicValue(RS_30_customer_c_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_30_customer_c_customer_sk_bloom_filter))) and (ss_sold_date_sk 
BETWEEN DynamicValue(RS_79_date_dim_d_date_sk_min) AND 
DynamicValue(RS_79_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_79_date_dim_d_date_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_sold_date_sk is not null)
+                                                                  TableScan 
[TS_37] (rows=575995635 width=88)
                                                                     
default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_sales_price"]
-                                                                  <-Reducer 12 
[BROADCAST_EDGE] vectorized
-                                                                    BROADCAST 
[RS_291]
-                                                                      Group By 
Operator [GBY_290] (rows=1 width=12)
+                                                                  <-Reducer 26 
[BROADCAST_EDGE] vectorized
+                                                                    BROADCAST 
[RS_321]
+                                                                      Group By 
Operator [GBY_319] (rows=1 width=12)
+                                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=80000000)"]
+                                                                      <-Map 25 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                                        
PARTITION_ONLY_SHUFFLE [RS_315]
+                                                                          
Group By Operator [GBY_314] (rows=1 width=12)
+                                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=80000000)"]
+                                                                            
Select Operator [SEL_313] (rows=80000000 width=860)
+                                                                              
Output:["_col0"]
+                                                                              
Select Operator [SEL_311] (rows=80000000 width=860)
+                                                                               
 Output:["_col0","_col1"]
+                                                                               
 Filter Operator [FIL_310] (rows=80000000 width=860)
+                                                                               
   predicate:(c_current_addr_sk is not null and c_customer_sk is not null)
+                                                                               
   TableScan [TS_20] (rows=80000000 width=860)
+                                                                               
     
default@customer,customer,Tbl:COMPLETE,Col:NONE,Output:["c_customer_sk","c_current_addr_sk"]
+                                                                  <-Reducer 35 
[BROADCAST_EDGE] vectorized
+                                                                    BROADCAST 
[RS_329]
+                                                                      Group By 
Operator [GBY_328] (rows=1 width=12)
                                                                         
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                      <-Map 11 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                        
SHUFFLE [RS_289]
-                                                                          
Group By Operator [GBY_288] (rows=1 width=12)
+                                                                      <-Map 34 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                                        
SHUFFLE [RS_327]
+                                                                          
Group By Operator [GBY_326] (rows=1 width=12)
                                                                             
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                            
Select Operator [SEL_287] (rows=73049 width=1119)
+                                                                            
Select Operator [SEL_325] (rows=73049 width=1119)
                                                                               
Output:["_col0"]
-                                                                               
Please refer to the previous Select Operator [SEL_285]
-                                                  <-Reducer 32 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_340]
-                                                      Select Operator 
[SEL_339] (rows=1 width=8)
-                                                        Filter Operator 
[FIL_338] (rows=1 width=8)
-                                                          
predicate:(sq_count_check(_col0) <= 1)
-                                                          Group By Operator 
[GBY_337] (rows=1 width=8)
-                                                            
Output:["_col0"],aggregations:["count(VALUE._col0)"]
-                                                          <-Reducer 31 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                            
PARTITION_ONLY_SHUFFLE [RS_336]
-                                                              Group By 
Operator [GBY_335] (rows=1 width=8)
-                                                                
Output:["_col0"],aggregations:["count()"]
-                                                                Select 
Operator [SEL_333] (rows=9131 width=1119)
-                                                                   Please 
refer to the previous Group By Operator [GBY_332]
+                                                                               
Please refer to the previous Select Operator [SEL_323]
+                                                          <-Reducer 3 
[SIMPLE_EDGE]
+                                                            SHUFFLE [RS_72]
+                                                              
PartitionCols:_col5
+                                                              Merge Join 
Operator [MERGEJOIN_275] (rows=316240138 width=135)
+                                                                
Conds:RS_69._col0=RS_318._col1(Inner),Output:["_col5"]
+                                                              <-Reducer 19 
[SIMPLE_EDGE] vectorized
+                                                                SHUFFLE 
[RS_318]
+                                                                  
PartitionCols:_col1
+                                                                  Select 
Operator [SEL_317] (rows=287491029 width=135)
+                                                                    
Output:["_col0","_col1"]
+                                                                    Group By 
Operator [GBY_316] (rows=287491029 width=135)
+                                                                      
Output:["_col0","_col1"],keys:KEY._col0, KEY._col1
+                                                                    <-Reducer 
18 [SIMPLE_EDGE]
+                                                                      SHUFFLE 
[RS_34]
+                                                                        
PartitionCols:_col0, _col1
+                                                                        Group 
By Operator [GBY_33] (rows=574982058 width=135)
+                                                                          
Output:["_col0","_col1"],keys:_col10, _col9
+                                                                          
Merge Join Operator [MERGEJOIN_274] (rows=574982058 width=135)
+                                                                            
Conds:RS_29._col1=RS_312._col0(Inner),Output:["_col9","_col10"]
+                                                                          
<-Map 25 [SIMPLE_EDGE] vectorized
+                                                                            
PARTITION_ONLY_SHUFFLE [RS_312]
+                                                                              
PartitionCols:_col0
+                                                                               
Please refer to the previous Select Operator [SEL_311]
+                                                                          
<-Reducer 17 [SIMPLE_EDGE]
+                                                                            
SHUFFLE [RS_29]
+                                                                              
PartitionCols:_col1
+                                                                              
Merge Join Operator [MERGEJOIN_273] (rows=522710951 width=135)
+                                                                               
 Conds:RS_26._col2=RS_306._col0(Inner),Output:["_col1"]
+                                                                              
<-Map 23 [SIMPLE_EDGE] vectorized
+                                                                               
 PARTITION_ONLY_SHUFFLE [RS_306]
+                                                                               
   PartitionCols:_col0
+                                                                               
   Select Operator [SEL_305] (rows=115500 width=1436)
+                                                                               
     Output:["_col0"]
+                                                                               
     Filter Operator [FIL_304] (rows=115500 width=1436)
+                                                                               
       predicate:((i_category = 'Jewelry') and (i_class = 'consignment') and 
i_item_sk is not null)
+                                                                               
       TableScan [TS_17] (rows=462000 width=1436)
+                                                                               
         
default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_sk","i_class","i_category"]
+                                                                              
<-Reducer 16 [SIMPLE_EDGE]
+                                                                               
 SHUFFLE [RS_26]
+                                                                               
   PartitionCols:_col2
+                                                                               
   Merge Join Operator [MERGEJOIN_272] (rows=475191764 width=135)
+                                                                               
     Conds:Union 15._col0=RS_300._col0(Inner),Output:["_col1","_col2"]
+                                                                               
   <-Map 21 [SIMPLE_EDGE] vectorized
+                                                                               
     PARTITION_ONLY_SHUFFLE [RS_300]
+                                                                               
       PartitionCols:_col0
+                                                                               
       Select Operator [SEL_299] (rows=18262 width=1119)
+                                                                               
         Output:["_col0"]
+                                                                               
         Filter Operator [FIL_298] (rows=18262 width=1119)
+                                                                               
           predicate:((d_moy = 3) and (d_year = 1999) and d_date_sk is not null)
+                                                                               
           TableScan [TS_14] (rows=73049 width=1119)
+                                                                               
             
default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_moy"]
+                                                                               
   <-Union 15 [SIMPLE_EDGE]
+                                                                               
     <-Map 14 [CONTAINS] vectorized
+                                                                               
       Reduce Output Operator [RS_380]
+                                                                               
         PartitionCols:_col0
+                                                                               
         Select Operator [SEL_379] (rows=287989836 width=135)
+                                                                               
           Output:["_col0","_col1","_col2"]
+                                                                               
           Filter Operator [FIL_378] (rows=287989836 width=135)
+                                                                               
             predicate:((cs_bill_customer_sk BETWEEN 
DynamicValue(RS_30_customer_c_customer_sk_min) AND 
DynamicValue(RS_30_customer_c_customer_sk_max) and 
in_bloom_filter(cs_bill_customer_sk, 
DynamicValue(RS_30_customer_c_customer_sk_bloom_filter))) and (cs_item_sk 
BETWEEN DynamicValue(RS_27_item_i_item_sk_min) AND 
DynamicValue(RS_27_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, 
DynamicValue(RS_27_item_i_item_sk_bloom_filter))) and (cs_sold_date_sk BETWEEN 
DynamicValue(RS_24_date_dim_d_date_sk_min) AND 
DynamicValue(RS_24_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_24_date_dim_d_date_sk_bloom_filter))) and cs_bill_customer_sk 
is not null and cs_item_sk is not null and cs_sold_date_sk is not null)
+                                                                               
             TableScan [TS_282] (rows=287989836 width=135)
+                                                                               
               Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk"]
+                                                                               
             <-Reducer 22 [BROADCAST_EDGE] vectorized
+                                                                               
               BROADCAST [RS_373]
+                                                                               
                 Group By Operator [GBY_372] (rows=1 width=12)
+                                                                               
                   
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
+                                                                               
                 <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized
+                                                                               
                   PARTITION_ONLY_SHUFFLE [RS_303]
+                                                                               
                     Group By Operator [GBY_302] (rows=1 width=12)
+                                                                               
                       
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
+                                                                               
                       Select Operator [SEL_301] (rows=18262 width=1119)
+                                                                               
                         Output:["_col0"]
+                                                                               
                          Please refer to the previous Select Operator [SEL_299]
+                                                                               
             <-Reducer 24 [BROADCAST_EDGE] vectorized
+                                                                               
               BROADCAST [RS_376]
+                                                                               
                 Group By Operator [GBY_375] (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_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=115500 width=1436)
+                                                                               
                         Output:["_col0"]
+                                                                               
                          Please refer to the previous Select Operator [SEL_305]
+                                                                               
             <-Reducer 26 [BROADCAST_EDGE] vectorized
+                                                                               
               BROADCAST [RS_320]
+                                                                               
                  Please refer to the previous Group By Operator [GBY_319]
+                                                                               
     <-Map 20 [CONTAINS] vectorized
+                                                                               
       Reduce Output Operator [RS_383]
+                                                                               
         PartitionCols:_col0
+                                                                               
         Select Operator [SEL_382] (rows=144002668 width=135)
+                                                                               
           Output:["_col0","_col1","_col2"]
+                                                                               
           Filter Operator [FIL_381] (rows=144002668 width=135)
+                                                                               
             predicate:((ws_item_sk BETWEEN 
DynamicValue(RS_27_item_i_item_sk_min) AND 
DynamicValue(RS_27_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_27_item_i_item_sk_bloom_filter))) and (ws_sold_date_sk BETWEEN 
DynamicValue(RS_24_date_dim_d_date_sk_min) AND 
DynamicValue(RS_24_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_24_date_dim_d_date_sk_bloom_filter))) and ws_bill_customer_sk 
is not null and ws_item_sk is not null and ws_sold_date_sk is not null)
+                                                                               
             TableScan [TS_287] (rows=144002668 width=135)
+                                                                               
               Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk"]
+                                                                               
             <-Reducer 22 [BROADCAST_EDGE] vectorized
+                                                                               
               BROADCAST [RS_374]
+                                                                               
                  Please refer to the previous Group By Operator [GBY_372]
+                                                                               
             <-Reducer 24 [BROADCAST_EDGE] vectorized
+                                                                               
               BROADCAST [RS_377]
+                                                                               
                  Please refer to the previous Group By Operator [GBY_375]
+                                                              <-Reducer 2 
[SIMPLE_EDGE]
+                                                                SHUFFLE [RS_69]
+                                                                  
PartitionCols:_col0
+                                                                  Merge Join 
Operator [MERGEJOIN_271] (rows=44000000 width=1014)
+                                                                    
Conds:RS_294._col1, _col2=RS_297._col0, _col1(Inner),Output:["_col0"]
+                                                                  <-Map 1 
[SIMPLE_EDGE] vectorized
+                                                                    SHUFFLE 
[RS_294]
+                                                                      
PartitionCols:_col1, _col2
+                                                                      Select 
Operator [SEL_293] (rows=40000000 width=1014)
+                                                                        
Output:["_col0","_col1","_col2"]
+                                                                        Filter 
Operator [FIL_292] (rows=40000000 width=1014)
+                                                                          
predicate:(ca_address_sk is not null and ca_county is not null and ca_state is 
not null)
+                                                                          
TableScan [TS_0] (rows=40000000 width=1014)
+                                                                            
default@customer_address,customer_address,Tbl:COMPLETE,Col:NONE,Output:["ca_address_sk","ca_county","ca_state"]
+                                                                  <-Map 13 
[SIMPLE_EDGE] vectorized
+                                                                    SHUFFLE 
[RS_297]
+                                                                      
PartitionCols:_col0, _col1
+                                                                      Select 
Operator [SEL_296] (rows=1704 width=1910)
+                                                                        
Output:["_col0","_col1"]
+                                                                        Filter 
Operator [FIL_295] (rows=1704 width=1910)
+                                                                          
predicate:(s_county is not null and s_state is not null)
+                                                                          
TableScan [TS_3] (rows=1704 width=1910)
+                                                                            
default@store,store,Tbl:COMPLETE,Col:NONE,Output:["s_county","s_state"]
 

Reply via email to