http://git-wip-us.apache.org/repos/asf/hive/blob/c7b5454a/ql/src/test/results/clientpositive/perf/tez/query14.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/perf/tez/query14.q.out 
b/ql/src/test/results/clientpositive/perf/tez/query14.q.out
index a65632d..fd8eb9b 100644
--- a/ql/src/test/results/clientpositive/perf/tez/query14.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/query14.q.out
@@ -1,9 +1,6 @@
-Warning: Shuffle Join MERGEJOIN[1440][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 5' is a cross product
-Warning: Shuffle Join MERGEJOIN[1452][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 6' is a cross product
-Warning: Shuffle Join MERGEJOIN[1442][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 13' is a cross product
-Warning: Shuffle Join MERGEJOIN[1465][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 14' is a cross product
-Warning: Shuffle Join MERGEJOIN[1444][tables = [$hdt$_2, $hdt$_3]] in Stage 
'Reducer 18' is a cross product
-Warning: Shuffle Join MERGEJOIN[1478][tables = [$hdt$_2, $hdt$_3, $hdt$_1]] in 
Stage 'Reducer 19' is a cross product
+Warning: Shuffle Join MERGEJOIN[1164][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 6' is a cross product
+Warning: Shuffle Join MERGEJOIN[1171][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 16' is a cross product
+Warning: Shuffle Join MERGEJOIN[1178][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 22' is a cross product
 PREHOOK: query: explain
 with  cross_items as
  (select i_item_sk ss_item_sk
@@ -225,1116 +222,840 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 99 (BROADCAST_EDGE)
-Map 101 <- Reducer 96 (BROADCAST_EDGE)
-Map 102 <- Reducer 98 (BROADCAST_EDGE)
-Map 103 <- Reducer 63 (BROADCAST_EDGE)
-Map 104 <- Reducer 68 (BROADCAST_EDGE)
-Map 20 <- Reducer 25 (BROADCAST_EDGE)
-Map 36 <- Reducer 41 (BROADCAST_EDGE)
-Map 46 <- Reducer 100 (BROADCAST_EDGE)
-Map 50 <- Reducer 29 (BROADCAST_EDGE)
-Map 51 <- Reducer 43 (BROADCAST_EDGE)
-Map 52 <- Reducer 58 (BROADCAST_EDGE)
-Map 91 <- Reducer 94 (BROADCAST_EDGE)
-Reducer 10 <- Map 1 (SIMPLE_EDGE), Map 93 (SIMPLE_EDGE), Union 11 (CONTAINS)
-Reducer 100 <- Map 93 (CUSTOM_SIMPLE_EDGE)
-Reducer 12 <- Union 11 (CUSTOM_SIMPLE_EDGE)
-Reducer 13 <- Reducer 12 (CUSTOM_SIMPLE_EDGE), Reducer 32 (CUSTOM_SIMPLE_EDGE)
-Reducer 14 <- Reducer 13 (CUSTOM_SIMPLE_EDGE), Reducer 62 
(CUSTOM_SIMPLE_EDGE), Union 7 (CONTAINS)
-Reducer 15 <- Map 1 (SIMPLE_EDGE), Map 93 (SIMPLE_EDGE), Union 16 (CONTAINS)
-Reducer 17 <- Union 16 (CUSTOM_SIMPLE_EDGE)
-Reducer 18 <- Reducer 17 (CUSTOM_SIMPLE_EDGE), Reducer 35 (CUSTOM_SIMPLE_EDGE)
-Reducer 19 <- Reducer 18 (CUSTOM_SIMPLE_EDGE), Reducer 67 
(CUSTOM_SIMPLE_EDGE), Union 7 (CONTAINS)
-Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 93 (SIMPLE_EDGE), Union 3 (CONTAINS)
-Reducer 21 <- Map 20 (SIMPLE_EDGE), Map 24 (SIMPLE_EDGE), Union 3 (CONTAINS)
-Reducer 22 <- Map 20 (SIMPLE_EDGE), Map 24 (SIMPLE_EDGE), Union 11 (CONTAINS)
-Reducer 23 <- Map 20 (SIMPLE_EDGE), Map 24 (SIMPLE_EDGE), Union 16 (CONTAINS)
-Reducer 25 <- Map 24 (CUSTOM_SIMPLE_EDGE)
-Reducer 26 <- Map 24 (SIMPLE_EDGE), Map 50 (SIMPLE_EDGE), Union 27 (CONTAINS)
-Reducer 28 <- Union 27 (CUSTOM_SIMPLE_EDGE)
-Reducer 29 <- Map 24 (CUSTOM_SIMPLE_EDGE)
-Reducer 30 <- Map 24 (SIMPLE_EDGE), Map 50 (SIMPLE_EDGE), Union 31 (CONTAINS)
-Reducer 32 <- Union 31 (CUSTOM_SIMPLE_EDGE)
-Reducer 33 <- Map 24 (SIMPLE_EDGE), Map 50 (SIMPLE_EDGE), Union 34 (CONTAINS)
-Reducer 35 <- Union 34 (CUSTOM_SIMPLE_EDGE)
-Reducer 37 <- Map 36 (SIMPLE_EDGE), Map 40 (SIMPLE_EDGE), Union 3 (CONTAINS)
-Reducer 38 <- Map 36 (SIMPLE_EDGE), Map 40 (SIMPLE_EDGE), Union 11 (CONTAINS)
-Reducer 39 <- Map 36 (SIMPLE_EDGE), Map 40 (SIMPLE_EDGE), Union 16 (CONTAINS)
-Reducer 4 <- Union 3 (CUSTOM_SIMPLE_EDGE)
-Reducer 41 <- Map 40 (CUSTOM_SIMPLE_EDGE)
-Reducer 42 <- Map 40 (SIMPLE_EDGE), Map 51 (SIMPLE_EDGE), Union 27 (CONTAINS)
-Reducer 43 <- Map 40 (CUSTOM_SIMPLE_EDGE)
-Reducer 44 <- Map 40 (SIMPLE_EDGE), Map 51 (SIMPLE_EDGE), Union 31 (CONTAINS)
-Reducer 45 <- Map 40 (SIMPLE_EDGE), Map 51 (SIMPLE_EDGE), Union 34 (CONTAINS)
-Reducer 47 <- Map 46 (SIMPLE_EDGE), Map 93 (SIMPLE_EDGE), Union 27 (CONTAINS)
-Reducer 48 <- Map 46 (SIMPLE_EDGE), Map 93 (SIMPLE_EDGE), Union 31 (CONTAINS)
-Reducer 49 <- Map 46 (SIMPLE_EDGE), Map 93 (SIMPLE_EDGE), Union 34 (CONTAINS)
-Reducer 5 <- Reducer 28 (CUSTOM_SIMPLE_EDGE), Reducer 4 (CUSTOM_SIMPLE_EDGE)
-Reducer 53 <- Map 52 (SIMPLE_EDGE), Map 57 (SIMPLE_EDGE)
-Reducer 54 <- Map 69 (SIMPLE_EDGE), Reducer 53 (SIMPLE_EDGE)
-Reducer 55 <- Reducer 54 (ONE_TO_ONE_EDGE), Reducer 70 (SIMPLE_EDGE)
-Reducer 56 <- Reducer 55 (SIMPLE_EDGE)
-Reducer 58 <- Map 57 (CUSTOM_SIMPLE_EDGE)
-Reducer 59 <- Map 103 (SIMPLE_EDGE), Map 57 (SIMPLE_EDGE)
+Map 1 <- Reducer 11 (BROADCAST_EDGE)
+Map 46 <- Reducer 49 (BROADCAST_EDGE)
+Map 64 <- Reducer 51 (BROADCAST_EDGE)
+Map 65 <- Reducer 53 (BROADCAST_EDGE)
+Map 66 <- Reducer 57 (BROADCAST_EDGE)
+Map 67 <- Reducer 72 (BROADCAST_EDGE)
+Map 73 <- Reducer 78 (BROADCAST_EDGE)
+Map 79 <- Reducer 17 (BROADCAST_EDGE)
+Map 80 <- Reducer 23 (BROADCAST_EDGE)
+Reducer 11 <- Map 10 (CUSTOM_SIMPLE_EDGE)
+Reducer 12 <- Map 10 (SIMPLE_EDGE), Map 79 (SIMPLE_EDGE)
+Reducer 13 <- Map 24 (SIMPLE_EDGE), Reducer 12 (SIMPLE_EDGE)
+Reducer 14 <- Reducer 13 (ONE_TO_ONE_EDGE), Reducer 33 (SIMPLE_EDGE)
+Reducer 15 <- Reducer 14 (SIMPLE_EDGE)
+Reducer 16 <- Reducer 15 (CUSTOM_SIMPLE_EDGE), Reducer 60 
(CUSTOM_SIMPLE_EDGE), Union 7 (CONTAINS)
+Reducer 17 <- Map 10 (CUSTOM_SIMPLE_EDGE)
+Reducer 18 <- Map 10 (SIMPLE_EDGE), Map 80 (SIMPLE_EDGE)
+Reducer 19 <- Map 24 (SIMPLE_EDGE), Reducer 18 (SIMPLE_EDGE)
+Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE)
+Reducer 20 <- Reducer 19 (ONE_TO_ONE_EDGE), Reducer 37 (SIMPLE_EDGE)
+Reducer 21 <- Reducer 20 (SIMPLE_EDGE)
+Reducer 22 <- Reducer 21 (CUSTOM_SIMPLE_EDGE), Reducer 63 
(CUSTOM_SIMPLE_EDGE), Union 7 (CONTAINS)
+Reducer 23 <- Map 10 (CUSTOM_SIMPLE_EDGE)
+Reducer 25 <- Map 24 (SIMPLE_EDGE), Reducer 29 (ONE_TO_ONE_EDGE)
+Reducer 26 <- Map 24 (SIMPLE_EDGE), Reducer 47 (SIMPLE_EDGE)
+Reducer 27 <- Reducer 26 (SIMPLE_EDGE), Union 28 (CONTAINS)
+Reducer 29 <- Union 28 (SIMPLE_EDGE)
+Reducer 3 <- Map 24 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
+Reducer 30 <- Reducer 26 (SIMPLE_EDGE), Union 31 (CONTAINS)
+Reducer 32 <- Union 31 (SIMPLE_EDGE)
+Reducer 33 <- Map 24 (SIMPLE_EDGE), Reducer 32 (ONE_TO_ONE_EDGE)
+Reducer 34 <- Reducer 26 (SIMPLE_EDGE), Union 35 (CONTAINS)
+Reducer 36 <- Union 35 (SIMPLE_EDGE)
+Reducer 37 <- Map 24 (SIMPLE_EDGE), Reducer 36 (ONE_TO_ONE_EDGE)
+Reducer 38 <- Map 24 (SIMPLE_EDGE), Reducer 50 (SIMPLE_EDGE)
+Reducer 39 <- Reducer 38 (SIMPLE_EDGE), Union 28 (CONTAINS)
+Reducer 4 <- Reducer 25 (SIMPLE_EDGE), Reducer 3 (ONE_TO_ONE_EDGE)
+Reducer 40 <- Reducer 38 (SIMPLE_EDGE), Union 31 (CONTAINS)
+Reducer 41 <- Reducer 38 (SIMPLE_EDGE), Union 35 (CONTAINS)
+Reducer 42 <- Map 24 (SIMPLE_EDGE), Reducer 52 (SIMPLE_EDGE)
+Reducer 43 <- Reducer 42 (SIMPLE_EDGE), Union 28 (CONTAINS)
+Reducer 44 <- Reducer 42 (SIMPLE_EDGE), Union 31 (CONTAINS)
+Reducer 45 <- Reducer 42 (SIMPLE_EDGE), Union 35 (CONTAINS)
+Reducer 47 <- Map 46 (SIMPLE_EDGE), Map 48 (SIMPLE_EDGE)
+Reducer 49 <- Map 48 (CUSTOM_SIMPLE_EDGE)
+Reducer 5 <- Reducer 4 (SIMPLE_EDGE)
+Reducer 50 <- Map 48 (SIMPLE_EDGE), Map 64 (SIMPLE_EDGE)
+Reducer 51 <- Map 48 (CUSTOM_SIMPLE_EDGE)
+Reducer 52 <- Map 48 (SIMPLE_EDGE), Map 65 (SIMPLE_EDGE)
+Reducer 53 <- Map 48 (CUSTOM_SIMPLE_EDGE)
+Reducer 54 <- Map 48 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE), Union 55 (CONTAINS)
+Reducer 56 <- Union 55 (CUSTOM_SIMPLE_EDGE)
+Reducer 57 <- Map 48 (CUSTOM_SIMPLE_EDGE)
+Reducer 58 <- Map 48 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE), Union 59 (CONTAINS)
 Reducer 6 <- Reducer 5 (CUSTOM_SIMPLE_EDGE), Reducer 56 (CUSTOM_SIMPLE_EDGE), 
Union 7 (CONTAINS)
-Reducer 60 <- Map 69 (SIMPLE_EDGE), Reducer 59 (SIMPLE_EDGE)
-Reducer 61 <- Reducer 60 (ONE_TO_ONE_EDGE), Reducer 78 (SIMPLE_EDGE)
-Reducer 62 <- Reducer 61 (SIMPLE_EDGE)
-Reducer 63 <- Map 57 (CUSTOM_SIMPLE_EDGE)
-Reducer 64 <- Map 104 (SIMPLE_EDGE), Map 57 (SIMPLE_EDGE)
-Reducer 65 <- Map 69 (SIMPLE_EDGE), Reducer 64 (SIMPLE_EDGE)
-Reducer 66 <- Reducer 65 (ONE_TO_ONE_EDGE), Reducer 82 (SIMPLE_EDGE)
-Reducer 67 <- Reducer 66 (SIMPLE_EDGE)
-Reducer 68 <- Map 57 (CUSTOM_SIMPLE_EDGE)
-Reducer 70 <- Map 69 (SIMPLE_EDGE), Reducer 74 (ONE_TO_ONE_EDGE)
-Reducer 71 <- Map 69 (SIMPLE_EDGE), Reducer 92 (SIMPLE_EDGE)
-Reducer 72 <- Reducer 71 (SIMPLE_EDGE), Union 73 (CONTAINS)
-Reducer 74 <- Union 73 (SIMPLE_EDGE)
-Reducer 75 <- Reducer 71 (SIMPLE_EDGE), Union 76 (CONTAINS)
-Reducer 77 <- Union 76 (SIMPLE_EDGE)
-Reducer 78 <- Map 69 (SIMPLE_EDGE), Reducer 77 (ONE_TO_ONE_EDGE)
-Reducer 79 <- Reducer 71 (SIMPLE_EDGE), Union 80 (CONTAINS)
+Reducer 60 <- Union 59 (CUSTOM_SIMPLE_EDGE)
+Reducer 61 <- Map 48 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE), Union 62 (CONTAINS)
+Reducer 63 <- Union 62 (CUSTOM_SIMPLE_EDGE)
+Reducer 68 <- Map 67 (SIMPLE_EDGE), Map 71 (SIMPLE_EDGE), Union 55 (CONTAINS)
+Reducer 69 <- Map 67 (SIMPLE_EDGE), Map 71 (SIMPLE_EDGE), Union 59 (CONTAINS)
+Reducer 70 <- Map 67 (SIMPLE_EDGE), Map 71 (SIMPLE_EDGE), Union 62 (CONTAINS)
+Reducer 72 <- Map 71 (CUSTOM_SIMPLE_EDGE)
+Reducer 74 <- Map 73 (SIMPLE_EDGE), Map 77 (SIMPLE_EDGE), Union 55 (CONTAINS)
+Reducer 75 <- Map 73 (SIMPLE_EDGE), Map 77 (SIMPLE_EDGE), Union 59 (CONTAINS)
+Reducer 76 <- Map 73 (SIMPLE_EDGE), Map 77 (SIMPLE_EDGE), Union 62 (CONTAINS)
+Reducer 78 <- Map 77 (CUSTOM_SIMPLE_EDGE)
 Reducer 8 <- Union 7 (SIMPLE_EDGE)
-Reducer 81 <- Union 80 (SIMPLE_EDGE)
-Reducer 82 <- Map 69 (SIMPLE_EDGE), Reducer 81 (ONE_TO_ONE_EDGE)
-Reducer 83 <- Map 69 (SIMPLE_EDGE), Reducer 95 (SIMPLE_EDGE)
-Reducer 84 <- Reducer 83 (SIMPLE_EDGE), Union 73 (CONTAINS)
-Reducer 85 <- Reducer 83 (SIMPLE_EDGE), Union 76 (CONTAINS)
-Reducer 86 <- Reducer 83 (SIMPLE_EDGE), Union 80 (CONTAINS)
-Reducer 87 <- Map 69 (SIMPLE_EDGE), Reducer 97 (SIMPLE_EDGE)
-Reducer 88 <- Reducer 87 (SIMPLE_EDGE), Union 73 (CONTAINS)
-Reducer 89 <- Reducer 87 (SIMPLE_EDGE), Union 76 (CONTAINS)
 Reducer 9 <- Reducer 8 (SIMPLE_EDGE)
-Reducer 90 <- Reducer 87 (SIMPLE_EDGE), Union 80 (CONTAINS)
-Reducer 92 <- Map 91 (SIMPLE_EDGE), Map 93 (SIMPLE_EDGE)
-Reducer 94 <- Map 93 (CUSTOM_SIMPLE_EDGE)
-Reducer 95 <- Map 101 (SIMPLE_EDGE), Map 93 (SIMPLE_EDGE)
-Reducer 96 <- Map 93 (CUSTOM_SIMPLE_EDGE)
-Reducer 97 <- Map 102 (SIMPLE_EDGE), Map 93 (SIMPLE_EDGE)
-Reducer 98 <- Map 93 (CUSTOM_SIMPLE_EDGE)
-Reducer 99 <- Map 93 (CUSTOM_SIMPLE_EDGE)
 
 Stage-0
   Fetch Operator
     limit:100
     Stage-1
       Reducer 9 vectorized
-      File Output Operator [FS_1710]
-        Limit [LIM_1709] (rows=7 width=192)
+      File Output Operator [FS_1335]
+        Limit [LIM_1334] (rows=7 width=192)
           Number of rows:100
-          Select Operator [SEL_1708] (rows=7 width=192)
+          Select Operator [SEL_1333] (rows=7 width=192)
             Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
           <-Reducer 8 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_1707]
-              Select Operator [SEL_1706] (rows=7 width=192)
+            SHUFFLE [RS_1332]
+              Select Operator [SEL_1331] (rows=7 width=192)
                 Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
-                Group By Operator [GBY_1705] (rows=7 width=200)
+                Group By Operator [GBY_1330] (rows=7 width=200)
                   
Output:["_col0","_col1","_col2","_col3","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0,
 KEY._col1, KEY._col2, KEY._col3, KEY._col4
                 <-Union 7 [SIMPLE_EDGE]
-                  <-Reducer 14 [CONTAINS]
-                    Reduce Output Operator [RS_1471]
+                  <-Reducer 16 [CONTAINS]
+                    Reduce Output Operator [RS_1177]
                       PartitionCols:_col0, _col1, _col2, _col3, _col4
-                      Group By Operator [GBY_1470] (rows=7 width=200)
+                      Group By Operator [GBY_1176] (rows=7 width=200)
                         
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0,
 _col1, _col2, _col3, 0L
-                        Top N Key Operator [TNK_1469] (rows=3 width=221)
+                        Top N Key Operator [TNK_1175] (rows=3 width=221)
                           keys:_col0, _col1, _col2, _col3, 0L,sort 
order:+++++,top n:100
-                          Select Operator [SEL_1467] (rows=1 width=223)
+                          Select Operator [SEL_1173] (rows=1 width=223)
                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
-                            Filter Operator [FIL_1466] (rows=1 width=244)
-                              predicate:(_col5 > _col1)
-                              Merge Join Operator [MERGEJOIN_1465] (rows=1 
width=244)
-                                
Conds:(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6"]
-                              <-Reducer 13 [CUSTOM_SIMPLE_EDGE]
-                                PARTITION_ONLY_SHUFFLE [RS_377]
-                                  Merge Join Operator [MERGEJOIN_1442] (rows=1 
width=112)
-                                    Conds:(Inner),Output:["_col1"]
-                                  <-Reducer 12 [CUSTOM_SIMPLE_EDGE] vectorized
-                                    PARTITION_ONLY_SHUFFLE [RS_1716]
-                                      Select Operator [SEL_1715] (rows=1 
width=8)
-                                        Filter Operator [FIL_1714] (rows=1 
width=8)
-                                          predicate:(sq_count_check(_col0) <= 
1)
-                                          Group By Operator [GBY_1713] (rows=1 
width=8)
-                                            
Output:["_col0"],aggregations:["count()"]
-                                            Select Operator [SEL_1712] (rows=1 
width=8)
-                                              Group By Operator [GBY_1711] 
(rows=1 width=8)
-                                                
Output:["_col0"],aggregations:["count(VALUE._col0)"]
-                                              <-Union 11 [CUSTOM_SIMPLE_EDGE]
-                                                <-Reducer 10 [CONTAINS]
-                                                  Reduce Output Operator 
[RS_1464]
-                                                    Group By Operator 
[GBY_1463] (rows=1 width=8)
-                                                      
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_1462] (rows=26270325 width=1)
-                                                        Output:["_col0"]
-                                                        Select Operator 
[SEL_1460] (rows=14736682 width=0)
-                                                          Output:["_col0"]
-                                                          Merge Join Operator 
[MERGEJOIN_1459] (rows=14736682 width=0)
-                                                            
Conds:RS_1642._col0=RS_1623._col0(Inner),Output:["_col1"]
-                                                          <-Map 93 
[SIMPLE_EDGE] vectorized
-                                                            
PARTITION_ONLY_SHUFFLE [RS_1623]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1612] (rows=1957 width=4)
-                                                                
Output:["_col0"]
-                                                                Filter 
Operator [FIL_1611] (rows=1957 width=8)
-                                                                  
predicate:(d_date_sk is not null and d_year BETWEEN 1999 AND 2001)
-                                                                  TableScan 
[TS_97] (rows=73049 width=8)
-                                                                    
default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"]
-                                                          <-Map 1 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_1642]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1640] (rows=550076554 width=7)
-                                                                
Output:["_col0","_col1"]
-                                                                Filter 
Operator [FIL_1639] (rows=550076554 width=7)
-                                                                  
predicate:((ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) 
AND DynamicValue(RS_7_date_dim_d_date_sk_max) and 
in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) and ss_sold_date_sk is not 
null)
-                                                                  TableScan 
[TS_0] (rows=575995635 width=7)
-                                                                    
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_quantity"]
-                                                                  <-Reducer 99 
[BROADCAST_EDGE] vectorized
-                                                                    BROADCAST 
[RS_1638]
-                                                                      Group By 
Operator [GBY_1637] (rows=1 width=12)
-                                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                      <-Map 93 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                        
PARTITION_ONLY_SHUFFLE [RS_1635]
-                                                                          
Group By Operator [GBY_1630] (rows=1 width=12)
-                                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                            
Select Operator [SEL_1620] (rows=1957 width=4)
-                                                                              
Output:["_col0"]
-                                                                               
Please refer to the previous Select Operator [SEL_1612]
-                                                <-Reducer 22 [CONTAINS]
-                                                  Reduce Output Operator 
[RS_1496]
-                                                    Group By Operator 
[GBY_1495] (rows=1 width=8)
-                                                      
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_1494] (rows=26270325 width=1)
-                                                        Output:["_col0"]
-                                                        Select Operator 
[SEL_1492] (rows=7676736 width=3)
-                                                          Output:["_col0"]
-                                                          Merge Join Operator 
[MERGEJOIN_1491] (rows=7676736 width=3)
-                                                            
Conds:RS_1770._col0=RS_1757._col0(Inner),Output:["_col1"]
-                                                          <-Map 24 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_1757]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1752] (rows=1957 width=4)
-                                                                
Output:["_col0"]
-                                                                Filter 
Operator [FIL_1751] (rows=1957 width=8)
-                                                                  
predicate:(d_date_sk is not null and d_year BETWEEN 1998 AND 2000)
-                                                                  TableScan 
[TS_13] (rows=73049 width=8)
-                                                                    
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"]
-                                                          <-Map 20 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_1770]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1768] (rows=286549727 width=7)
-                                                                
Output:["_col0","_col1"]
-                                                                Filter 
Operator [FIL_1767] (rows=286549727 width=7)
-                                                                  
predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_17_date_dim_d_date_sk_min) 
AND DynamicValue(RS_17_date_dim_d_date_sk_max) and 
in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_17_date_dim_d_date_sk_bloom_filter))) and cs_sold_date_sk is 
not null)
-                                                                  TableScan 
[TS_10] (rows=287989836 width=7)
-                                                                    
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_quantity"]
-                                                                  <-Reducer 25 
[BROADCAST_EDGE] vectorized
-                                                                    BROADCAST 
[RS_1766]
-                                                                      Group By 
Operator [GBY_1765] (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
-                                                                        
SHUFFLE [RS_1763]
-                                                                          
Group By Operator [GBY_1761] (rows=1 width=12)
-                                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                            
Select Operator [SEL_1754] (rows=1957 width=4)
-                                                                              
Output:["_col0"]
-                                                                               
Please refer to the previous Select Operator [SEL_1752]
-                                                <-Reducer 38 [CONTAINS]
-                                                  Reduce Output Operator 
[RS_1532]
-                                                    Group By Operator 
[GBY_1531] (rows=1 width=8)
-                                                      
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_1530] (rows=26270325 width=1)
-                                                        Output:["_col0"]
-                                                        Select Operator 
[SEL_1528] (rows=3856907 width=3)
-                                                          Output:["_col0"]
-                                                          Merge Join Operator 
[MERGEJOIN_1527] (rows=3856907 width=3)
-                                                            
Conds:RS_1798._col0=RS_1785._col0(Inner),Output:["_col1"]
-                                                          <-Map 40 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_1785]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1780] (rows=1957 width=4)
-                                                                
Output:["_col0"]
-                                                                Filter 
Operator [FIL_1779] (rows=1957 width=8)
-                                                                  
predicate:(d_date_sk is not null and d_year BETWEEN 1998 AND 2000)
-                                                                  TableScan 
[TS_24] (rows=73049 width=8)
-                                                                    
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"]
-                                                          <-Map 36 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_1798]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1796] (rows=143966864 width=7)
-                                                                
Output:["_col0","_col1"]
-                                                                Filter 
Operator [FIL_1795] (rows=143966864 width=7)
-                                                                  
predicate:((ws_sold_date_sk BETWEEN DynamicValue(RS_28_date_dim_d_date_sk_min) 
AND DynamicValue(RS_28_date_dim_d_date_sk_max) and 
in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_28_date_dim_d_date_sk_bloom_filter))) and ws_sold_date_sk is 
not null)
-                                                                  TableScan 
[TS_21] (rows=144002668 width=7)
-                                                                    
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_quantity"]
-                                                                  <-Reducer 41 
[BROADCAST_EDGE] vectorized
-                                                                    BROADCAST 
[RS_1794]
-                                                                      Group By 
Operator [GBY_1793] (rows=1 width=12)
-                                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                      <-Map 40 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                        
SHUFFLE [RS_1791]
-                                                                          
Group By Operator [GBY_1789] (rows=1 width=12)
-                                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                            
Select Operator [SEL_1782] (rows=1957 width=4)
-                                                                              
Output:["_col0"]
-                                                                               
Please refer to the previous Select Operator [SEL_1780]
-                                  <-Reducer 32 [CUSTOM_SIMPLE_EDGE] vectorized
-                                    PARTITION_ONLY_SHUFFLE [RS_1719]
-                                      Select Operator [SEL_1718] (rows=1 
width=112)
-                                        Output:["_col0"]
-                                        Group By Operator [GBY_1717] (rows=1 
width=120)
-                                          
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"]
-                                        <-Union 31 [CUSTOM_SIMPLE_EDGE]
-                                          <-Reducer 30 [CONTAINS]
-                                            Reduce Output Operator [RS_1514]
-                                              Group By Operator [GBY_1513] 
(rows=1 width=120)
-                                                
Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"]
-                                                Select Operator [SEL_1512] 
(rows=26270325 width=44)
-                                                  Output:["_col0"]
-                                                  Select Operator [SEL_1510] 
(rows=7676736 width=94)
-                                                    Output:["_col0","_col1"]
-                                                    Merge Join Operator 
[MERGEJOIN_1509] (rows=7676736 width=94)
-                                                      
Conds:RS_1777._col0=RS_1758._col0(Inner),Output:["_col1","_col2"]
-                                                    <-Map 24 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1758]
-                                                        PartitionCols:_col0
-                                                         Please refer to the 
previous Select Operator [SEL_1752]
-                                                    <-Map 50 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1777]
-                                                        PartitionCols:_col0
-                                                        Select Operator 
[SEL_1775] (rows=286549727 width=119)
-                                                          
Output:["_col0","_col1","_col2"]
-                                                          Filter Operator 
[FIL_1774] (rows=286549727 width=119)
-                                                            
predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_62_date_dim_d_date_sk_min) 
AND DynamicValue(RS_62_date_dim_d_date_sk_max) and 
in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_62_date_dim_d_date_sk_bloom_filter))) and cs_sold_date_sk is 
not null)
-                                                            TableScan [TS_55] 
(rows=287989836 width=119)
-                                                              
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_quantity","cs_list_price"]
-                                                            <-Reducer 29 
[BROADCAST_EDGE] vectorized
-                                                              BROADCAST 
[RS_1773]
-                                                                Group By 
Operator [GBY_1772] (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
-                                                                  SHUFFLE 
[RS_1764]
-                                                                    Group By 
Operator [GBY_1762] (rows=1 width=12)
-                                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                      Select 
Operator [SEL_1756] (rows=1957 width=4)
-                                                                        
Output:["_col0"]
-                                                                         
Please refer to the previous Select Operator [SEL_1752]
-                                          <-Reducer 44 [CONTAINS]
-                                            Reduce Output Operator [RS_1550]
-                                              Group By Operator [GBY_1549] 
(rows=1 width=120)
-                                                
Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"]
-                                                Select Operator [SEL_1548] 
(rows=26270325 width=44)
-                                                  Output:["_col0"]
-                                                  Select Operator [SEL_1546] 
(rows=3856907 width=114)
-                                                    Output:["_col0","_col1"]
-                                                    Merge Join Operator 
[MERGEJOIN_1545] (rows=3856907 width=114)
-                                                      
Conds:RS_1805._col0=RS_1786._col0(Inner),Output:["_col1","_col2"]
-                                                    <-Map 40 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1786]
-                                                        PartitionCols:_col0
-                                                         Please refer to the 
previous Select Operator [SEL_1780]
-                                                    <-Map 51 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1805]
-                                                        PartitionCols:_col0
-                                                        Select Operator 
[SEL_1803] (rows=143966864 width=119)
-                                                          
Output:["_col0","_col1","_col2"]
-                                                          Filter Operator 
[FIL_1802] (rows=143966864 width=119)
-                                                            
predicate:((ws_sold_date_sk BETWEEN DynamicValue(RS_73_date_dim_d_date_sk_min) 
AND DynamicValue(RS_73_date_dim_d_date_sk_max) and 
in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_73_date_dim_d_date_sk_bloom_filter))) and ws_sold_date_sk is 
not null)
-                                                            TableScan [TS_66] 
(rows=144002668 width=119)
-                                                              
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_quantity","ws_list_price"]
-                                                            <-Reducer 43 
[BROADCAST_EDGE] vectorized
-                                                              BROADCAST 
[RS_1801]
-                                                                Group By 
Operator [GBY_1800] (rows=1 width=12)
-                                                                  
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                <-Map 40 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                  SHUFFLE 
[RS_1792]
-                                                                    Group By 
Operator [GBY_1790] (rows=1 width=12)
-                                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                      Select 
Operator [SEL_1784] (rows=1957 width=4)
-                                                                        
Output:["_col0"]
-                                                                         
Please refer to the previous Select Operator [SEL_1780]
-                                          <-Reducer 48 [CONTAINS]
-                                            Reduce Output Operator [RS_1568]
-                                              Group By Operator [GBY_1567] 
(rows=1 width=120)
-                                                
Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"]
-                                                Select Operator [SEL_1566] 
(rows=26270325 width=44)
-                                                  Output:["_col0"]
-                                                  Select Operator [SEL_1564] 
(rows=14736682 width=0)
-                                                    Output:["_col0","_col1"]
-                                                    Merge Join Operator 
[MERGEJOIN_1563] (rows=14736682 width=0)
-                                                      
Conds:RS_1812._col0=RS_1624._col0(Inner),Output:["_col1","_col2"]
-                                                    <-Map 93 [SIMPLE_EDGE] 
vectorized
-                                                      PARTITION_ONLY_SHUFFLE 
[RS_1624]
-                                                        PartitionCols:_col0
-                                                         Please refer to the 
previous Select Operator [SEL_1612]
-                                                    <-Map 46 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1812]
-                                                        PartitionCols:_col0
-                                                        Select Operator 
[SEL_1810] (rows=550076554 width=114)
-                                                          
Output:["_col0","_col1","_col2"]
-                                                          Filter Operator 
[FIL_1809] (rows=550076554 width=114)
-                                                            
predicate:((ss_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(ss_sold_date_sk, 
DynamicValue(RS_52_date_dim_d_date_sk_bloom_filter))) and ss_sold_date_sk is 
not null)
-                                                            TableScan [TS_45] 
(rows=575995635 width=114)
-                                                              
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_quantity","ss_list_price"]
-                                                            <-Reducer 100 
[BROADCAST_EDGE] vectorized
-                                                              BROADCAST 
[RS_1808]
-                                                                Group By 
Operator [GBY_1807] (rows=1 width=12)
-                                                                  
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                <-Map 93 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                  
PARTITION_ONLY_SHUFFLE [RS_1636]
-                                                                    Group By 
Operator [GBY_1631] (rows=1 width=12)
-                                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                      Select 
Operator [SEL_1622] (rows=1957 width=4)
-                                                                        
Output:["_col0"]
-                                                                         
Please refer to the previous Select Operator [SEL_1612]
-                              <-Reducer 62 [CUSTOM_SIMPLE_EDGE] vectorized
-                                PARTITION_ONLY_SHUFFLE [RS_1730]
-                                  Group By Operator [GBY_1729] (rows=1 
width=132)
+                            Filter Operator [FIL_1172] (rows=1 width=244)
+                              predicate:(_col3 > _col5)
+                              Merge Join Operator [MERGEJOIN_1171] (rows=1 
width=244)
+                                
Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
+                              <-Reducer 15 [CUSTOM_SIMPLE_EDGE] vectorized
+                                PARTITION_ONLY_SHUFFLE [RS_1346]
+                                  Group By Operator [GBY_1345] (rows=1 
width=132)
                                     
Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0,
 KEY._col1, KEY._col2
