http://git-wip-us.apache.org/repos/asf/hive/blob/c7b5454a/ql/src/test/results/clientpositive/perf/tez/constraints/query14.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query14.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query14.q.out
index 4df5864..1a3aefe 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query14.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query14.q.out
@@ -1,9 +1,6 @@
-Warning: Shuffle Join MERGEJOIN[1458][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 5' is a cross product
-Warning: Shuffle Join MERGEJOIN[1470][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 6' is a cross product
-Warning: Shuffle Join MERGEJOIN[1460][tables = [$hdt$_1, $hdt$_2]] in Stage 
'Reducer 13' is a cross product
-Warning: Shuffle Join MERGEJOIN[1483][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in 
Stage 'Reducer 14' is a cross product
-Warning: Shuffle Join MERGEJOIN[1462][tables = [$hdt$_2, $hdt$_3]] in Stage 
'Reducer 18' is a cross product
-Warning: Shuffle Join MERGEJOIN[1496][tables = [$hdt$_2, $hdt$_3, $hdt$_1]] in 
Stage 'Reducer 19' is a cross product
+Warning: Shuffle Join MERGEJOIN[1182][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 6' is a cross product
+Warning: Shuffle Join MERGEJOIN[1189][tables = [$hdt$_0, $hdt$_1]] in Stage 
'Reducer 16' is a cross product
+Warning: Shuffle Join MERGEJOIN[1196][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,1104 +222,828 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 98 (BROADCAST_EDGE)
-Map 100 <- Reducer 91 (BROADCAST_EDGE)
-Map 101 <- Reducer 97 (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 99 (BROADCAST_EDGE)
-Map 50 <- Reducer 29 (BROADCAST_EDGE)
-Map 51 <- Reducer 43 (BROADCAST_EDGE)
-Map 52 <- Reducer 58 (BROADCAST_EDGE)
-Map 69 <- Reducer 85 (BROADCAST_EDGE)
-Reducer 10 <- Map 1 (SIMPLE_EDGE), Map 84 (SIMPLE_EDGE), Union 11 (CONTAINS)
-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 84 (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 84 (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 84 (SIMPLE_EDGE), Union 27 (CONTAINS)
-Reducer 48 <- Map 46 (SIMPLE_EDGE), Map 84 (SIMPLE_EDGE), Union 31 (CONTAINS)
-Reducer 49 <- Map 46 (SIMPLE_EDGE), Map 84 (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 <- Reducer 53 (SIMPLE_EDGE), Reducer 75 (SIMPLE_EDGE)
-Reducer 55 <- Map 102 (SIMPLE_EDGE), Reducer 54 (ONE_TO_ONE_EDGE)
-Reducer 56 <- Reducer 55 (SIMPLE_EDGE)
-Reducer 58 <- Map 57 (CUSTOM_SIMPLE_EDGE)
-Reducer 59 <- Map 103 (SIMPLE_EDGE), Map 57 (SIMPLE_EDGE)
-Reducer 6 <- Reducer 5 (CUSTOM_SIMPLE_EDGE), Reducer 56 (CUSTOM_SIMPLE_EDGE), 
Union 7 (CONTAINS)
-Reducer 60 <- Reducer 59 (SIMPLE_EDGE), Reducer 79 (SIMPLE_EDGE)
-Reducer 61 <- Map 102 (SIMPLE_EDGE), Reducer 60 (ONE_TO_ONE_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 <- Reducer 64 (SIMPLE_EDGE), Reducer 83 (SIMPLE_EDGE)
-Reducer 66 <- Map 102 (SIMPLE_EDGE), Reducer 65 (ONE_TO_ONE_EDGE)
-Reducer 67 <- Reducer 66 (SIMPLE_EDGE)
-Reducer 68 <- Map 57 (CUSTOM_SIMPLE_EDGE)
-Reducer 70 <- Map 69 (SIMPLE_EDGE), Map 84 (SIMPLE_EDGE)
-Reducer 71 <- Map 102 (SIMPLE_EDGE), Reducer 70 (SIMPLE_EDGE)
-Reducer 72 <- Reducer 71 (SIMPLE_EDGE), Union 73 (CONTAINS)
-Reducer 74 <- Union 73 (SIMPLE_EDGE)
-Reducer 75 <- Map 102 (SIMPLE_EDGE), Reducer 74 (ONE_TO_ONE_EDGE)
-Reducer 76 <- Reducer 71 (SIMPLE_EDGE), Union 77 (CONTAINS)
-Reducer 78 <- Union 77 (SIMPLE_EDGE)
-Reducer 79 <- Map 102 (SIMPLE_EDGE), Reducer 78 (ONE_TO_ONE_EDGE)
+Map 1 <- Reducer 11 (BROADCAST_EDGE)
+Map 24 <- Reducer 40 (BROADCAST_EDGE)
+Map 63 <- Reducer 46 (BROADCAST_EDGE)
+Map 64 <- Reducer 52 (BROADCAST_EDGE)
+Map 66 <- Reducer 56 (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 <- Reducer 12 (SIMPLE_EDGE), Reducer 34 (SIMPLE_EDGE)
+Reducer 14 <- Map 65 (SIMPLE_EDGE), Reducer 13 (ONE_TO_ONE_EDGE)
+Reducer 15 <- Reducer 14 (SIMPLE_EDGE)
+Reducer 16 <- Reducer 15 (CUSTOM_SIMPLE_EDGE), Reducer 59 
(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 <- Reducer 18 (SIMPLE_EDGE), Reducer 38 (SIMPLE_EDGE)
+Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE)
+Reducer 20 <- Map 65 (SIMPLE_EDGE), Reducer 19 (ONE_TO_ONE_EDGE)
+Reducer 21 <- Reducer 20 (SIMPLE_EDGE)
+Reducer 22 <- Reducer 21 (CUSTOM_SIMPLE_EDGE), Reducer 62 
(CUSTOM_SIMPLE_EDGE), Union 7 (CONTAINS)
+Reducer 23 <- Map 10 (CUSTOM_SIMPLE_EDGE)
+Reducer 25 <- Map 24 (SIMPLE_EDGE), Map 39 (SIMPLE_EDGE)
+Reducer 26 <- Map 65 (SIMPLE_EDGE), Reducer 25 (SIMPLE_EDGE)
+Reducer 27 <- Reducer 26 (SIMPLE_EDGE), Union 28 (CONTAINS)
+Reducer 29 <- Union 28 (SIMPLE_EDGE)
+Reducer 3 <- Reducer 2 (SIMPLE_EDGE), Reducer 30 (SIMPLE_EDGE)
+Reducer 30 <- Map 65 (SIMPLE_EDGE), Reducer 29 (ONE_TO_ONE_EDGE)
+Reducer 31 <- Reducer 26 (SIMPLE_EDGE), Union 32 (CONTAINS)
+Reducer 33 <- Union 32 (SIMPLE_EDGE)
+Reducer 34 <- Map 65 (SIMPLE_EDGE), Reducer 33 (ONE_TO_ONE_EDGE)
+Reducer 35 <- Reducer 26 (SIMPLE_EDGE), Union 36 (CONTAINS)
+Reducer 37 <- Union 36 (SIMPLE_EDGE)
+Reducer 38 <- Map 65 (SIMPLE_EDGE), Reducer 37 (ONE_TO_ONE_EDGE)
+Reducer 4 <- Map 65 (SIMPLE_EDGE), Reducer 3 (ONE_TO_ONE_EDGE)
+Reducer 40 <- Map 39 (CUSTOM_SIMPLE_EDGE)
+Reducer 41 <- Map 39 (SIMPLE_EDGE), Map 63 (SIMPLE_EDGE)
+Reducer 42 <- Map 65 (SIMPLE_EDGE), Reducer 41 (SIMPLE_EDGE)
+Reducer 43 <- Reducer 42 (SIMPLE_EDGE), Union 28 (CONTAINS)
+Reducer 44 <- Reducer 42 (SIMPLE_EDGE), Union 32 (CONTAINS)
+Reducer 45 <- Reducer 42 (SIMPLE_EDGE), Union 36 (CONTAINS)
+Reducer 46 <- Map 39 (CUSTOM_SIMPLE_EDGE)
+Reducer 47 <- Map 39 (SIMPLE_EDGE), Map 64 (SIMPLE_EDGE)
+Reducer 48 <- Map 65 (SIMPLE_EDGE), Reducer 47 (SIMPLE_EDGE)
+Reducer 49 <- Reducer 48 (SIMPLE_EDGE), Union 28 (CONTAINS)
+Reducer 5 <- Reducer 4 (SIMPLE_EDGE)
+Reducer 50 <- Reducer 48 (SIMPLE_EDGE), Union 32 (CONTAINS)
+Reducer 51 <- Reducer 48 (SIMPLE_EDGE), Union 36 (CONTAINS)
+Reducer 52 <- Map 39 (CUSTOM_SIMPLE_EDGE)
+Reducer 53 <- Map 39 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE), Union 54 (CONTAINS)
+Reducer 55 <- Union 54 (CUSTOM_SIMPLE_EDGE)
+Reducer 56 <- Map 39 (CUSTOM_SIMPLE_EDGE)
+Reducer 57 <- Map 39 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE), Union 58 (CONTAINS)
+Reducer 59 <- Union 58 (CUSTOM_SIMPLE_EDGE)
+Reducer 6 <- Reducer 5 (CUSTOM_SIMPLE_EDGE), Reducer 55 (CUSTOM_SIMPLE_EDGE), 
Union 7 (CONTAINS)
+Reducer 60 <- Map 39 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE), Union 61 (CONTAINS)
+Reducer 62 <- Union 61 (CUSTOM_SIMPLE_EDGE)
+Reducer 68 <- Map 67 (SIMPLE_EDGE), Map 71 (SIMPLE_EDGE), Union 54 (CONTAINS)
+Reducer 69 <- Map 67 (SIMPLE_EDGE), Map 71 (SIMPLE_EDGE), Union 58 (CONTAINS)
+Reducer 70 <- Map 67 (SIMPLE_EDGE), Map 71 (SIMPLE_EDGE), Union 61 (CONTAINS)
+Reducer 72 <- Map 71 (CUSTOM_SIMPLE_EDGE)
+Reducer 74 <- Map 73 (SIMPLE_EDGE), Map 77 (SIMPLE_EDGE), Union 54 (CONTAINS)
+Reducer 75 <- Map 73 (SIMPLE_EDGE), Map 77 (SIMPLE_EDGE), Union 58 (CONTAINS)
+Reducer 76 <- Map 73 (SIMPLE_EDGE), Map 77 (SIMPLE_EDGE), Union 61 (CONTAINS)
+Reducer 78 <- Map 77 (CUSTOM_SIMPLE_EDGE)
 Reducer 8 <- Union 7 (SIMPLE_EDGE)
-Reducer 80 <- Reducer 71 (SIMPLE_EDGE), Union 81 (CONTAINS)
-Reducer 82 <- Union 81 (SIMPLE_EDGE)
-Reducer 83 <- Map 102 (SIMPLE_EDGE), Reducer 82 (ONE_TO_ONE_EDGE)
-Reducer 85 <- Map 84 (CUSTOM_SIMPLE_EDGE)
-Reducer 86 <- Map 100 (SIMPLE_EDGE), Map 84 (SIMPLE_EDGE)
-Reducer 87 <- Map 102 (SIMPLE_EDGE), Reducer 86 (SIMPLE_EDGE)
-Reducer 88 <- Reducer 87 (SIMPLE_EDGE), Union 73 (CONTAINS)
-Reducer 89 <- Reducer 87 (SIMPLE_EDGE), Union 77 (CONTAINS)
 Reducer 9 <- Reducer 8 (SIMPLE_EDGE)
-Reducer 90 <- Reducer 87 (SIMPLE_EDGE), Union 81 (CONTAINS)
-Reducer 91 <- Map 84 (CUSTOM_SIMPLE_EDGE)
-Reducer 92 <- Map 101 (SIMPLE_EDGE), Map 84 (SIMPLE_EDGE)
-Reducer 93 <- Map 102 (SIMPLE_EDGE), Reducer 92 (SIMPLE_EDGE)
-Reducer 94 <- Reducer 93 (SIMPLE_EDGE), Union 73 (CONTAINS)
-Reducer 95 <- Reducer 93 (SIMPLE_EDGE), Union 77 (CONTAINS)
-Reducer 96 <- Reducer 93 (SIMPLE_EDGE), Union 81 (CONTAINS)
-Reducer 97 <- Map 84 (CUSTOM_SIMPLE_EDGE)
-Reducer 98 <- Map 84 (CUSTOM_SIMPLE_EDGE)
-Reducer 99 <- Map 84 (CUSTOM_SIMPLE_EDGE)
 
 Stage-0
   Fetch Operator
     limit:100
     Stage-1
       Reducer 9 vectorized
-      File Output Operator [FS_1725]
-        Limit [LIM_1724] (rows=7 width=192)
+      File Output Operator [FS_1350]
+        Limit [LIM_1349] (rows=7 width=192)
           Number of rows:100
-          Select Operator [SEL_1723] (rows=7 width=192)
+          Select Operator [SEL_1348] (rows=7 width=192)
             Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
           <-Reducer 8 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_1722]
-              Select Operator [SEL_1721] (rows=7 width=192)
+            SHUFFLE [RS_1347]
+              Select Operator [SEL_1346] (rows=7 width=192)
                 Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
-                Group By Operator [GBY_1720] (rows=7 width=200)
+                Group By Operator [GBY_1345] (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_1489]
+                  <-Reducer 16 [CONTAINS]
+                    Reduce Output Operator [RS_1195]
                       PartitionCols:_col0, _col1, _col2, _col3, _col4
-                      Group By Operator [GBY_1488] (rows=7 width=200)
+                      Group By Operator [GBY_1194] (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_1487] (rows=3 width=221)
+                        Top N Key Operator [TNK_1193] (rows=3 width=221)
                           keys:_col0, _col1, _col2, _col3, 0L,sort 
order:+++++,top n:100
-                          Select Operator [SEL_1485] (rows=1 width=223)
+                          Select Operator [SEL_1191] (rows=1 width=223)
                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
-                            Filter Operator [FIL_1484] (rows=1 width=244)
-                              predicate:(_col5 > _col1)
-                              Merge Join Operator [MERGEJOIN_1483] (rows=1 
width=244)
-                                
Conds:(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6"]
-                              <-Reducer 13 [CUSTOM_SIMPLE_EDGE]
-                                PARTITION_ONLY_SHUFFLE [RS_371]
-                                  Merge Join Operator [MERGEJOIN_1460] (rows=1 
width=112)
-                                    Conds:(Inner),Output:["_col1"]
-                                  <-Reducer 12 [CUSTOM_SIMPLE_EDGE] vectorized
-                                    PARTITION_ONLY_SHUFFLE [RS_1731]
-                                      Select Operator [SEL_1730] (rows=1 
width=8)
-                                        Filter Operator [FIL_1729] (rows=1 
width=8)
-                                          predicate:(sq_count_check(_col0) <= 
1)
-                                          Group By Operator [GBY_1728] (rows=1 
width=8)
-                                            
Output:["_col0"],aggregations:["count()"]
-                                            Select Operator [SEL_1727] (rows=1 
width=8)
-                                              Group By Operator [GBY_1726] 
(rows=1 width=8)
-                                                
Output:["_col0"],aggregations:["count(VALUE._col0)"]
-                                              <-Union 11 [CUSTOM_SIMPLE_EDGE]
-                                                <-Reducer 10 [CONTAINS]
-                                                  Reduce Output Operator 
[RS_1482]
-                                                    Group By Operator 
[GBY_1481] (rows=1 width=8)
-                                                      
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_1480] (rows=26270325 width=1)
-                                                        Output:["_col0"]
-                                                        Select Operator 
[SEL_1478] (rows=14736682 width=0)
-                                                          Output:["_col0"]
-                                                          Merge Join Operator 
[MERGEJOIN_1477] (rows=14736682 width=0)
-                                                            
Conds:RS_1660._col0=RS_1641._col0(Inner),Output:["_col1"]
-                                                          <-Map 84 
[SIMPLE_EDGE] vectorized
-                                                            
PARTITION_ONLY_SHUFFLE [RS_1641]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1630] (rows=1957 width=4)
-                                                                
Output:["_col0"]
-                                                                Filter 
Operator [FIL_1629] (rows=1957 width=8)
-                                                                  
predicate:d_year BETWEEN 1999 AND 2001
-                                                                  TableScan 
[TS_94] (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_1660]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1658] (rows=550076554 width=7)
-                                                                
Output:["_col0","_col1"]
-                                                                Filter 
Operator [FIL_1657] (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 98 
[BROADCAST_EDGE] vectorized
-                                                                    BROADCAST 
[RS_1656]
-                                                                      Group By 
Operator [GBY_1655] (rows=1 width=12)
-                                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                      <-Map 84 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                        
PARTITION_ONLY_SHUFFLE [RS_1653]
-                                                                          
Group By Operator [GBY_1648] (rows=1 width=12)
-                                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                            
Select Operator [SEL_1638] (rows=1957 width=4)
-                                                                              
Output:["_col0"]
-                                                                               
Please refer to the previous Select Operator [SEL_1630]
-                                                <-Reducer 22 [CONTAINS]
-                                                  Reduce Output Operator 
[RS_1514]
-                                                    Group By Operator 
[GBY_1513] (rows=1 width=8)
-                                                      
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_1512] (rows=26270325 width=1)
-                                                        Output:["_col0"]
-                                                        Select Operator 
[SEL_1510] (rows=7676736 width=3)
-                                                          Output:["_col0"]
-                                                          Merge Join Operator 
[MERGEJOIN_1509] (rows=7676736 width=3)
-                                                            
Conds:RS_1785._col0=RS_1772._col0(Inner),Output:["_col1"]
-                                                          <-Map 24 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_1772]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1767] (rows=1957 width=4)
-                                                                
Output:["_col0"]
-                                                                Filter 
Operator [FIL_1766] (rows=1957 width=8)
-                                                                  
predicate: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_1785]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1783] (rows=286549727 width=7)
-                                                                
Output:["_col0","_col1"]
-                                                                Filter 
Operator [FIL_1782] (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_1781]
-                                                                      Group By 
Operator [GBY_1780] (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_1778]
-                                                                          
Group By Operator [GBY_1776] (rows=1 width=12)
-                                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                            
Select Operator [SEL_1769] (rows=1957 width=4)
-                                                                              
Output:["_col0"]
-                                                                               
Please refer to the previous Select Operator [SEL_1767]
-                                                <-Reducer 38 [CONTAINS]
-                                                  Reduce Output Operator 
[RS_1550]
-                                                    Group By Operator 
[GBY_1549] (rows=1 width=8)
-                                                      
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_1548] (rows=26270325 width=1)
-                                                        Output:["_col0"]
-                                                        Select Operator 
[SEL_1546] (rows=3856907 width=3)
-                                                          Output:["_col0"]
-                                                          Merge Join Operator 
[MERGEJOIN_1545] (rows=3856907 width=3)
-                                                            
Conds:RS_1813._col0=RS_1800._col0(Inner),Output:["_col1"]
-                                                          <-Map 40 
[SIMPLE_EDGE] vectorized
-                                                            SHUFFLE [RS_1800]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1795] (rows=1957 width=4)
-                                                                
Output:["_col0"]
-                                                                Filter 
Operator [FIL_1794] (rows=1957 width=8)
-                                                                  
predicate: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_1813]
-                                                              
PartitionCols:_col0
-                                                              Select Operator 
[SEL_1811] (rows=143966864 width=7)
-                                                                
Output:["_col0","_col1"]
-                                                                Filter 
Operator [FIL_1810] (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_1809]
-                                                                      Group By 
Operator [GBY_1808] (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_1806]
-                                                                          
Group By Operator [GBY_1804] (rows=1 width=12)
-                                                                            
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                            
Select Operator [SEL_1797] (rows=1957 width=4)
-                                                                              
Output:["_col0"]
-                                                                               
Please refer to the previous Select Operator [SEL_1795]
-                                  <-Reducer 32 [CUSTOM_SIMPLE_EDGE] vectorized
-                                    PARTITION_ONLY_SHUFFLE [RS_1734]
-                                      Select Operator [SEL_1733] (rows=1 
width=112)
-                                        Output:["_col0"]
-                                        Group By Operator [GBY_1732] (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_1532]
-                                              Group By Operator [GBY_1531] 
(rows=1 width=120)
-                                                
Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"]
-                                                Select Operator [SEL_1530] 
(rows=26270325 width=44)
-                                                  Output:["_col0"]
-                                                  Select Operator [SEL_1528] 
(rows=7676736 width=94)
-                                                    Output:["_col0","_col1"]
-                                                    Merge Join Operator 
[MERGEJOIN_1527] (rows=7676736 width=94)
-                                                      
Conds:RS_1792._col0=RS_1773._col0(Inner),Output:["_col1","_col2"]
-                                                    <-Map 24 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1773]
-                                                        PartitionCols:_col0
-                                                         Please refer to the 
previous Select Operator [SEL_1767]
-                                                    <-Map 50 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1792]
-                                                        PartitionCols:_col0
-                                                        Select Operator 
[SEL_1790] (rows=286549727 width=119)
-                                                          
Output:["_col0","_col1","_col2"]
-                                                          Filter Operator 
[FIL_1789] (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_1788]
-                                                                Group By 
Operator [GBY_1787] (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_1779]
-                                                                    Group By 
Operator [GBY_1777] (rows=1 width=12)
-                                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                      Select 
Operator [SEL_1771] (rows=1957 width=4)
-                                                                        
Output:["_col0"]
-                                                                         
Please refer to the previous Select Operator [SEL_1767]
-                                          <-Reducer 44 [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=3856907 width=114)
-                                                    Output:["_col0","_col1"]
-                                                    Merge Join Operator 
[MERGEJOIN_1563] (rows=3856907 width=114)
-                                                      
Conds:RS_1820._col0=RS_1801._col0(Inner),Output:["_col1","_col2"]
-                                                    <-Map 40 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1801]
-                                                        PartitionCols:_col0
-                                                         Please refer to the 
previous Select Operator [SEL_1795]
-                                                    <-Map 51 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1820]
-                                                        PartitionCols:_col0
-                                                        Select Operator 
[SEL_1818] (rows=143966864 width=119)
-                                                          
Output:["_col0","_col1","_col2"]
-                                                          Filter Operator 
[FIL_1817] (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_1816]
-                                                                Group By 
Operator [GBY_1815] (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_1807]
-                                                                    Group By 
Operator [GBY_1805] (rows=1 width=12)
-                                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                      Select 
Operator [SEL_1799] (rows=1957 width=4)
-                                                                        
Output:["_col0"]
-                                                                         
Please refer to the previous Select Operator [SEL_1795]
-                                          <-Reducer 48 [CONTAINS]
-                                            Reduce Output Operator [RS_1586]
-                                              Group By Operator [GBY_1585] 
(rows=1 width=120)
-                                                
Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"]
-                                                Select Operator [SEL_1584] 
(rows=26270325 width=44)
-                                                  Output:["_col0"]
-                                                  Select Operator [SEL_1582] 
(rows=14736682 width=0)
-                                                    Output:["_col0","_col1"]
-                                                    Merge Join Operator 
[MERGEJOIN_1581] (rows=14736682 width=0)
-                                                      
Conds:RS_1827._col0=RS_1642._col0(Inner),Output:["_col1","_col2"]
-                                                    <-Map 84 [SIMPLE_EDGE] 
vectorized
-                                                      PARTITION_ONLY_SHUFFLE 
[RS_1642]
-                                                        PartitionCols:_col0
-                                                         Please refer to the 
previous Select Operator [SEL_1630]
-                                                    <-Map 46 [SIMPLE_EDGE] 
vectorized
-                                                      SHUFFLE [RS_1827]
-                                                        PartitionCols:_col0
-                                                        Select Operator 
[SEL_1825] (rows=550076554 width=114)
-                                                          
Output:["_col0","_col1","_col2"]
-                                                          Filter Operator 
[FIL_1824] (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 99 
[BROADCAST_EDGE] vectorized
-                                                              BROADCAST 
[RS_1823]
-                                                                Group By 
Operator [GBY_1822] (rows=1 width=12)
-                                                                  
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                <-Map 84 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                                  
PARTITION_ONLY_SHUFFLE [RS_1654]
-                                                                    Group By 
Operator [GBY_1649] (rows=1 width=12)
-                                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                      Select 
Operator [SEL_1640] (rows=1957 width=4)
-                                                                        
Output:["_col0"]
-                                                                         
Please refer to the previous Select Operator [SEL_1630]
-                              <-Reducer 62 [CUSTOM_SIMPLE_EDGE] vectorized
-                                PARTITION_ONLY_SHUFFLE [RS_1745]
-                                  Group By Operator [GBY_1744] (rows=1 
width=132)
+                            Filter Operator [FIL_1190] (rows=1 width=244)
+                              predicate:(_col3 > _col5)
+                              Merge Join Operator [MERGEJOIN_1189] (rows=1 
width=244)
+                                
Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
+                              <-Reducer 15 [CUSTOM_SIMPLE_EDGE] vectorized
+                                PARTITION_ONLY_SHUFFLE [RS_1361]
+                                  Group By Operator [GBY_1360] (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_365]
+                                  <-Reducer 14 [SIMPLE_EDGE]
+                                    SHUFFLE [RS_235]
                                       PartitionCols:_col0, _col1, _col2
-                                      Group By Operator [GBY_364] (rows=1 
width=132)
+                                      Group By Operator [GBY_234] (rows=1 
width=132)
                                         
Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0,
 _col1, _col2
-                                        Select Operator [SEL_362] (rows=1 
width=128)
+                                        Select Operator [SEL_232] (rows=1 
width=128)
                                           
Output:["_col0","_col1","_col2","_col3"]
-                                          Merge Join Operator [MERGEJOIN_1441] 
(rows=1 width=128)
-                                            
Conds:RS_359._col1=RS_1708._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9"]
-                                          <-Map 102 [SIMPLE_EDGE] vectorized
-                                            SHUFFLE [RS_1708]
+                                          Merge Join Operator [MERGEJOIN_1162] 
(rows=1 width=128)
+                                            
Conds:RS_229._col1=RS_1330._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9"]
+                                          <-Map 65 [SIMPLE_EDGE] vectorized
+                                            SHUFFLE [RS_1330]
                                               PartitionCols:_col0
-                                              Select Operator [SEL_1699] 
(rows=462000 width=15)
+                                              Select Operator [SEL_1321] 
(rows=462000 width=15)
                                                 
Output:["_col0","_col1","_col2","_col3"]
-                                                TableScan [TS_163] 
(rows=462000 width=15)
+                                                TableScan [TS_81] (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 60 [ONE_TO_ONE_EDGE]
-                                            FORWARD [RS_359]
+                                          <-Reducer 13 [ONE_TO_ONE_EDGE]
+                                            FORWARD [RS_229]
                                               PartitionCols:_col1
-                                              Merge Join Operator 
[MERGEJOIN_1440] (rows=1 width=120)
-                                                
Conds:RS_356._col1=RS_357._col0(Inner),Output:["_col1","_col2","_col3"]
-                                              <-Reducer 59 [SIMPLE_EDGE]
-                                                SHUFFLE [RS_356]
+                                              Merge Join Operator 
[MERGEJOIN_1161] (rows=1 width=120)
+                                                
Conds:RS_226._col1=RS_227._col0(Inner),Output:["_col1","_col2","_col3"]
+                                              <-Reducer 12 [SIMPLE_EDGE]
+                                                SHUFFLE [RS_226]
                                                   PartitionCols:_col1
-                                                  Merge Join Operator 
[MERGEJOIN_1432] (rows=7790806 width=98)
-                                                    
Conds:RS_1739._col0=RS_1675._col0(Inner),Output:["_col1","_col2","_col3"]
-                                                  <-Map 57 [SIMPLE_EDGE] 
vectorized
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_1675]
+                                                  Merge Join Operator 
[MERGEJOIN_1153] (rows=7790806 width=98)
+                                                    
Conds:RS_1355._col0=RS_1297._col0(Inner),Output:["_col1","_col2","_col3"]
+                                                  <-Map 10 [SIMPLE_EDGE] 
vectorized
+                                                    PARTITION_ONLY_SHUFFLE 
[RS_1297]
                                                       PartitionCols:_col0
-                                                      Select Operator 
[SEL_1672] (rows=50 width=4)
+                                                      Select Operator 
[SEL_1294] (rows=50 width=4)
                                                         Output:["_col0"]
-                                                        Filter Operator 
[FIL_1671] (rows=50 width=12)
+                                                        Filter Operator 
[FIL_1293] (rows=50 width=12)
                                                           predicate:((d_moy = 
11) and (d_year = 2000))
-                                                          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_1739]
+                                                  <-Map 79 [SIMPLE_EDGE] 
vectorized
+                                                    SHUFFLE [RS_1355]
                                                       PartitionCols:_col0
-                                                      Select Operator 
[SEL_1738] (rows=286549727 width=123)
+                                                      Select Operator 
[SEL_1354] (rows=286549727 width=123)
                                                         
Output:["_col0","_col1","_col2","_col3"]
-                                                        Filter Operator 
[FIL_1737] (rows=286549727 width=123)
-                                                          
predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_354_date_dim_d_date_sk_min) 
AND DynamicValue(RS_354_date_dim_d_date_sk_max) and 
in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_354_date_dim_d_date_sk_bloom_filter))) and cs_sold_date_sk is 
not null)
-                                                          TableScan [TS_270] 
(rows=287989836 width=123)
+                                                        Filter Operator 
[FIL_1353] (rows=286549727 width=123)
+                                                          
predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_224_date_dim_d_date_sk_min) 
AND DynamicValue(RS_224_date_dim_d_date_sk_max) and 
in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_224_date_dim_d_date_sk_bloom_filter))) and cs_sold_date_sk is 
not null)
+                                                          TableScan [TS_140] 
(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_1736]
-                                                              Group By 
Operator [GBY_1735] (rows=1 width=12)
+                                                          <-Reducer 17 
[BROADCAST_EDGE] vectorized
+                                                            BROADCAST [RS_1352]
+                                                              Group By 
Operator [GBY_1351] (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_1683]
-                                                                  Group By 
Operator [GBY_1680] (rows=1 width=12)
+                                                              <-Map 10 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                                
PARTITION_ONLY_SHUFFLE [RS_1305]
+                                                                  Group By 
Operator [GBY_1302] (rows=1 width=12)
                                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                    Select 