-                                  <-Reducer 61 [SIMPLE_EDGE]
-                                    SHUFFLE [RS_371]
+                                  <-Reducer 14 [SIMPLE_EDGE]
+                                    SHUFFLE [RS_241]
                                       PartitionCols:_col0, _col1, _col2
-                                      Group By Operator [GBY_370] (rows=1 
width=132)
+                                      Group By Operator [GBY_240] (rows=1 
width=132)
                                         
Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0,
 _col1, _col2
-                                        Select Operator [SEL_368] (rows=1 
width=128)
+                                        Select Operator [SEL_238] (rows=1 
width=128)
                                           
Output:["_col0","_col1","_col2","_col3"]
-                                          Merge Join Operator [MERGEJOIN_1438] 
(rows=1 width=128)
-                                            
Conds:RS_365._col1=RS_366._col0(Left 
Semi),Output:["_col2","_col3","_col6","_col7","_col8"]
-                                          <-Reducer 60 [ONE_TO_ONE_EDGE]
-                                            FORWARD [RS_365]
+                                          Merge Join Operator [MERGEJOIN_1159] 
(rows=1 width=128)
+                                            
Conds:RS_235._col1=RS_236._col0(Left 
Semi),Output:["_col2","_col3","_col6","_col7","_col8"]
+                                          <-Reducer 13 [ONE_TO_ONE_EDGE]
+                                            FORWARD [RS_235]
                                               PartitionCols:_col1