Operator [SEL_1676] (rows=50 width=4)
+                                                                    Select 
Operator [SEL_1298] (rows=50 width=4)
                                                                       
Output:["_col0"]
-                                                                       Please 
refer to the previous Select Operator [SEL_1672]
-                                              <-Reducer 79 [SIMPLE_EDGE]
-                                                SHUFFLE [RS_357]
+                                                                       Please 
refer to the previous Select Operator [SEL_1294]
+                                              <-Reducer 34 [SIMPLE_EDGE]
+                                                SHUFFLE [RS_227]
                                                   PartitionCols:_col0
-                                                  Merge Join Operator 
[MERGEJOIN_1439] (rows=724 width=4)
-                                                    Conds:RS_1716._col1, 
_col2, _col3=RS_1743._col0, _col1, _col2(Inner),Output:["_col0"]
-                                                  <-Map 102 [SIMPLE_EDGE] 
vectorized
-                                                    SHUFFLE [RS_1716]
+                                                  Merge Join Operator 
[MERGEJOIN_1160] (rows=724 width=4)
+                                                    Conds:RS_1338._col1, 
_col2, _col3=RS_1359._col0, _col1, _col2(Inner),Output:["_col0"]
+                                                  <-Map 65 [SIMPLE_EDGE] 
vectorized
+                                                    SHUFFLE [RS_1338]
                                                       PartitionCols:_col1, 
_col2, _col3
-                                                      Select Operator 
[SEL_1709] (rows=458612 width=15)
+                                                      Select Operator 
[SEL_1331] (rows=458612 width=15)
                                                         
Output:["_col0","_col1","_col2","_col3"]
-                                                        Filter Operator 
[FIL_1700] (rows=458612 width=15)
+                                                        Filter Operator 
[FIL_1322] (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)
-                                                           Please refer to the 
previous TableScan [TS_163]
-                                                  <-Reducer 78 
[ONE_TO_ONE_EDGE] vectorized
-                                                    FORWARD [RS_1743]
+                                                           Please refer to the 
previous TableScan [TS_81]
+                                                  <-Reducer 33 
[ONE_TO_ONE_EDGE] vectorized
+                                                    FORWARD [RS_1359]
                                                       PartitionCols:_col0, 
_col1, _col2
-                                                      Select Operator 
[SEL_1742] (rows=1 width=12)
+                                                      Select Operator 
[SEL_1358] (rows=1 width=12)
                                                         
Output:["_col0","_col1","_col2"]
-                                                        Filter Operator 
[FIL_1741] (rows=1 width=20)
+                                                        Filter Operator 
[FIL_1357] (rows=1 width=20)
                                                           predicate:(_col3 = 
3L)
-                                                          Group By Operator 
[GBY_1740] (rows=121728 width=19)
+                                                          Group By Operator 
[GBY_1356] (rows=121728 width=19)
                                                             
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
-                                                          <-Union 77 
[SIMPLE_EDGE]
-                                                            <-Reducer 76 
[CONTAINS] vectorized
-                                                              Reduce Output 
Operator [RS_1839]
+                                                          <-Union 32 
[SIMPLE_EDGE]
+                                                            <-Reducer 31 
[CONTAINS] vectorized
+                                                              Reduce Output 
Operator [RS_1409]
                                                                 