-                                              Merge Join Operator 
[MERGEJOIN_1414] (rows=7790806 width=110)
-                                                
Conds:RS_360._col1=RS_1695._col0(Inner),Output:["_col1","_col2","_col3","_col6","_col7","_col8"]
-                                              <-Map 69 [SIMPLE_EDGE] vectorized
-                                                SHUFFLE [RS_1695]
+                                              Merge Join Operator 
[MERGEJOIN_1135] (rows=7790806 width=110)
+                                                
Conds:RS_230._col1=RS_1317._col0(Inner),Output:["_col1","_col2","_col3","_col6","_col7","_col8"]
+                                              <-Map 24 [SIMPLE_EDGE] vectorized
+                                                SHUFFLE [RS_1317]
                                                   PartitionCols:_col0
-                                                  Select Operator [SEL_1686] 
(rows=462000 width=15)
+                                                  Select Operator [SEL_1308] 
(rows=462000 width=15)
                                                     
Output:["_col0","_col1","_col2","_col3"]
-                                                    Filter Operator [FIL_1677] 
(rows=462000 width=15)
+                                                    Filter Operator [FIL_1299] 
(rows=462000 width=15)
                                                       predicate:i_item_sk is 
not null
-                                                      TableScan [TS_88] 
(rows=462000 width=15)
+                                                      TableScan [TS_6] 
(rows=462000 width=15)
                                                         
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_class_id","i_category_id"]
-                                              <-Reducer 59 [SIMPLE_EDGE]
-                                                SHUFFLE [RS_360]
+                                              <-Reducer 12 [SIMPLE_EDGE]
+                                                SHUFFLE [RS_230]
                                                   PartitionCols:_col1