PartitionCols:_col0, _col1, _col2
-                                                                Group By 
Operator [GBY_1838] (rows=121728 width=19)
+                                                                Group By 
Operator [GBY_1408] (rows=121728 width=19)
                                                                   
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_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(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
-                                                                  <-Reducer 71 
[SIMPLE_EDGE]
-                                                                    SHUFFLE 
[RS_296]
+                                                                  <-Reducer 26 
[SIMPLE_EDGE]
+                                                                    SHUFFLE 
[RS_166]
                                                                       
PartitionCols:_col0, _col1, _col2
-                                                                      Group By 
Operator [GBY_107] (rows=121728 width=19)
+                                                                      Group By 
Operator [GBY_25] (rows=121728 width=19)
                                                                         
Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, 
_col5, _col6
-                                                                        Merge 
Join Operator [MERGEJOIN_1418] (rows=14628613 width=11)
-                                                                          
Conds:RS_103._col1=RS_1713._col0(Inner),Output:["_col4","_col5","_col6"]
-                                                                        <-Map 
102 [SIMPLE_EDGE] vectorized
-                                                                          
SHUFFLE [RS_1713]
+                                                                        Merge 
Join Operator [MERGEJOIN_1142] (rows=14628613 width=11)
+                                                                          
Conds:RS_21._col1=RS_1335._col0(Inner),Output:["_col4","_col5","_col6"]
+                                                                        <-Map 
65 [SIMPLE_EDGE] vectorized
+                                                                          
SHUFFLE [RS_1335]
                                                                             
PartitionCols:_col0
-                                                                            
Select Operator [SEL_1705] (rows=458612 width=15)
+                                                                            
Select Operator [SEL_1327] (rows=458612 width=15)
                                                                               
Output:["_col0","_col1","_col2","_col3"]
-                                                                              
Filter Operator [FIL_1696] (rows=458612 width=15)
+                                                                              
Filter Operator [FIL_1318] (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)
-                                                                               
  Please refer to the previous TableScan [TS_163]
-                                                                        
<-Reducer 70 [SIMPLE_EDGE]
-                                                                          
SHUFFLE [RS_103]
+                                                                               
  Please refer to the previous TableScan [TS_81]
+                                                                        
<-Reducer 25 [SIMPLE_EDGE]
+                                                                          
SHUFFLE [RS_21]
                                                                             
PartitionCols:_col1
-                                                                            
Merge Join Operator [MERGEJOIN_1417] (rows=14736682 width=4)
-                                                                              
Conds:RS_1833._col0=RS_1631._col0(Inner),Output:["_col1"]
-                                                                            
<-Map 84 [SIMPLE_EDGE] vectorized
-                                                                              
PARTITION_ONLY_SHUFFLE [RS_1631]
+                                                                            
Merge Join Operator [MERGEJOIN_1141] (rows=14736682 width=4)
+                                                                              
Conds:RS_1403._col0=RS_1381._col0(Inner),Output:["_col1"]
+                                                                            
<-Map 39 [SIMPLE_EDGE] vectorized
+                                                                              
SHUFFLE [RS_1381]
                                                                                
 PartitionCols:_col0
-                                                                               
  Please refer to the previous Select Operator [SEL_1630]
-                                                                            
<-Map 69 [SIMPLE_EDGE] vectorized
-                                                                              
SHUFFLE [RS_1833]
+                                                                               
 Select Operator [SEL_1380] (rows=1957 width=4)
+                                                                               
   Output:["_col0"]
+                                                                               
   Filter Operator [FIL_1379] (rows=1957 width=8)
+                                                                               
     predicate:d_year BETWEEN 1999 AND 2001
+                                                                               
     TableScan [TS_12] (rows=73049 width=8)
+                                                                               
       
default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"]
+                                                                            
<-Map 24 [SIMPLE_EDGE] vectorized
+                                                                              
SHUFFLE [RS_1403]
                                                                                
 PartitionCols:_col0
-                                                                               
 Select Operator [SEL_1832] (rows=550076554 width=7)
+                                                                               
 Select Operator [SEL_1402] (rows=550076554 width=7)
                                                                                
   Output:["_col0","_col1"]
-                                                                               
   Filter Operator [FIL_1831] (rows=550076554 width=7)
-                                                                               
     predicate:((ss_sold_date_sk BETWEEN DynamicValue(RS_101_d1_d_date_sk_min) 
AND DynamicValue(RS_101_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_101_d1_d_date_sk_bloom_filter))) and ss_sold_date_sk is not 
null)
-                                                                               
     TableScan [TS_91] (rows=575995635 width=7)