-                                                  Merge Join Operator 
[MERGEJOIN_1413] (rows=7790806 width=98)
-                                                    
Conds:RS_1724._col0=RS_1657._col0(Inner),Output:["_col1","_col2","_col3"]
-                                                  <-Map 57 [SIMPLE_EDGE] 
vectorized
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_1657]
+                                                  Merge Join Operator 
[MERGEJOIN_1134] (rows=7790806 width=98)
+                                                    
Conds:RS_1340._col0=RS_1279._col0(Inner),Output:["_col1","_col2","_col3"]
+                                                  <-Map 10 [SIMPLE_EDGE] 
vectorized
+                                                    PARTITION_ONLY_SHUFFLE 
[RS_1279]
                                                       PartitionCols:_col0
-                                                      Select Operator 
[SEL_1654] (rows=50 width=4)
+                                                      Select Operator 
[SEL_1276] (rows=50 width=4)
                                                         Output:["_col0"]
-                                                        Filter Operator 
[FIL_1653] (rows=50 width=12)
+                                                        Filter Operator 
[FIL_1275] (rows=50 width=12)
                                                           predicate:((d_moy = 
11) and (d_year = 2000) and d_date_sk is not null)
-                                                          TableScan [TS_85] 
(rows=73049 width=12)
+                                                          TableScan [TS_3] 
(rows=73049 width=12)
                                                             
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"]
-                                                  <-Map 103 [SIMPLE_EDGE] 
vectorized
-                                                    SHUFFLE [RS_1724]
+                                                  <-Map 79 [SIMPLE_EDGE] 
vectorized
+                                                    SHUFFLE [RS_1340]
                                                       PartitionCols:_col0
-                                                      Select Operator 
[SEL_1723] (rows=286549727 width=123)
+                                                      Select Operator 
[SEL_1339] (rows=286549727 width=123)
                                                         
Output:["_col0","_col1","_col2","_col3"]
-                                                        Filter Operator 
[FIL_1722] (rows=286549727 width=123)
-                                                          
predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_358_date_dim_d_date_sk_min) 
AND DynamicValue(RS_358_date_dim_d_date_sk_max) and 
in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_358_date_dim_d_date_sk_bloom_filter))) and cs_item_sk is not 
null and cs_sold_date_sk is not null)
-                                                          TableScan [TS_273] 
(rows=287989836 width=123)
+                                                        Filter Operator 
[FIL_1338] (rows=286549727 width=123)
+                                                          
predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_228_date_dim_d_date_sk_min) 
AND DynamicValue(RS_228_date_dim_d_date_sk_max) and 
in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_228_date_dim_d_date_sk_bloom_filter))) and cs_item_sk is not 
null and cs_sold_date_sk is not null)
+                                                          TableScan [TS_143] 
(rows=287989836 width=123)
                                                             
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_quantity","cs_list_price"]
-                                                          <-Reducer 63 
[BROADCAST_EDGE] vectorized
-                                                            BROADCAST [RS_1721]
-                                                              Group By 
Operator [GBY_1720] (rows=1 width=12)
+                                                          <-Reducer 17 
[BROADCAST_EDGE] vectorized
+                                                            BROADCAST [RS_1337]
+                                                              Group By 
Operator [GBY_1336] (rows=1 width=12)
                                                                 
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                              <-Map 57 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                
PARTITION_ONLY_SHUFFLE [RS_1665]
-                                                                  Group By 
Operator [GBY_1662] (rows=1 width=12)
+                                                              <-Map 10 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                                
PARTITION_ONLY_SHUFFLE [RS_1287]
+                                                                  Group By 
Operator [GBY_1284] (rows=1 width=12)
                                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                    Select 