+                                                                               
   Filter Operator [FIL_1401] (rows=550076554 width=7)
+                                                                               
     predicate:((ss_sold_date_sk BETWEEN DynamicValue(RS_19_d1_d_date_sk_min) 
AND DynamicValue(RS_19_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_19_d1_d_date_sk_bloom_filter))) and ss_sold_date_sk is not null)
+                                                                               
     TableScan [TS_9] (rows=575995635 width=7)
                                                                                
       
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk"]
-                                                                               
     <-Reducer 85 [BROADCAST_EDGE] vectorized
-                                                                               
       BROADCAST [RS_1830]
-                                                                               
         Group By Operator [GBY_1829] (rows=1 width=12)
+                                                                               
     <-Reducer 40 [BROADCAST_EDGE] vectorized
+                                                                               
       BROADCAST [RS_1400]
+                                                                               
         Group By Operator [GBY_1399] (rows=1 width=12)
                                                                                
           
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
         <-Map 84 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
           PARTITION_ONLY_SHUFFLE [RS_1650]
-                                                                               
             Group By Operator [GBY_1645] (rows=1 width=12)
+                                                                               
         <-Map 39 [CUSTOM_SIMPLE_EDGE] vectorized
+                                                                               
           SHUFFLE [RS_1395]
+                                                                               
             Group By Operator [GBY_1391] (rows=1 width=12)
                                                                                
               
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
               Select Operator [SEL_1632] (rows=1957 width=4)
+                                                                               
               Select Operator [SEL_1382] (rows=1957 width=4)
                                                                                
                 Output:["_col0"]
-                                                                               
                  Please refer to the previous Select Operator [SEL_1630]
-                                                            <-Reducer 89 
[CONTAINS] vectorized
-                                                              Reduce Output 
Operator [RS_1853]
+                                                                               
                  Please refer to the previous Select Operator [SEL_1380]
+                                                            <-Reducer 44 
[CONTAINS] vectorized
+                                                              Reduce Output 
Operator [RS_1423]
                                                                 