Operator [SEL_1658] (rows=50 width=4)
+                                                                    Select 
Operator [SEL_1280] (rows=50 width=4)
                                                                       
Output:["_col0"]
-                                                                       Please 
refer to the previous Select Operator [SEL_1654]
-                                          <-Reducer 78 [SIMPLE_EDGE]
-                                            SHUFFLE [RS_366]
+                                                                       Please 
refer to the previous Select Operator [SEL_1276]
+                                          <-Reducer 33 [SIMPLE_EDGE]
+                                            SHUFFLE [RS_236]
                                               PartitionCols:_col0
-                                              Group By Operator [GBY_364] 
(rows=362 width=4)
+                                              Group By Operator [GBY_234] 
(rows=362 width=4)
                                                 Output:["_col0"],keys:_col0
-                                                Merge Join Operator 
[MERGEJOIN_1421] (rows=724 width=4)
-                                                  Conds:RS_1696._col1, _col2, 
_col3=RS_1728._col0, _col1, _col2(Inner),Output:["_col0"]
-                                                <-Map 69 [SIMPLE_EDGE] 
vectorized
-                                                  SHUFFLE [RS_1696]
+                                                Merge Join Operator 
[MERGEJOIN_1142] (rows=724 width=4)
+                                                  Conds:RS_1318._col1, _col2, 
_col3=RS_1344._col0, _col1, _col2(Inner),Output:["_col0"]
+                                                <-Map 24 [SIMPLE_EDGE] 
vectorized
+                                                  SHUFFLE [RS_1318]
                                                     PartitionCols:_col1, 
_col2, _col3
-                                                    Select Operator [SEL_1687] 
(rows=458612 width=15)
+                                                    Select Operator [SEL_1309] 
(rows=458612 width=15)
                                                       
Output:["_col0","_col1","_col2","_col3"]
-                                                      Filter Operator 
[FIL_1678] (rows=458612 width=15)
+                                                      Filter Operator 
[FIL_1300] (rows=458612 width=15)
                                                         predicate:(i_brand_id 
is not null and i_category_id is not null and i_class_id is not null and 
i_item_sk is not null)
-                                                         Please refer to the 
previous TableScan [TS_88]
-                                                <-Reducer 77 [ONE_TO_ONE_EDGE] 
vectorized
-                                                  FORWARD [RS_1728]
+                                                         Please refer to the 
previous TableScan [TS_6]
+                                                <-Reducer 32 [ONE_TO_ONE_EDGE] 
vectorized
+                                                  FORWARD [RS_1344]
                                                     PartitionCols:_col0, 
_col1, _col2
-                                                    Select Operator [SEL_1727] 
(rows=1 width=12)
+                                                    Select Operator [SEL_1343] 
(rows=1 width=12)
                                                       
Output:["_col0","_col1","_col2"]
-                                                      Filter Operator 
[FIL_1726] (rows=1 width=20)
+                                                      Filter Operator 
[FIL_1342] (rows=1 width=20)
                                                         predicate:(_col3 = 3L)
-                                                        Group By Operator 
[GBY_1725] (rows=121728 width=19)
+                                                        Group By Operator 
[GBY_1341] (rows=121728 width=19)
                                                           
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
-                                                        <-Union 76 
[SIMPLE_EDGE]
-                                                          <-Reducer 75 
[CONTAINS] vectorized
-                                                            Reduce Output 
Operator [RS_1824]
+                                                        <-Union 31 
[SIMPLE_EDGE]
+                                                          <-Reducer 30 
[CONTAINS] vectorized
+                                                            Reduce Output 
Operator [RS_1394]
                                                               
PartitionCols:_col0, _col1, _col2
-                                                              Group By 
Operator [GBY_1823] (rows=121728 width=19)
+                                                              Group By 
Operator [GBY_1393] (rows=121728 width=19)
                                                                 
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0,
 _col1, _col2
-                                                                Group By 
Operator [GBY_1822] (rows=121728 width=19)
+                                                                Group By 
Operator [GBY_1392] (rows=121728 width=19)
                                                                   
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
-                                                                <-Reducer 71 
[SIMPLE_EDGE]
-                                                                  SHUFFLE 
[RS_302]
+                                                                <-Reducer 26 
[SIMPLE_EDGE]
+                                                                  SHUFFLE 
[RS_172]
                                                                     
PartitionCols:_col0, _col1, _col2
-                                                                    Group By 
Operator [GBY_110] (rows=121728 width=19)
+                                                                    Group By 
Operator [GBY_28] (rows=121728 width=19)
                                                                       
Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, 
_col5, _col6
-                                                                      Merge 
Join Operator [MERGEJOIN_1401] (rows=14628613 width=11)
-                                                                        
Conds:RS_106._col1=RS_1692._col0(Inner),Output:["_col4","_col5","_col6"]
-                                                                      <-Map 69 
[SIMPLE_EDGE] vectorized
-                                                                        
SHUFFLE [RS_1692]
+                                                                      Merge 
Join Operator [MERGEJOIN_1125] (rows=14628613 width=11)
+                                                                        
Conds:RS_24._col1=RS_1314._col0(Inner),Output:["_col4","_col5","_col6"]
+                                                                      <-Map 24 
[SIMPLE_EDGE] vectorized
+                                                                        
SHUFFLE [RS_1314]
                                                                           
PartitionCols:_col0
-                                                                          
Select Operator [SEL_1683] (rows=458612 width=15)
+                                                                          
Select Operator [SEL_1305] (rows=458612 width=15)
                                                                             
Output:["_col0","_col1","_col2","_col3"]
-                                                                            
Filter Operator [FIL_1674] (rows=458612 width=15)
+                                                                            
Filter Operator [FIL_1296] (rows=458612 width=15)
                                                                               
predicate:(i_brand_id is not null and i_category_id is not null and i_class_id 
is not null and i_item_sk is not null)
-                                                                               
Please refer to the previous TableScan [TS_88]
-                                                                      
<-Reducer 92 [SIMPLE_EDGE]
-                                                                        
SHUFFLE [RS_106]
+                                                                               
Please refer to the previous TableScan [TS_6]
+                                                                      
<-Reducer 47 [SIMPLE_EDGE]
+                                                                        
SHUFFLE [RS_24]
                                                                           
PartitionCols:_col1
-                                                                          
Merge Join Operator [MERGEJOIN_1400] (rows=14736682 width=4)
-                                                                            
Conds:RS_1818._col0=RS_1613._col0(Inner),Output:["_col1"]
-                                                                          
<-Map 93 [SIMPLE_EDGE] vectorized
-                                                                            
PARTITION_ONLY_SHUFFLE [RS_1613]
+                                                                          
Merge Join Operator [MERGEJOIN_1124] (rows=14736682 width=4)
+                                                                            
Conds:RS_1388._col0=RS_1366._col0(Inner),Output:["_col1"]
+                                                                          
<-Map 48 [SIMPLE_EDGE] vectorized
+                                                                            
SHUFFLE [RS_1366]
                                                                               
PartitionCols:_col0
-                                                                               
Please refer to the previous Select Operator [SEL_1612]
-                                                                          
<-Map 91 [SIMPLE_EDGE] vectorized
-                                                                            
SHUFFLE [RS_1818]
+                                                                              
Select Operator [SEL_1365] (rows=1957 width=4)
+                                                                               
 Output:["_col0"]
+                                                                               
 Filter Operator [FIL_1364] (rows=1957 width=8)
+                                                                               
   predicate:(d_date_sk is not null and d_year BETWEEN 1999 AND 2001)
+                                                                               
   TableScan [TS_15] (rows=73049 width=8)
+                                                                               
     default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"]
+                                                                          
<-Map 46 [SIMPLE_EDGE] vectorized
+                                                                            
SHUFFLE [RS_1388]
                                                                               
PartitionCols:_col0
-                                                                              
Select Operator [SEL_1817] (rows=550076554 width=7)
+                                                                              
Select Operator [SEL_1387] (rows=550076554 width=7)
                                                                                
 Output:["_col0","_col1"]
-                                                                               
 Filter Operator [FIL_1816] (rows=550076554 width=7)
-                                                                               
   predicate:((ss_sold_date_sk BETWEEN DynamicValue(RS_104_d1_d_date_sk_min) 
AND DynamicValue(RS_104_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_104_d1_d_date_sk_bloom_filter))) and ss_item_sk is not null and 
ss_sold_date_sk is not null)
-                                                                               
   TableScan [TS_94] (rows=575995635 width=7)
+                                                                               
 Filter Operator [FIL_1386] (rows=550076554 width=7)
+                                                                               
   predicate:((ss_sold_date_sk BETWEEN DynamicValue(RS_22_d1_d_date_sk_min) AND 
DynamicValue(RS_22_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_22_d1_d_date_sk_bloom_filter))) and ss_item_sk is not null and 
ss_sold_date_sk is not null)
+                                                                               
   TableScan [TS_12] (rows=575995635 width=7)
                                                                                
     
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk"]
-                                                                               
   <-Reducer 94 [BROADCAST_EDGE] vectorized
-                                                                               
     BROADCAST [RS_1815]
-                                                                               
       Group By Operator [GBY_1814] (rows=1 width=12)
+                                                                               
   <-Reducer 49 [BROADCAST_EDGE] vectorized
+                                                                               
     BROADCAST [RS_1385]
+                                                                               
       Group By Operator [GBY_1384] (rows=1 width=12)
                                                                                
         
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
       <-Map 93 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
         PARTITION_ONLY_SHUFFLE [RS_1632]
-                                                                               
           Group By Operator [GBY_1627] (rows=1 width=12)
+                                                                               
       <-Map 48 [CUSTOM_SIMPLE_EDGE] vectorized
+                                                                               
         SHUFFLE [RS_1380]
+                                                                               
           Group By Operator [GBY_1376] (rows=1 width=12)
                                                                                
             
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
             Select Operator [SEL_1614] (rows=1957 width=4)
+                                                                               
             Select Operator [SEL_1367] (rows=1957 width=4)
                                                                                
               Output:["_col0"]
-                                                                               
                Please refer to the previous Select Operator [SEL_1612]
-                                                          <-Reducer 85 
[CONTAINS] vectorized
-                                                            Reduce Output 
Operator [RS_1838]
+                                                                               
                Please refer to the previous Select Operator [SEL_1365]
+                                                          <-Reducer 40 
[CONTAINS] vectorized
+                                                            Reduce Output 
Operator [RS_1408]
                                                               
PartitionCols:_col0, _col1, _col2
-                                                              Group By 
Operator [GBY_1837] (rows=121728 width=19)
+                                                              Group By 
Operator [GBY_1407] (rows=121728 width=19)
                                                                 
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0,
 _col1, _col2
-                                                                Group By 
Operator [GBY_1836] (rows=121728 width=19)
+                                                                Group By 
Operator [GBY_1406] (rows=121728 width=19)
                                                                   
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
-                                                                <-Reducer 83 
[SIMPLE_EDGE]
-                                                                  SHUFFLE 
[RS_322]
+                                                                <-Reducer 38 
[SIMPLE_EDGE]
+                                                                  SHUFFLE 
[RS_192]
                                                                     
PartitionCols:_col0, _col1, _col2
-                                                                    Group By 
Operator [GBY_130] (rows=121728 width=19)
+                                                                    Group By 
Operator [GBY_48] (rows=121728 width=19)
                                                                       
Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, 
_col5, _col6
-                                                                      Merge 
Join Operator [MERGEJOIN_1403] (rows=7620440 width=11)
-                                                                        
Conds:RS_126._col1=RS_1693._col0(Inner),Output:["_col4","_col5","_col6"]
-                                                                      <-Map 69 
[SIMPLE_EDGE] vectorized
-                                                                        
SHUFFLE [RS_1693]
+                                                                      Merge 
Join Operator [MERGEJOIN_1127] (rows=7620440 width=11)
+                                                                        
Conds:RS_44._col1=RS_1315._col0(Inner),Output:["_col4","_col5","_col6"]
+                                                                      <-Map 24 
[SIMPLE_EDGE] vectorized
+                                                                        
SHUFFLE [RS_1315]
                                                                           
PartitionCols:_col0
-                                                                          
Select Operator [SEL_1684] (rows=458612 width=15)
+                                                                          
Select Operator [SEL_1306] (rows=458612 width=15)
                                                                             
Output:["_col0","_col1","_col2","_col3"]
-                                                                            
Filter Operator [FIL_1675] (rows=458612 width=15)
+                                                                            
Filter Operator [FIL_1297] (rows=458612 width=15)
                                                                               
predicate:(i_brand_id is not null and i_category_id is not null and i_class_id 
is not null and i_item_sk is not null)
-                                                                               
Please refer to the previous TableScan [TS_88]
-                                                                      
<-Reducer 95 [SIMPLE_EDGE]
-                                                                        
SHUFFLE [RS_126]
+                                                                               
Please refer to the previous TableScan [TS_6]
+                                                                      
<-Reducer 50 [SIMPLE_EDGE]
+                                                                        
SHUFFLE [RS_44]
                                                                           
PartitionCols:_col1
-                                                                          
Merge Join Operator [MERGEJOIN_1402] (rows=7676736 width=4)
-                                                                            
Conds:RS_1832._col0=RS_1615._col0(Inner),Output:["_col1"]
-                                                                          
<-Map 93 [SIMPLE_EDGE] vectorized
-                                                                            
PARTITION_ONLY_SHUFFLE [RS_1615]
+                                                                          
Merge Join Operator [MERGEJOIN_1126] (rows=7676736 width=4)
+                                                                            
Conds:RS_1402._col0=RS_1368._col0(Inner),Output:["_col1"]
+                                                                          
<-Map 48 [SIMPLE_EDGE] vectorized
+                                                                            
SHUFFLE [RS_1368]
                                                                               
PartitionCols:_col0
-                                                                               
Please refer to the previous Select Operator [SEL_1612]
-                                                                          
<-Map 101 [SIMPLE_EDGE] vectorized
-                                                                            
SHUFFLE [RS_1832]
+                                                                               
Please refer to the previous Select Operator [SEL_1365]
+                                                                          
<-Map 64 [SIMPLE_EDGE] vectorized
+                                                                            
SHUFFLE [RS_1402]
                                                                               
PartitionCols:_col0
-                                                                              
Select Operator [SEL_1831] (rows=286549727 width=7)
+                                                                              
Select Operator [SEL_1401] (rows=286549727 width=7)
                                                                                
 Output:["_col0","_col1"]
-                                                                               
 Filter Operator [FIL_1830] (rows=286549727 width=7)
-                                                                               
   predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_124_d2_d_date_sk_min) 
AND DynamicValue(RS_124_d2_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_124_d2_d_date_sk_bloom_filter))) and cs_item_sk is not null and 
cs_sold_date_sk is not null)
-                                                                               
   TableScan [TS_114] (rows=287989836 width=7)
+                                                                               
 Filter Operator [FIL_1400] (rows=286549727 width=7)
+                                                                               
   predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_42_d2_d_date_sk_min) AND 
DynamicValue(RS_42_d2_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_42_d2_d_date_sk_bloom_filter))) and cs_item_sk is not null and 
cs_sold_date_sk is not null)
+                                                                               
   TableScan [TS_32] (rows=287989836 width=7)
                                                                                
     
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk"]
-                                                                               
   <-Reducer 96 [BROADCAST_EDGE] vectorized
-                                                                               
     BROADCAST [RS_1829]
-                                                                               
       Group By Operator [GBY_1828] (rows=1 width=12)
+                                                                               
   <-Reducer 51 [BROADCAST_EDGE] vectorized
+                                                                               
     BROADCAST [RS_1399]
+                                                                               
       Group By Operator [GBY_1398] (rows=1 width=12)
                                                                                
         
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
       <-Map 93 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
         PARTITION_ONLY_SHUFFLE [RS_1633]
-                                                                               
           Group By Operator [GBY_1628] (rows=1 width=12)