PartitionCols:_col0, _col1, _col2
-                                                                Group By 
Operator [GBY_1852] (rows=121728 width=19)
+                                                                Group By 
Operator [GBY_1422] (rows=121728 width=19)
                                                                   
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_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(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
-                                                                  <-Reducer 87 
[SIMPLE_EDGE]
-                                                                    SHUFFLE 
[RS_316]
+                                                                  <-Reducer 42 
[SIMPLE_EDGE]
+                                                                    SHUFFLE 
[RS_186]
                                                                       
PartitionCols:_col0, _col1, _col2
-                                                                      Group By 
Operator [GBY_127] (rows=121728 width=19)
+                                                                      Group By 
Operator [GBY_45] (rows=121728 width=19)
                                                                         
Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, 
_col5, _col6
-                                                                        Merge 
Join Operator [MERGEJOIN_1420] (rows=7620440 width=11)
-                                                                          
Conds:RS_123._col1=RS_1714._col0(Inner),Output:["_col4","_col5","_col6"]
-                                                                        <-Map 
102 [SIMPLE_EDGE] vectorized
-                                                                          
SHUFFLE [RS_1714]
+                                                                        Merge 
Join Operator [MERGEJOIN_1144] (rows=7620440 width=11)
+                                                                          
Conds:RS_41._col1=RS_1336._col0(Inner),Output:["_col4","_col5","_col6"]
+                                                                        <-Map 
65 [SIMPLE_EDGE] vectorized
+                                                                          
SHUFFLE [RS_1336]
                                                                             
PartitionCols:_col0
-                                                                            
Select Operator [SEL_1706] (rows=458612 width=15)
+                                                                            
Select Operator [SEL_1328] (rows=458612 width=15)
                                                                               
Output:["_col0","_col1","_col2","_col3"]
-                                                                              
Filter Operator [FIL_1697] (rows=458612 width=15)
+                                                                              
Filter Operator [FIL_1319] (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)
-                                                                               
  Please refer to the previous TableScan [TS_163]
-                                                                        
<-Reducer 86 [SIMPLE_EDGE]
-                                                                          
SHUFFLE [RS_123]
+                                                                               
  Please refer to the previous TableScan [TS_81]
+                                                                        
<-Reducer 41 [SIMPLE_EDGE]
+                                                                          
SHUFFLE [RS_41]
                                                                             
PartitionCols:_col1
-                                                                            
Merge Join Operator [MERGEJOIN_1419] (rows=7676736 width=4)
-                                                                              
Conds:RS_1847._col0=RS_1633._col0(Inner),Output:["_col1"]
-                                                                            
<-Map 84 [SIMPLE_EDGE] vectorized
-                                                                              
PARTITION_ONLY_SHUFFLE [RS_1633]
+                                                                            
Merge Join Operator [MERGEJOIN_1143] (rows=7676736 width=4)
+                                                                              
Conds:RS_1417._col0=RS_1383._col0(Inner),Output:["_col1"]
+                                                                            
<-Map 39 [SIMPLE_EDGE] vectorized
+                                                                              
SHUFFLE [RS_1383]
                                                                                
 PartitionCols:_col0
-                                                                               
  Please refer to the previous Select Operator [SEL_1630]
-                                                                            
<-Map 100 [SIMPLE_EDGE] vectorized
-                                                                              
SHUFFLE [RS_1847]
+                                                                               
  Please refer to the previous Select Operator [SEL_1380]
+                                                                            
<-Map 63 [SIMPLE_EDGE] vectorized
+                                                                              
SHUFFLE [RS_1417]
                                                                                
 PartitionCols:_col0
-                                                                               
 Select Operator [SEL_1846] (rows=286549727 width=7)
+                                                                               
 Select Operator [SEL_1416] (rows=286549727 width=7)
                                                                                
   Output:["_col0","_col1"]
-                                                                               
   Filter Operator [FIL_1845] (rows=286549727 width=7)
-                                                                               
     predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_121_d2_d_date_sk_min) 
AND DynamicValue(RS_121_d2_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_121_d2_d_date_sk_bloom_filter))) and cs_sold_date_sk is not 
null)
-                                                                               
     TableScan [TS_111] (rows=287989836 width=7)
+                                                                               
   Filter Operator [FIL_1415] (rows=286549727 width=7)
+                                                                               
     predicate:((cs_sold_date_sk BETWEEN DynamicValue(RS_39_d2_d_date_sk_min) 
AND DynamicValue(RS_39_d2_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_39_d2_d_date_sk_bloom_filter))) and cs_sold_date_sk is not null)
+                                                                               
     TableScan [TS_29] (rows=287989836 width=7)
                                                                                
       
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk"]
-                                                                               
     <-Reducer 91 [BROADCAST_EDGE] vectorized
-                                                                               
       BROADCAST [RS_1844]
-                                                                               
         Group By Operator [GBY_1843] (rows=1 width=12)
+                                                                               
     <-Reducer 46 [BROADCAST_EDGE] vectorized
+                                                                               
       BROADCAST [RS_1414]
+                                                                               
         Group By Operator [GBY_1413] (rows=1 width=12)
                                                                                
           
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
         <-Map 84 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
           PARTITION_ONLY_SHUFFLE [RS_1651]
-                                                                               
             Group By Operator [GBY_1646] (rows=1 width=12)
+                                                                               
         <-Map 39 [CUSTOM_SIMPLE_EDGE] vectorized
+                                                                               
           SHUFFLE [RS_1396]
+                                                                               
             Group By Operator [GBY_1392] (rows=1 width=12)
                                                                                
               
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
               Select Operator [SEL_1634] (rows=1957 width=4)
+                                                                               
               Select Operator [SEL_1384] (rows=1957 width=4)
                                                                                
                 Output:["_col0"]
-                                                                               
                  Please refer to the previous Select Operator [SEL_1630]
-                                                            <-Reducer 95 
[CONTAINS] vectorized
-                                                              Reduce Output 
Operator [RS_1867]
+                                                                               
                  Please refer to the previous Select Operator [SEL_1380]
+                                                            <-Reducer 50 
[CONTAINS] vectorized
+                                                              Reduce Output 
Operator [RS_1437]
                                                                 
PartitionCols:_col0, _col1, _col2
-                                                                Group By 
Operator [GBY_1866] (rows=121728 width=19)
+                                                                Group By 
Operator [GBY_1436] (rows=121728 width=19)
                                                                   
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0,
 _col1, _col2
-                                                                  Group By 
Operator [GBY_1865] (rows=121728 width=19)
+                                                                  Group By 
Operator [GBY_1435] (rows=121728 width=19)
                                                                     
Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2
-                                                                  <-Reducer 93 
[SIMPLE_EDGE]
-                                                                    SHUFFLE 
[RS_337]
+                                                                  <-Reducer 48 
[SIMPLE_EDGE]
+                                                                    SHUFFLE 
[RS_207]
                                                                       
PartitionCols:_col0, _col1, _col2
-                                                                      Group By 
Operator [GBY_148] (rows=121728 width=19)
+                                                                      Group By 
Operator [GBY_66] (rows=121728 width=19)
                                                                         
Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, 
_col5, _col6
-                                                                        Merge 
Join Operator [MERGEJOIN_1422] (rows=3828623 width=11)
-                                                                          
Conds:RS_144._col1=RS_1715._col0(Inner),Output:["_col4","_col5","_col6"]
-                                                                        <-Map 
102 [SIMPLE_EDGE] vectorized
-                                                                          
SHUFFLE [RS_1715]
+                                                                        Merge 
Join Operator [MERGEJOIN_1146] (rows=3828623 width=11)
+                                                                          
Conds:RS_62._col1=RS_1337._col0(Inner),Output:["_col4","_col5","_col6"]
+                                                                        <-Map 
65 [SIMPLE_EDGE] vectorized
+                                                                          
SHUFFLE [RS_1337]
                                                                             
PartitionCols:_col0
-                                                                            
Select Operator [SEL_1707] (rows=458612 width=15)
+                                                                            
Select Operator [SEL_1329] (rows=458612 width=15)
                                                                               
Output:["_col0","_col1","_col2","_col3"]
-                                                                              
Filter Operator [FIL_1698] (rows=458612 width=15)
+                                                                              
Filter Operator [FIL_1320] (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)
-                                                                               
  Please refer to the previous TableScan [TS_163]
-                                                                        
<-Reducer 92 [SIMPLE_EDGE]
-                                                                          
SHUFFLE [RS_144]
+                                                                               
  Please refer to the previous TableScan [TS_81]
+                                                                        
<-Reducer 47 [SIMPLE_EDGE]
+                                                                          
SHUFFLE [RS_62]
                                                                             
PartitionCols:_col1
-                                                                            
Merge Join Operator [MERGEJOIN_1421] (rows=3856907 width=4)
-                                                                              
Conds:RS_1861._col0=RS_1635._col0(Inner),Output:["_col1"]
-                                                                            
<-Map 84 [SIMPLE_EDGE] vectorized
-                                                                              
PARTITION_ONLY_SHUFFLE [RS_1635]
+                                                                            
Merge Join Operator [MERGEJOIN_1145] (rows=3856907 width=4)
+                                                                              
Conds:RS_1431._col0=RS_1385._col0(Inner),Output:["_col1"]
+                                                                            
<-Map 39 [SIMPLE_EDGE] vectorized
+                                                                              
SHUFFLE [RS_1385]
                                                                                
 PartitionCols:_col0
-                                                                               
  Please refer to the previous Select Operator [SEL_1630]
-                                                                            
<-Map 101 [SIMPLE_EDGE] vectorized
-                                                                              
SHUFFLE [RS_1861]
+                                                                               
  Please refer to the previous Select Operator [SEL_1380]
+                                                                            
<-Map 64 [SIMPLE_EDGE] vectorized
+                                                                              
SHUFFLE [RS_1431]
                                                                                
 PartitionCols:_col0
-                                                                               
 Select Operator [SEL_1860] (rows=143966864 width=7)
+                                                                               
 Select Operator [SEL_1430] (rows=143966864 width=7)
                                                                                
   Output:["_col0","_col1"]
-                                                                               
   Filter Operator [FIL_1859] (rows=143966864 width=7)
-                                                                               
     predicate:((ws_sold_date_sk BETWEEN DynamicValue(RS_142_d3_d_date_sk_min) 
AND DynamicValue(RS_142_d3_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_142_d3_d_date_sk_bloom_filter))) and ws_sold_date_sk is not 
null)
-                                                                               
     TableScan [TS_132] (rows=144002668 width=7)
+                                                                               
   Filter Operator [FIL_1429] (rows=143966864 width=7)
+                                                                               
     predicate:((ws_sold_date_sk BETWEEN DynamicValue(RS_60_d3_d_date_sk_min) 
AND DynamicValue(RS_60_d3_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_60_d3_d_date_sk_bloom_filter))) and ws_sold_date_sk is not null)
+                                                                               
     TableScan [TS_50] (rows=144002668 width=7)
                                                                                
       
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk"]
-                                                                               
     <-Reducer 97 [BROADCAST_EDGE] vectorized
-                                                                               
       BROADCAST [RS_1858]
-                                                                               
         Group By Operator [GBY_1857] (rows=1 width=12)
+                                                                               
     <-Reducer 52 [BROADCAST_EDGE] vectorized
+                                                                               
       BROADCAST [RS_1428]
+                                                                               
         Group By Operator [GBY_1427] (rows=1 width=12)
                                                                                
           
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                                               
         <-Map 84 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                               
           PARTITION_ONLY_SHUFFLE [RS_1652]
-                                                                               
             Group By Operator [GBY_1647] (rows=1 width=12)
+                                                                               
         <-Map 39 [CUSTOM_SIMPLE_EDGE] vectorized
+                                                                               
           SHUFFLE [RS_1397]
+                                                                               
             Group By Operator [GBY_1393] (rows=1 width=12)
                                                                                
               
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
               Select Operator [SEL_1636] (rows=1957 width=4)
+                                                                               
               Select Operator [SEL_1386] (rows=1957 width=4)
                                                                                
                 Output:["_col0"]
-                                                                               
                  Please refer to the previous Select Operator [SEL_1630]
-                  <-Reducer 19 [CONTAINS]
-                    Reduce Output Operator [RS_1502]
+                                                                               
                  Please refer to the previous Select Operator [SEL_1380]
+                              <-Reducer 59 [CUSTOM_SIMPLE_EDGE] vectorized
+                                PARTITION_ONLY_SHUFFLE [RS_1364]
+                                  Select Operator [SEL_1363] (rows=1 width=112)
+                                    Output:["_col0"]
+                                    Group By Operator [GBY_1362] (rows=1 
width=120)
+                                      
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"]
+                                    <-Union 58 [CUSTOM_SIMPLE_EDGE]
+                                      <-Reducer 57 [CONTAINS]
+                                        Reduce Output Operator [RS_1250]
+                                          Group By Operator [GBY_1249] (rows=1 
width=120)
+                                            
Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"]
+                                            Select Operator [SEL_1248] 
(rows=26270325 width=44)
+                                              Output:["_col0"]
+                                              Select Operator [SEL_1246] 
(rows=14736682 width=0)
+                                                Output:["_col0","_col1"]
+                                                Merge Join Operator 
[MERGEJOIN_1245] (rows=14736682 width=0)
+                                                  
Conds:RS_1446._col0=RS_1389._col0(Inner),Output:["_col1","_col2"]
+                                                <-Map 39 [SIMPLE_EDGE] 
vectorized
+                                                  SHUFFLE [RS_1389]
+                                                    PartitionCols:_col0
+                                                     Please refer to the 
previous 

<TRUNCATED>

Reply via email to