+                                                                               
       <-Map 48 [CUSTOM_SIMPLE_EDGE] vectorized
+                                                                               
         SHUFFLE [RS_1381]
+                                                                               
           Group By Operator [GBY_1377] (rows=1 width=12)
                                                                                
             
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
             Select Operator [SEL_1616] (rows=1957 width=4)
+                                                                               
             Select Operator [SEL_1369] (rows=1957 width=4)
                                                                                
               Output:["_col0"]
-                                                                               
                Please refer to the previous Select Operator [SEL_1612]
-                                                          <-Reducer 89 
[CONTAINS] vectorized
-                                                            Reduce Output 
Operator [RS_1852]
+                                                                               
                Please refer to the previous Select Operator [SEL_1365]
+                                                          <-Reducer 44 
[CONTAINS] vectorized
+                                                            Reduce Output 
Operator [RS_1422]
                                                               
PartitionCols:_col0, _col1, _col2
-                                                              Group By 
Operator [GBY_1851] (rows=121728 width=19)
+                                                              Group By 
Operator [GBY_1421] (rows=121728 width=19)
                                                                 
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0,
 _col1, _col2
-                                                                Group By 
Operator [GBY_1850] (rows=121728 width=19)
+                                                                Group By 
Operator [GBY_1420] (rows=121728 width=19)
                                                                   
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
-                                                                <-Reducer 87 
[SIMPLE_EDGE]
-                                                                  SHUFFLE 
[RS_343]
+                                                                <-Reducer 42 
[SIMPLE_EDGE]
+                                                                  SHUFFLE 
[RS_213]
                                                                     
PartitionCols:_col0, _col1, _col2
-                                                                    Group By 
Operator [GBY_151] (rows=121728 width=19)
+                                                                    Group By 
Operator [GBY_69] (rows=121728 width=19)
                                                                       
Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, 
_col5, _col6
-                                                                      Merge 
Join Operator [MERGEJOIN_1405] (rows=3828623 width=11)
-                                                                        
Conds:RS_147._col1=RS_1694._col0(Inner),Output:["_col4","_col5","_col6"]
-                                                                      <-Map 69 
[SIMPLE_EDGE] vectorized
-                                                                        
SHUFFLE [RS_1694]
+                                                                      Merge 
Join Operator [MERGEJOIN_1129] (rows=3828623 width=11)
+                                                                        
Conds:RS_65._col1=RS_1316._col0(Inner),Output:["_col4","_col5","_col6"]
+                                                                      <-Map 24 
[SIMPLE_EDGE] vectorized
+                                                                        
SHUFFLE [RS_1316]
                                                                           
PartitionCols:_col0
-                                                                          
Select Operator [SEL_1685] (rows=458612 width=15)
+                                                                          
Select Operator [SEL_1307] (rows=458612 width=15)
                                                                             
Output:["_col0","_col1","_col2","_col3"]
-                                                                            
Filter Operator [FIL_1676] (rows=458612 width=15)
+                                                                            
Filter Operator [FIL_1298] (rows=458612 width=15)
                                                                               
predicate:(i_brand_id is not null and i_category_id is not null and i_class_id 
is not null and i_item_sk is not null)
-                                                                               
Please refer to the previous TableScan [TS_88]
-                                                                      
<-Reducer 97 [SIMPLE_EDGE]
-                                                                        
SHUFFLE [RS_147]
+                                                                               
Please refer to the previous TableScan [TS_6]
+                                                                      
<-Reducer 52 [SIMPLE_EDGE]
+                                                                        
SHUFFLE [RS_65]
                                                                           
PartitionCols:_col1
-                                                                          
Merge Join Operator [MERGEJOIN_1404] (rows=3856907 width=4)
-                                                                            
Conds:RS_1846._col0=RS_1617._col0(Inner),Output:["_col1"]
-                                                                          
<-Map 93 [SIMPLE_EDGE] vectorized
-                                                                            
PARTITION_ONLY_SHUFFLE [RS_1617]
+                                                                          
Merge Join Operator [MERGEJOIN_1128] (rows=3856907 width=4)
+                                                                            
Conds:RS_1416._col0=RS_1370._col0(Inner),Output:["_col1"]
+                                                                          
<-Map 48 [SIMPLE_EDGE] vectorized
+                                                                            
SHUFFLE [RS_1370]
                                                                               
PartitionCols:_col0
-                                                                               
Please refer to the previous Select Operator [SEL_1612]
-                                                                          
<-Map 102 [SIMPLE_EDGE] vectorized
-                                                                            
SHUFFLE [RS_1846]
+                                                                               
Please refer to the previous Select Operator [SEL_1365]
+                                                                          
<-Map 65 [SIMPLE_EDGE] vectorized
+                                                                            
SHUFFLE [RS_1416]
                                                                               
PartitionCols:_col0
-                                                                              
Select Operator [SEL_1845] (rows=143966864 width=7)
+                                                                              
Select Operator [SEL_1415] (rows=143966864 width=7)
                                                                                
 Output:["_col0","_col1"]
-                                                                               
 Filter Operator [FIL_1844] (rows=143966864 width=7)
-                                                                               
   predicate:((ws_sold_date_sk BETWEEN DynamicValue(RS_145_d3_d_date_sk_min) 
AND DynamicValue(RS_145_d3_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_145_d3_d_date_sk_bloom_filter))) and ws_item_sk is not null and 
ws_sold_date_sk is not null)
-                                                                               
   TableScan [TS_135] (rows=144002668 width=7)
+                                                                               
 Filter Operator [FIL_1414] (rows=143966864 width=7)
+                                                                               
   predicate:((ws_sold_date_sk BETWEEN DynamicValue(RS_63_d3_d_date_sk_min) AND 
DynamicValue(RS_63_d3_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_63_d3_d_date_sk_bloom_filter))) and ws_item_sk is not null and 
ws_sold_date_sk is not null)
+                                                                               
   TableScan [TS_53] (rows=144002668 width=7)
                                                                                
     
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk"]
-                                                                               
   <-Reducer 98 [BROADCAST_EDGE] vectorized
-                                                                               
     BROADCAST [RS_1843]
-                                                                               
       Group By Operator [GBY_1842] (rows=1 width=12)
+                                                                               
   <-Reducer 53 [BROADCAST_EDGE] vectorized
+                                                                               
     BROADCAST [RS_1413]
+                                                                               
       Group By Operator [GBY_1412] (rows=1 width=12)
                                                                                
         
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
       <-Map 93 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
         PARTITION_ONLY_SHUFFLE [RS_1634]
-                                                                               
           Group By Operator [GBY_1629] (rows=1 width=12)
+                                                                               
       <-Map 48 [CUSTOM_SIMPLE_EDGE] vectorized
+                                                                               
         SHUFFLE [RS_1382]
+                                                                               
           Group By Operator [GBY_1378] (rows=1 width=12)
                                                                                
             
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
             Select Operator [SEL_1618] (rows=1957 width=4)
+                                                                               
             Select Operator [SEL_1371] (rows=1957 width=4)
                                                                                
               Output:["_col0"]
-                                                                               
                Please refer to the previous Select Operator [SEL_1612]
-                  <-Reducer 19 [CONTAINS]
-                    Reduce Output Operator [RS_1484]
+                                                                               
                Please refer to the previous Select Operator [SEL_1365]
+                              <-Reducer 60 [CUSTOM_SIMPLE_EDGE] vectorized
+                                PARTITION_ONLY_SHUFFLE [RS_1349]
+                                  Select Operator [SEL_1348] (rows=1 width=112)
+                                    Output:["_col0"]
+                                    Group By Operator [GBY_1347] (rows=1 
width=120)
+                                      
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"]
+                                    <-Union 59 [CUSTOM_SIMPLE_EDGE]
+                                      <-Reducer 58 [CONTAINS]
+                                        Reduce Output Operator [RS_1232]
+                                          Group By Operator [GBY_1231] (rows=1 
width=120)
+                                            
Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"]
+                                            Select Operator [SEL_1230] 
(rows=26270325 width=44)
+                                              Output:["_col0"]
+                                              Select Operator [SEL_1228] 
(rows=14736682 width=0)
+                                                Output:["_col0","_col1"]
+                                                Merge Join Operator 
[MERGEJOIN_1227] (rows=14736682 width=0)
+                                                  
Conds:RS_1431._col0=RS_1374._c

<TRUNCATED>

Reply via email to