http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/constraints/query20.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query20.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query20.q.out
index da3e262..d3ecdac 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query20.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query20.q.out
@@ -65,8 +65,7 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 10 (BROADCAST_EDGE), Reducer 8 (BROADCAST_EDGE)
-Reducer 10 <- Map 9 (CUSTOM_SIMPLE_EDGE)
+Map 1 <- Reducer 8 (BROADCAST_EDGE)
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 7 (SIMPLE_EDGE)
 Reducer 3 <- Map 9 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
 Reducer 4 <- Reducer 3 (SIMPLE_EDGE)
@@ -79,23 +78,23 @@ Stage-0
     limit:-1
     Stage-1
       Reducer 6 vectorized
-      File Output Operator [FS_86]
-        Limit [LIM_85] (rows=100 width=802)
+      File Output Operator [FS_81]
+        Limit [LIM_80] (rows=100 width=802)
           Number of rows:100
-          Select Operator [SEL_84] (rows=138600 width=801)
+          Select Operator [SEL_79] (rows=138600 width=801)
             Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
           <-Reducer 5 [SIMPLE_EDGE] vectorized
-            SHUFFLE [RS_83]
-              Select Operator [SEL_82] (rows=138600 width=801)
+            SHUFFLE [RS_78]
+              Select Operator [SEL_77] (rows=138600 width=801)
                 
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"]
-                PTF Operator [PTF_81] (rows=138600 width=689)
+                PTF Operator [PTF_76] (rows=138600 width=689)
                   Function 
definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS 
FIRST","partition by:":"_col1"}]
-                  Select Operator [SEL_80] (rows=138600 width=689)
+                  Select Operator [SEL_75] (rows=138600 width=689)
                     Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
                   <-Reducer 4 [SIMPLE_EDGE] vectorized
-                    SHUFFLE [RS_79]
+                    SHUFFLE [RS_74]
                       PartitionCols:_col1
-                      Group By Operator [GBY_78] (rows=138600 width=689)
+                      Group By Operator [GBY_73] (rows=138600 width=689)
                         
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2, KEY._col3, KEY._col4
                       <-Reducer 3 [SIMPLE_EDGE]
                         SHUFFLE [RS_17]
@@ -103,13 +102,13 @@ Stage-0
                           Group By Operator [GBY_16] (rows=138600 width=689)
                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9,
 _col8, _col5, _col6, _col7
                             Merge Join Operator [MERGEJOIN_58] (rows=9551005 
width=673)
-                              
Conds:RS_12._col1=RS_69._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"]
+                              
Conds:RS_12._col1=RS_72._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"]
                             <-Map 9 [SIMPLE_EDGE] vectorized
-                              SHUFFLE [RS_69]
+                              SHUFFLE [RS_72]
                                 PartitionCols:_col0
-                                Select Operator [SEL_68] (rows=138600 
width=581)
+                                Select Operator [SEL_71] (rows=138600 
width=581)
                                   
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
-                                  Filter Operator [FIL_67] (rows=138600 
width=581)
+                                  Filter Operator [FIL_70] (rows=138600 
width=581)
                                     predicate:(i_category) IN ('Jewelry', 
'Sports', 'Books')
                                     TableScan [TS_6] (rows=462000 width=581)
                                       
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"]
@@ -117,7 +116,7 @@ Stage-0
                               SHUFFLE [RS_12]
                                 PartitionCols:_col1
                                 Merge Join Operator [MERGEJOIN_57] 
(rows=31836679 width=110)
-                                  
Conds:RS_77._col0=RS_61._col0(Inner),Output:["_col1","_col2"]
+                                  
Conds:RS_69._col0=RS_61._col0(Inner),Output:["_col1","_col2"]
                                 <-Map 7 [SIMPLE_EDGE] vectorized
                                   PARTITION_ONLY_SHUFFLE [RS_61]
                                     PartitionCols:_col0
@@ -128,25 +127,14 @@ Stage-0
                                         TableScan [TS_3] (rows=73049 width=98)
                                           
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"]
                                 <-Map 1 [SIMPLE_EDGE] vectorized
-                                  SHUFFLE [RS_77]
+                                  SHUFFLE [RS_69]
                                     PartitionCols:_col0
-                                    Select Operator [SEL_76] (rows=286549727 
width=119)
+                                    Select Operator [SEL_68] (rows=286549727 
width=119)
                                       Output:["_col0","_col1","_col2"]
-                                      Filter Operator [FIL_75] (rows=286549727 
width=119)
-                                        predicate:((cs_item_sk BETWEEN 
DynamicValue(RS_13_item_i_item_sk_min) AND 
DynamicValue(RS_13_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, 
DynamicValue(RS_13_item_i_item_sk_bloom_filter))) and (cs_sold_date_sk BETWEEN 
DynamicValue(RS_10_date_dim_d_date_sk_min) AND 
DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) and cs_sold_date_sk is 
not null)
+                                      Filter Operator [FIL_67] (rows=286549727 
width=119)
+                                        predicate:((cs_sold_date_sk BETWEEN 
DynamicValue(RS_10_date_dim_d_date_sk_min) AND 
DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) and cs_sold_date_sk is 
not null)
                                         TableScan [TS_0] (rows=287989836 
width=119)
                                           
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_ext_sales_price"]
-                                        <-Reducer 10 [BROADCAST_EDGE] 
vectorized
-                                          BROADCAST [RS_74]
-                                            Group By Operator [GBY_73] (rows=1 
width=12)
-                                              
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                            <-Map 9 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                              SHUFFLE [RS_72]
-                                                Group By Operator [GBY_71] 
(rows=1 width=12)
-                                                  
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                  Select Operator [SEL_70] 
(rows=138600 width=4)
-                                                    Output:["_col0"]
-                                                     Please refer to the 
previous Select Operator [SEL_68]
                                         <-Reducer 8 [BROADCAST_EDGE] vectorized
                                           BROADCAST [RS_66]
                                             Group By Operator [GBY_65] (rows=1 
width=12)

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out
index 292c920..7678363 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query23.q.out
@@ -121,15 +121,15 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 31 (BROADCAST_EDGE), Reducer 9 (BROADCAST_EDGE)
+Map 1 <- Reducer 9 (BROADCAST_EDGE)
 Map 15 <- Reducer 27 (BROADCAST_EDGE)
-Map 35 <- Reducer 7 (BROADCAST_EDGE)
-Map 37 <- Reducer 34 (BROADCAST_EDGE)
-Map 39 <- Reducer 14 (BROADCAST_EDGE), Reducer 33 (BROADCAST_EDGE)
-Map 40 <- Reducer 13 (BROADCAST_EDGE)
-Reducer 10 <- Map 39 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
+Map 33 <- Reducer 7 (BROADCAST_EDGE)
+Map 35 <- Reducer 32 (BROADCAST_EDGE)
+Map 37 <- Reducer 14 (BROADCAST_EDGE)
+Map 38 <- Reducer 13 (BROADCAST_EDGE)
+Reducer 10 <- Map 37 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
 Reducer 11 <- Reducer 10 (SIMPLE_EDGE), Reducer 24 (SIMPLE_EDGE)
-Reducer 12 <- Reducer 11 (SIMPLE_EDGE), Reducer 32 (ONE_TO_ONE_EDGE), Union 5 
(CONTAINS)
+Reducer 12 <- Reducer 11 (SIMPLE_EDGE), Reducer 31 (ONE_TO_ONE_EDGE), Union 5 
(CONTAINS)
 Reducer 13 <- Reducer 10 (CUSTOM_SIMPLE_EDGE)
 Reducer 14 <- Map 8 (CUSTOM_SIMPLE_EDGE)
 Reducer 16 <- Map 15 (SIMPLE_EDGE), Map 26 (SIMPLE_EDGE)
@@ -137,24 +137,22 @@ Reducer 17 <- Reducer 16 (SIMPLE_EDGE)
 Reducer 18 <- Reducer 17 (CUSTOM_SIMPLE_EDGE)
 Reducer 19 <- Reducer 18 (CUSTOM_SIMPLE_EDGE), Reducer 21 (CUSTOM_SIMPLE_EDGE)
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 8 (SIMPLE_EDGE)
-Reducer 20 <- Reducer 19 (CUSTOM_SIMPLE_EDGE), Reducer 36 (CUSTOM_SIMPLE_EDGE)
+Reducer 20 <- Reducer 19 (CUSTOM_SIMPLE_EDGE), Reducer 34 (CUSTOM_SIMPLE_EDGE)
 Reducer 21 <- Reducer 17 (CUSTOM_SIMPLE_EDGE)
 Reducer 22 <- Reducer 17 (CUSTOM_SIMPLE_EDGE)
 Reducer 23 <- Reducer 22 (CUSTOM_SIMPLE_EDGE), Reducer 25 (CUSTOM_SIMPLE_EDGE)
-Reducer 24 <- Reducer 23 (CUSTOM_SIMPLE_EDGE), Reducer 41 (CUSTOM_SIMPLE_EDGE)
+Reducer 24 <- Reducer 23 (CUSTOM_SIMPLE_EDGE), Reducer 39 (CUSTOM_SIMPLE_EDGE)
 Reducer 25 <- Reducer 17 (CUSTOM_SIMPLE_EDGE)
 Reducer 27 <- Map 26 (CUSTOM_SIMPLE_EDGE)
-Reducer 28 <- Map 26 (SIMPLE_EDGE), Map 37 (SIMPLE_EDGE)
-Reducer 29 <- Map 38 (SIMPLE_EDGE), Reducer 28 (SIMPLE_EDGE)
+Reducer 28 <- Map 26 (SIMPLE_EDGE), Map 35 (SIMPLE_EDGE)
+Reducer 29 <- Map 36 (SIMPLE_EDGE), Reducer 28 (SIMPLE_EDGE)
 Reducer 3 <- Reducer 2 (SIMPLE_EDGE), Reducer 20 (SIMPLE_EDGE)
 Reducer 30 <- Reducer 29 (SIMPLE_EDGE)
-Reducer 31 <- Reducer 30 (CUSTOM_SIMPLE_EDGE)
-Reducer 32 <- Reducer 29 (SIMPLE_EDGE)
-Reducer 33 <- Reducer 32 (CUSTOM_SIMPLE_EDGE)
-Reducer 34 <- Map 26 (CUSTOM_SIMPLE_EDGE)
-Reducer 36 <- Map 35 (SIMPLE_EDGE)
+Reducer 31 <- Reducer 29 (SIMPLE_EDGE)
+Reducer 32 <- Map 26 (CUSTOM_SIMPLE_EDGE)
+Reducer 34 <- Map 33 (SIMPLE_EDGE)
+Reducer 39 <- Map 38 (SIMPLE_EDGE)
 Reducer 4 <- Reducer 3 (SIMPLE_EDGE), Reducer 30 (ONE_TO_ONE_EDGE), Union 5 
(CONTAINS)
-Reducer 41 <- Map 40 (SIMPLE_EDGE)
 Reducer 6 <- Union 5 (CUSTOM_SIMPLE_EDGE)
 Reducer 7 <- Reducer 2 (CUSTOM_SIMPLE_EDGE)
 Reducer 9 <- Map 8 (CUSTOM_SIMPLE_EDGE)
@@ -164,10 +162,10 @@ Stage-0
     limit:100
     Stage-1
       Reducer 6 vectorized
-      File Output Operator [FS_532]
-        Limit [LIM_531] (rows=1 width=112)
+      File Output Operator [FS_527]
+        Limit [LIM_526] (rows=1 width=112)
           Number of rows:100
-          Group By Operator [GBY_530] (rows=1 width=112)
+          Group By Operator [GBY_525] (rows=1 width=112)
             Output:["_col0"],aggregations:["sum(VALUE._col0)"]
           <-Union 5 [CUSTOM_SIMPLE_EDGE]
             <-Reducer 12 [CONTAINS]
@@ -177,64 +175,7 @@ Stage-0
                   Select Operator [SEL_451] (rows=52 width=112)
                     Output:["_col0"]
                     Merge Join Operator [MERGEJOIN_450] (rows=52 width=2)
-                      
Conds:RS_192._col1=RS_538._col0(Inner),Output:["_col3","_col4"]
-                    <-Reducer 32 [ONE_TO_ONE_EDGE] vectorized
-                      PARTITION_ONLY_SHUFFLE [RS_538]
-                        PartitionCols:_col0
-                        Select Operator [SEL_537] (rows=745 width=4)
-                          Output:["_col0"]
-                          Filter Operator [FIL_536] (rows=745 width=12)
-                            predicate:(_col1 > 4L)
-                            Group By Operator [GBY_535] (rows=2235 width=12)
-                              
Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0
-                            <-Reducer 29 [SIMPLE_EDGE]
-                              SHUFFLE [RS_182]
-                                PartitionCols:_col0
-                                Group By Operator [GBY_83] (rows=2235 width=12)
-                                  
Output:["_col0","_col1"],aggregations:["count()"],keys:_col4
-                                  Merge Join Operator [MERGEJOIN_431] 
(rows=19646398 width=4)
-                                    
Conds:RS_79._col1=RS_483._col0(Inner),Output:["_col4"]
-                                  <-Map 38 [SIMPLE_EDGE] vectorized
-                                    SHUFFLE [RS_483]
-                                      PartitionCols:_col0
-                                      Select Operator [SEL_482] (rows=462000 
width=188)
-                                        Output:["_col0"]
-                                        TableScan [TS_74] (rows=462000 width=4)
-                                          
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk"]
-                                  <-Reducer 28 [SIMPLE_EDGE]
-                                    SHUFFLE [RS_79]
-                                      PartitionCols:_col1
-                                      Merge Join Operator [MERGEJOIN_430] 
(rows=19646398 width=4)
-                                        
Conds:RS_481._col0=RS_471._col0(Inner),Output:["_col1"]
-                                      <-Map 26 [SIMPLE_EDGE] vectorized
-                                        PARTITION_ONLY_SHUFFLE [RS_471]
-                                          PartitionCols:_col0
-                                          Select Operator [SEL_468] (rows=2609 
width=4)
-                                            Output:["_col0"]
-                                            Filter Operator [FIL_467] 
(rows=2609 width=8)
-                                              predicate:(d_year) IN (1999, 
2000, 2001, 2002)
-                                              TableScan [TS_9] (rows=73049 
width=8)
-                                                
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"]
-                                      <-Map 37 [SIMPLE_EDGE] vectorized
-                                        SHUFFLE [RS_481]
-                                          PartitionCols:_col0
-                                          Select Operator [SEL_480] 
(rows=550076554 width=7)
-                                            Output:["_col0","_col1"]
-                                            Filter Operator [FIL_479] 
(rows=550076554 width=7)
-                                              predicate:((ss_sold_date_sk 
BETWEEN DynamicValue(RS_77_date_dim_d_date_sk_min) AND 
DynamicValue(RS_77_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_77_date_dim_d_date_sk_bloom_filter))) and ss_sold_date_sk is 
not null)
-                                              TableScan [TS_68] 
(rows=575995635 width=7)
-                                                
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk"]
-                                              <-Reducer 34 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_478]
-                                                  Group By Operator [GBY_477] 
(rows=1 width=12)
-                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                  <-Map 26 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                    PARTITION_ONLY_SHUFFLE 
[RS_476]
-                                                      Group By Operator 
[GBY_474] (rows=1 width=12)
-                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                        Select Operator 
[SEL_472] (rows=2609 width=4)
-                                                          Output:["_col0"]
-                                                           Please refer to the 
previous Select Operator [SEL_468]
+                      
Conds:RS_192._col1=RS_552._col0(Inner),Output:["_col3","_col4"]
                     <-Reducer 11 [SIMPLE_EDGE]
                       SHUFFLE [RS_192]
                         PartitionCols:_col1
@@ -244,7 +185,7 @@ Stage-0
                           PARTITION_ONLY_SHUFFLE [RS_189]
                             PartitionCols:_col2
                             Merge Join Operator [MERGEJOIN_432] (rows=3941102 
width=122)
-                              
Conds:RS_546._col0=RS_459._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
+                              
Conds:RS_532._col0=RS_459._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
                             <-Map 8 [SIMPLE_EDGE] vectorized
                               PARTITION_ONLY_SHUFFLE [RS_459]
                                 PartitionCols:_col0
@@ -254,18 +195,18 @@ Stage-0
                                     predicate:((d_moy = 1) and (d_year = 1999))
                                     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 39 [SIMPLE_EDGE] vectorized
-                              SHUFFLE [RS_546]
+                            <-Map 37 [SIMPLE_EDGE] vectorized
+                              SHUFFLE [RS_532]
                                 PartitionCols:_col0
-                                Select Operator [SEL_545] (rows=143930993 
width=127)
+                                Select Operator [SEL_531] (rows=143930993 
width=127)
                                   
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                  Filter Operator [FIL_544] (rows=143930993 
width=127)
-                                    predicate:((ws_item_sk BETWEEN 
DynamicValue(RS_193_item_i_item_sk_min) AND 
DynamicValue(RS_193_item_i_item_sk_max) and in_bloom_filter(ws_item_sk, 
DynamicValue(RS_193_item_i_item_sk_bloom_filter))) and (ws_sold_date_sk BETWEEN 
DynamicValue(RS_187_date_dim_d_date_sk_min) AND 
DynamicValue(RS_187_date_dim_d_date_sk_max) and 
in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_187_date_dim_d_date_sk_bloom_filter))) and ws_bill_customer_sk 
is not null and ws_sold_date_sk is not null)
+                                  Filter Operator [FIL_530] (rows=143930993 
width=127)
+                                    predicate:((ws_sold_date_sk BETWEEN 
DynamicValue(RS_187_date_dim_d_date_sk_min) AND 
DynamicValue(RS_187_date_dim_d_date_sk_max) and 
in_bloom_filter(ws_sold_date_sk, 
DynamicValue(RS_187_date_dim_d_date_sk_bloom_filter))) and ws_bill_customer_sk 
is not null and ws_sold_date_sk is not null)
                                     TableScan [TS_98] (rows=144002668 
width=127)
                                       
default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk","ws_quantity","ws_list_price"]
                                     <-Reducer 14 [BROADCAST_EDGE] vectorized
-                                      BROADCAST [RS_534]
-                                        Group By Operator [GBY_533] (rows=1 
width=12)
+                                      BROADCAST [RS_529]
+                                        Group By Operator [GBY_528] (rows=1 
width=12)
                                           
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                         <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized
                                           PARTITION_ONLY_SHUFFLE [RS_464]
@@ -274,17 +215,6 @@ Stage-0
                                               Select Operator [SEL_460] 
(rows=50 width=4)
                                                 Output:["_col0"]
                                                  Please refer to the previous 
Select Operator [SEL_456]
-                                    <-Reducer 33 [BROADCAST_EDGE] vectorized
-                                      BROADCAST [RS_543]
-                                        Group By Operator [GBY_542] (rows=1 
width=12)
-                                          
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                        <-Reducer 32 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_541]
-                                            Group By Operator [GBY_540] 
(rows=1 width=12)
-                                              
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                              Select Operator [SEL_539] 
(rows=745 width=4)
-                                                Output:["_col0"]
-                                                 Please refer to the previous 
Select Operator [SEL_537]
                         <-Reducer 24 [SIMPLE_EDGE]
                           SHUFFLE [RS_190]
                             PartitionCols:_col0
@@ -299,22 +229,22 @@ Stage-0
                                     Merge Join Operator [MERGEJOIN_440] 
(rows=1 width=112)
                                       Conds:(Inner),Output:["_col1"]
                                     <-Reducer 22 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                      PARTITION_ONLY_SHUFFLE [RS_552]
-                                        Select Operator [SEL_551] (rows=1 
width=8)
-                                          Filter Operator [FIL_550] (rows=1 
width=8)
+                                      PARTITION_ONLY_SHUFFLE [RS_538]
+                                        Select Operator [SEL_537] (rows=1 
width=8)
+                                          Filter Operator [FIL_536] (rows=1 
width=8)
                                             predicate:(sq_count_check(_col0) 
<= 1)
-                                            Group By Operator [GBY_549] 
(rows=1 width=8)
+                                            Group By Operator [GBY_535] 
(rows=1 width=8)
                                               
Output:["_col0"],aggregations:["count()"]
-                                              Select Operator [SEL_548] 
(rows=1 width=8)
-                                                Group By Operator [GBY_547] 
(rows=1 width=8)
+                                              Select Operator [SEL_534] 
(rows=1 width=8)
+                                                Group By Operator [GBY_533] 
(rows=1 width=8)
                                                   
Output:["_col0"],aggregations:["count(VALUE._col0)"]
                                                 <-Reducer 17 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                  PARTITION_ONLY_SHUFFLE 
[RS_512]
-                                                    Group By Operator 
[GBY_508] (rows=1 width=8)
+                                                  PARTITION_ONLY_SHUFFLE 
[RS_496]
+                                                    Group By Operator 
[GBY_492] (rows=1 width=8)
                                                       
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_504] (rows=50562 width=112)
+                                                      Select Operator 
[SEL_488] (rows=50562 width=112)
                                                         Output:["_col0"]
-                                                        Group By Operator 
[GBY_501] (rows=50562 width=112)
+                                                        Group By Operator 
[GBY_485] (rows=50562 width=112)
                                                           
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
                                                         <-Reducer 16 
[SIMPLE_EDGE]
                                                           SHUFFLE [RS_17]
@@ -322,60 +252,65 @@ Stage-0
                                                             Group By Operator 
[GBY_16] (rows=455058 width=112)
                                                               
Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col1
                                                               Merge Join 
Operator [MERGEJOIN_428] (rows=18762463 width=112)
-                                                                
Conds:RS_500._col0=RS_469._col0(Inner),Output:["_col1","_col2"]
+                                                                
Conds:RS_484._col0=RS_472._col0(Inner),Output:["_col1","_col2"]
                                                               <-Map 26 
[SIMPLE_EDGE] vectorized
-                                                                
PARTITION_ONLY_SHUFFLE [RS_469]
+                                                                
PARTITION_ONLY_SHUFFLE [RS_472]
                                                                   
PartitionCols:_col0
-                                                                   Please 
refer to the previous Select Operator [SEL_468]
+                                                                  Select 
Operator [SEL_471] (rows=2609 width=4)
+                                                                    
Output:["_col0"]
+                                                                    Filter 
Operator [FIL_470] (rows=2609 width=8)
+                                                                      
predicate:(d_year) IN (1999, 2000, 2001, 2002)
+                                                                      
TableScan [TS_9] (rows=73049 width=8)
+                                                                        
default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"]
                                                               <-Map 15 
[SIMPLE_EDGE] vectorized
-                                                                SHUFFLE 
[RS_500]
+                                                                SHUFFLE 
[RS_484]
                                                                   
PartitionCols:_col0
-                                                                  Select 
Operator [SEL_499] (rows=525327388 width=119)
+                                                                  Select 
Operator [SEL_483] (rows=525327388 width=119)
                                                                     
Output:["_col0","_col1","_col2"]
-                                                                    Filter 
Operator [FIL_498] (rows=525327388 width=118)
+                                                                    Filter 
Operator [FIL_482] (rows=525327388 width=118)
                                                                       
predicate:((ss_sold_date_sk BETWEEN DynamicValue(RS_13_date_dim_d_date_sk_min) 
AND DynamicValue(RS_13_date_dim_d_date_sk_max) and 
in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_sold_date_sk is not null)
                                                                       
TableScan [TS_6] (rows=575995635 width=118)
                                                                         
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_quantity","ss_sales_price"]
                                                                       
<-Reducer 27 [BROADCAST_EDGE] vectorized
-                                                                        
BROADCAST [RS_497]
-                                                                          
Group By Operator [GBY_496] (rows=1 width=12)
+                                                                        
BROADCAST [RS_481]
+                                                                          
Group By Operator [GBY_480] (rows=1 width=12)
                                                                             
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                                                           
<-Map 26 [CUSTOM_SIMPLE_EDGE] vectorized
-                                                                            
PARTITION_ONLY_SHUFFLE [RS_475]
-                                                                              
Group By Operator [GBY_473] (rows=1 width=12)
+                                                                            
PARTITION_ONLY_SHUFFLE [RS_478]
+                                                                              
Group By Operator [GBY_476] (rows=1 width=12)
                                                                                
 
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                                               
 Select Operator [SEL_470] (rows=2609 width=4)
+                                                                               
 Select Operator [SEL_473] (rows=2609 width=4)
                                                                                
   Output:["_col0"]
-                                                                               
    Please refer to the previous Select Operator [SEL_468]
+                                                                               
    Please refer to the previous Select Operator [SEL_471]
                                     <-Reducer 25 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                      PARTITION_ONLY_SHUFFLE [RS_554]
-                                        Group By Operator [GBY_553] (rows=1 
width=112)
+                                      PARTITION_ONLY_SHUFFLE [RS_540]
+                                        Group By Operator [GBY_539] (rows=1 
width=112)
                                           
Output:["_col0"],aggregations:["max(VALUE._col0)"]
                                         <-Reducer 17 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_513]
-                                            Group By Operator [GBY_509] 
(rows=1 width=112)
+                                          PARTITION_ONLY_SHUFFLE [RS_497]
+                                            Group By Operator [GBY_493] 
(rows=1 width=112)
                                               
Output:["_col0"],aggregations:["max(_col1)"]
-                                              Select Operator [SEL_505] 
(rows=50562 width=112)
+                                              Select Operator [SEL_489] 
(rows=50562 width=112)
                                                 Output:["_col1"]
-                                                 Please refer to the previous 
Group By Operator [GBY_501]
-                                <-Reducer 41 [CUSTOM_SIMPLE_EDGE] vectorized
-                                  PARTITION_ONLY_SHUFFLE [RS_562]
-                                    Group By Operator [GBY_561] (rows=1415626 
width=115)
+                                                 Please refer to the previous 
Group By Operator [GBY_485]
+                                <-Reducer 39 [CUSTOM_SIMPLE_EDGE] vectorized
+                                  PARTITION_ONLY_SHUFFLE [RS_548]
+                                    Group By Operator [GBY_547] (rows=1415626 
width=115)
                                       
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
-                                    <-Map 40 [SIMPLE_EDGE] vectorized
-                                      SHUFFLE [RS_560]
+                                    <-Map 38 [SIMPLE_EDGE] vectorized
+                                      SHUFFLE [RS_546]
                                         PartitionCols:_col0
-                                        Group By Operator [GBY_559] 
(rows=550080312 width=115)
+                                        Group By Operator [GBY_545] 
(rows=550080312 width=115)
                                           
Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0
-                                          Select Operator [SEL_558] 
(rows=550080312 width=114)
+                                          Select Operator [SEL_544] 
(rows=550080312 width=114)
                                             Output:["_col0","_col1"]
-                                            Filter Operator [FIL_557] 
(rows=550080312 width=114)
+                                            Filter Operator [FIL_543] 
(rows=550080312 width=114)
                                               predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_189_web_sales_ws_bill_customer_sk_min) AND 
DynamicValue(RS_189_web_sales_ws_bill_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_189_web_sales_ws_bill_customer_sk_bloom_filter))) and 
ss_customer_sk is not null)
                                               TableScan [TS_150] 
(rows=575995635 width=114)
                                                 
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_customer_sk","ss_quantity","ss_sales_price"]
                                               <-Reducer 13 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_556]
-                                                  Group By Operator [GBY_555] 
(rows=1 width=12)
+                                                BROADCAST [RS_542]
+                                                  Group By Operator [GBY_541] 
(rows=1 width=12)
                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                                   <-Reducer 10 
[CUSTOM_SIMPLE_EDGE]
                                                     PARTITION_ONLY_SHUFFLE 
[RS_406]
@@ -384,6 +319,58 @@ Stage-0
                                                         Select Operator 
[SEL_404] (rows=3941102 width=7)
                                                           Output:["_col0"]
                                                            Please refer to the 
previous Merge Join Operator [MERGEJOIN_432]
+                    <-Reducer 31 [ONE_TO_ONE_EDGE] vectorized
+                      FORWARD [RS_552]
+                        PartitionCols:_col0
+                        Select Operator [SEL_551] (rows=745 width=4)
+                          Output:["_col0"]
+                          Filter Operator [FIL_550] (rows=745 width=12)
+                            predicate:(_col1 > 4L)
+                            Group By Operator [GBY_549] (rows=2235 width=12)
+                              
Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0
+                            <-Reducer 29 [SIMPLE_EDGE]
+                              SHUFFLE [RS_182]
+                                PartitionCols:_col0
+                                Group By Operator [GBY_83] (rows=2235 width=12)
+                                  
Output:["_col0","_col1"],aggregations:["count()"],keys:_col4
+                                  Merge Join Operator [MERGEJOIN_431] 
(rows=19646398 width=4)
+                                    
Conds:RS_79._col1=RS_520._col0(Inner),Output:["_col4"]
+                                  <-Map 36 [SIMPLE_EDGE] vectorized
+                                    SHUFFLE [RS_520]
+                                      PartitionCols:_col0
+                                      Select Operator [SEL_519] (rows=462000 
width=188)
+                                        Output:["_col0"]
+                                        TableScan [TS_74] (rows=462000 width=4)
+                                          
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk"]
+                                  <-Reducer 28 [SIMPLE_EDGE]
+                                    SHUFFLE [RS_79]
+                                      PartitionCols:_col1
+                                      Merge Join Operator [MERGEJOIN_430] 
(rows=19646398 width=4)
+                                        
Conds:RS_518._col0=RS_474._col0(Inner),Output:["_col1"]
+                                      <-Map 26 [SIMPLE_EDGE] vectorized
+                                        PARTITION_ONLY_SHUFFLE [RS_474]
+                                          PartitionCols:_col0
+                                           Please refer to the previous Select 
Operator [SEL_471]
+                                      <-Map 35 [SIMPLE_EDGE] vectorized
+                                        SHUFFLE [RS_518]
+                                          PartitionCols:_col0
+                                          Select Operator [SEL_517] 
(rows=550076554 width=7)
+                                            Output:["_col0","_col1"]
+                                            Filter Operator [FIL_516] 
(rows=550076554 width=7)
+                                              predicate:((ss_sold_date_sk 
BETWEEN DynamicValue(RS_77_date_dim_d_date_sk_min) AND 
DynamicValue(RS_77_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, 
DynamicValue(RS_77_date_dim_d_date_sk_bloom_filter))) and ss_sold_date_sk is 
not null)
+                                              TableScan [TS_68] 
(rows=575995635 width=7)
+                                                
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk"]
+                                              <-Reducer 32 [BROADCAST_EDGE] 
vectorized
+                                                BROADCAST [RS_515]
+                                                  Group By Operator [GBY_514] 
(rows=1 width=12)
+                                                    
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
+                                                  <-Map 26 
[CUSTOM_SIMPLE_EDGE] vectorized
+                                                    PARTITION_ONLY_SHUFFLE 
[RS_479]
+                                                      Group By Operator 
[GBY_477] (rows=1 width=12)
+                                                        
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
+                                                        Select Operator 
[SEL_475] (rows=2609 width=4)
+                                                          Output:["_col0"]
+                                                           Please refer to the 
previous Select Operator [SEL_471]
             <-Reducer 4 [CONTAINS]
               Reduce Output Operator [RS_449]
                 Group By Operator [GBY_448] (rows=1 width=112)
@@ -391,20 +378,7 @@ Stage-0
                   Select Operator [SEL_446] (rows=102 width=112)
                     Output:["_col0"]
                     Merge Join Operator [MERGEJOIN_445] (rows=102 width=1)
-                      
Conds:RS_94._col2=RS_487._col0(Inner),Output:["_col3","_col4"]
-                    <-Reducer 30 [ONE_TO_ONE_EDGE] vectorized
-                      FORWARD [RS_487]
-                        PartitionCols:_col0
-                        Select Operator [SEL_486] (rows=745 width=4)
-                          Output:["_col0"]
-                          Filter Operator [FIL_485] (rows=745 width=12)
-                            predicate:(_col1 > 4L)
-                            Group By Operator [GBY_484] (rows=2235 width=12)
-                              
Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0
-                            <-Reducer 29 [SIMPLE_EDGE]
-                              SHUFFLE [RS_84]
-                                PartitionCols:_col0
-                                 Please refer to the previous Group By 
Operator [GBY_83]
+                      
Conds:RS_94._col2=RS_524._col0(Inner),Output:["_col3","_col4"]
                     <-Reducer 3 [SIMPLE_EDGE]
                       SHUFFLE [RS_94]
                         PartitionCols:_col2
@@ -414,31 +388,20 @@ Stage-0
                           PARTITION_ONLY_SHUFFLE [RS_91]
                             PartitionCols:_col1
                             Merge Join Operator [MERGEJOIN_427] (rows=7751875 
width=101)
-                              
Conds:RS_495._col0=RS_457._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
+                              
Conds:RS_469._col0=RS_457._col0(Inner),Output:["_col1","_col2","_col3","_col4"]
                             <-Map 8 [SIMPLE_EDGE] vectorized
                               PARTITION_ONLY_SHUFFLE [RS_457]
                                 PartitionCols:_col0
                                  Please refer to the previous Select Operator 
[SEL_456]
                             <-Map 1 [SIMPLE_EDGE] vectorized
-                              SHUFFLE [RS_495]
+                              SHUFFLE [RS_469]
                                 PartitionCols:_col0
-                                Select Operator [SEL_494] (rows=285117831 
width=127)
+                                Select Operator [SEL_468] (rows=285117831 
width=127)
                                   
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                  Filter Operator [FIL_493] (rows=285117831 
width=127)
-                                    predicate:((cs_item_sk BETWEEN 
DynamicValue(RS_95_item_i_item_sk_min) AND 
DynamicValue(RS_95_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, 
DynamicValue(RS_95_item_i_item_sk_bloom_filter))) and (cs_sold_date_sk BETWEEN 
DynamicValue(RS_89_date_dim_d_date_sk_min) AND 
DynamicValue(RS_89_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_89_date_dim_d_date_sk_bloom_filter))) and cs_bill_customer_sk 
is not null and cs_sold_date_sk is not null)
+                                  Filter Operator [FIL_467] (rows=285117831 
width=127)
+                                    predicate:((cs_sold_date_sk BETWEEN 
DynamicValue(RS_89_date_dim_d_date_sk_min) AND 
DynamicValue(RS_89_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, 
DynamicValue(RS_89_date_dim_d_date_sk_bloom_filter))) and cs_bill_customer_sk 
is not null and cs_sold_date_sk is not null)
                                     TableScan [TS_0] (rows=287989836 width=127)
                                       
default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_quantity","cs_list_price"]
-                                    <-Reducer 31 [BROADCAST_EDGE] vectorized
-                                      BROADCAST [RS_492]
-                                        Group By Operator [GBY_491] (rows=1 
width=12)
-                                          
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                        <-Reducer 30 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          FORWARD [RS_490]
-                                            Group By Operator [GBY_489] 
(rows=1 width=12)
-                                              
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                              Select Operator [SEL_488] 
(rows=745 width=4)
-                                                Output:["_col0"]
-                                                 Please refer to the previous 
Select Operator [SEL_486]
                                     <-Reducer 9 [BROADCAST_EDGE] vectorized
                                       BROADCAST [RS_466]
                                         Group By Operator [GBY_465] (rows=1 
width=12)
@@ -464,51 +427,51 @@ Stage-0
                                     Merge Join Operator [MERGEJOIN_437] 
(rows=1 width=112)
                                       Conds:(Inner),Output:["_col1"]
                                     <-Reducer 18 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                      PARTITION_ONLY_SHUFFLE [RS_519]
-                                        Select Operator [SEL_518] (rows=1 
width=8)
-                                          Filter Operator [FIL_517] (rows=1 
width=8)
+                                      PARTITION_ONLY_SHUFFLE [RS_503]
+                                        Select Operator [SEL_502] (rows=1 
width=8)
+                                          Filter Operator [FIL_501] (rows=1 
width=8)
                                             predicate:(sq_count_check(_col0) 
<= 1)
-                                            Group By Operator [GBY_516] 
(rows=1 width=8)
+                                            Group By Operator [GBY_500] 
(rows=1 width=8)
                                               
Output:["_col0"],aggregations:["count()"]
-                                              Select Operator [SEL_515] 
(rows=1 width=8)
-                                                Group By Operator [GBY_514] 
(rows=1 width=8)
+                                              Select Operator [SEL_499] 
(rows=1 width=8)
+                                                Group By Operator [GBY_498] 
(rows=1 width=8)
                                                   
Output:["_col0"],aggregations:["count(VALUE._col0)"]
                                                 <-Reducer 17 
[CUSTOM_SIMPLE_EDGE] vectorized
-                                                  PARTITION_ONLY_SHUFFLE 
[RS_510]
-                                                    Group By Operator 
[GBY_506] (rows=1 width=8)
+                                                  PARTITION_ONLY_SHUFFLE 
[RS_494]
+                                                    Group By Operator 
[GBY_490] (rows=1 width=8)
                                                       
Output:["_col0"],aggregations:["count(_col0)"]
-                                                      Select Operator 
[SEL_502] (rows=50562 width=112)
+                                                      Select Operator 
[SEL_486] (rows=50562 width=112)
                                                         Output:["_col0"]
-                                                         Please refer to the 
previous Group By Operator [GBY_501]
+                                                         Please refer to the 
previous Group By Operator [GBY_485]
                                     <-Reducer 21 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                      PARTITION_ONLY_SHUFFLE [RS_521]
-                                        Group By Operator [GBY_520] (rows=1 
width=112)
+                                      PARTITION_ONLY_SHUFFLE [RS_505]
+                                        Group By Operator [GBY_504] (rows=1 
width=112)
                                           
Output:["_col0"],aggregations:["max(VALUE._col0)"]
                                         <-Reducer 17 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                          PARTITION_ONLY_SHUFFLE [RS_511]
-                                            Group By Operator [GBY_507] 
(rows=1 width=112)
+                                          PARTITION_ONLY_SHUFFLE [RS_495]
+                                            Group By Operator [GBY_491] 
(rows=1 width=112)
                                               
Output:["_col0"],aggregations:["max(_col1)"]
-                                              Select Operator [SEL_503] 
(rows=50562 width=112)
+                                              Select Operator [SEL_487] 
(rows=50562 width=112)
                                                 Output:["_col1"]
-                                                 Please refer to the previous 
Group By Operator [GBY_501]
-                                <-Reducer 36 [CUSTOM_SIMPLE_EDGE] vectorized
-                                  PARTITION_ONLY_SHUFFLE [RS_529]
-                                    Group By Operator [GBY_528] (rows=1415626 
width=115)
+                                                 Please refer to the previous 
Group By Operator [GBY_485]
+                                <-Reducer 34 [CUSTOM_SIMPLE_EDGE] vectorized
+                                  PARTITION_ONLY_SHUFFLE [RS_513]
+                                    Group By Operator [GBY_512] (rows=1415626 
width=115)
                                       
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0
-                                    <-Map 35 [SIMPLE_EDGE] vectorized
-                                      SHUFFLE [RS_527]
+                                    <-Map 33 [SIMPLE_EDGE] vectorized
+                                      SHUFFLE [RS_511]
                                         PartitionCols:_col0
-                                        Group By Operator [GBY_526] 
(rows=550080312 width=115)
+                                        Group By Operator [GBY_510] 
(rows=550080312 width=115)
                                           
Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0
-                                          Select Operator [SEL_525] 
(rows=550080312 width=114)
+                                          Select Operator [SEL_509] 
(rows=550080312 width=114)
                                             Output:["_col0","_col1"]
-                                            Filter Operator [FIL_524] 
(rows=550080312 width=114)
+                                            Filter Operator [FIL_508] 
(rows=550080312 width=114)
                                               predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_91_catalog_sales_cs_bill_customer_sk_min) AND 
DynamicValue(RS_91_catalog_sales_cs_bill_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_91_catalog_sales_cs_bill_customer_sk_bloom_filter))) and 
ss_customer_sk is not null)
                                               TableScan [TS_52] 
(rows=575995635 width=114)
                                                 
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_customer_sk","ss_quantity","ss_sales_price"]
                                               <-Reducer 7 [BROADCAST_EDGE] 
vectorized
-                                                BROADCAST [RS_523]
-                                                  Group By Operator [GBY_522] 
(rows=1 width=12)
+                                                BROADCAST [RS_507]
+                                                  Group By Operator [GBY_506] 
(rows=1 width=12)
                                                     
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
                                                   <-Reducer 2 
[CUSTOM_SIMPLE_EDGE]
                                                     PARTITION_ONLY_SHUFFLE 
[RS_333]
@@ -517,4 +480,17 @@ Stage-0
                                                         Select Operator 
[SEL_331] (rows=7751875 width=6)
                                                           Output:["_col0"]
                                                            Please refer to the 
previous Merge Join Operator [MERGEJOIN_427]
+                    <-Reducer 30 [ONE_TO_ONE_EDGE] vectorized
+                      FORWARD [RS_524]
+                        PartitionCols:_col0
+                        Select Operator [SEL_523] (rows=745 width=4)
+                          Output:["_col0"]
+                          Filter Operator [FIL_522] (rows=745 width=12)
+                            predicate:(_col1 > 4L)
+                            Group By Operator [GBY_521] (rows=2235 width=12)
+                              
Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0
+                            <-Reducer 29 [SIMPLE_EDGE]
+                              SHUFFLE [RS_84]
+                                PartitionCols:_col0
+                                 Please refer to the previous Group By 
Operator [GBY_83]
 

http://git-wip-us.apache.org/repos/asf/hive/blob/e986fc56/ql/src/test/results/clientpositive/perf/tez/constraints/query24.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/perf/tez/constraints/query24.q.out 
b/ql/src/test/results/clientpositive/perf/tez/constraints/query24.q.out
index e782873..d5ff339 100644
--- a/ql/src/test/results/clientpositive/perf/tez/constraints/query24.q.out
+++ b/ql/src/test/results/clientpositive/perf/tez/constraints/query24.q.out
@@ -116,24 +116,21 @@ POSTHOOK: Output: hdfs://### HDFS PATH ###
 Plan optimized by CBO.
 
 Vertex dependency in root stage
-Map 1 <- Reducer 16 (BROADCAST_EDGE), Reducer 17 (BROADCAST_EDGE), Reducer 23 
(BROADCAST_EDGE)
-Map 24 <- Reducer 18 (BROADCAST_EDGE), Reducer 19 (BROADCAST_EDGE)
-Reducer 10 <- Map 22 (SIMPLE_EDGE), Reducer 9 (SIMPLE_EDGE)
+Map 1 <- Reducer 20 (BROADCAST_EDGE)
+Map 21 <- Reducer 16 (BROADCAST_EDGE)
+Reducer 10 <- Map 19 (SIMPLE_EDGE), Reducer 9 (SIMPLE_EDGE)
 Reducer 11 <- Reducer 10 (SIMPLE_EDGE)
 Reducer 12 <- Reducer 11 (CUSTOM_SIMPLE_EDGE)
-Reducer 14 <- Map 13 (SIMPLE_EDGE), Map 20 (SIMPLE_EDGE)
-Reducer 15 <- Map 21 (SIMPLE_EDGE), Reducer 14 (SIMPLE_EDGE)
+Reducer 14 <- Map 13 (SIMPLE_EDGE), Map 17 (SIMPLE_EDGE)
+Reducer 15 <- Map 18 (SIMPLE_EDGE), Reducer 14 (SIMPLE_EDGE)
 Reducer 16 <- Reducer 15 (CUSTOM_SIMPLE_EDGE)
-Reducer 17 <- Reducer 15 (CUSTOM_SIMPLE_EDGE)
-Reducer 18 <- Reducer 15 (CUSTOM_SIMPLE_EDGE)
-Reducer 19 <- Reducer 15 (CUSTOM_SIMPLE_EDGE)
 Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 7 (SIMPLE_EDGE)
-Reducer 23 <- Map 22 (CUSTOM_SIMPLE_EDGE)
+Reducer 20 <- Map 19 (CUSTOM_SIMPLE_EDGE)
 Reducer 3 <- Reducer 15 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE)
-Reducer 4 <- Map 22 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
+Reducer 4 <- Map 19 (SIMPLE_EDGE), Reducer 3 (SIMPLE_EDGE)
 Reducer 5 <- Reducer 4 (SIMPLE_EDGE)
 Reducer 6 <- Reducer 12 (CUSTOM_SIMPLE_EDGE), Reducer 5 (CUSTOM_SIMPLE_EDGE)
-Reducer 8 <- Map 24 (SIMPLE_EDGE), Map 7 (SIMPLE_EDGE)
+Reducer 8 <- Map 21 (SIMPLE_EDGE), Map 7 (SIMPLE_EDGE)
 Reducer 9 <- Reducer 15 (SIMPLE_EDGE), Reducer 8 (SIMPLE_EDGE)
 
 Stage-0
@@ -149,18 +146,18 @@ Stage-0
             Merge Join Operator [MERGEJOIN_297] (rows=15392 width=492)
               Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4"]
             <-Reducer 12 [CUSTOM_SIMPLE_EDGE] vectorized
-              PARTITION_ONLY_SHUFFLE [RS_345]
-                Select Operator [SEL_344] (rows=1 width=112)
+              PARTITION_ONLY_SHUFFLE [RS_339]
+                Select Operator [SEL_338] (rows=1 width=112)
                   Output:["_col0"]
-                  Group By Operator [GBY_343] (rows=1 width=120)
+                  Group By Operator [GBY_337] (rows=1 width=120)
                     
Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"]
                   <-Reducer 11 [CUSTOM_SIMPLE_EDGE] vectorized
-                    PARTITION_ONLY_SHUFFLE [RS_342]
-                      Group By Operator [GBY_341] (rows=1 width=120)
+                    PARTITION_ONLY_SHUFFLE [RS_336]
+                      Group By Operator [GBY_335] (rows=1 width=120)
                         
Output:["_col0","_col1"],aggregations:["sum(_col10)","count(_col10)"]
-                        Select Operator [SEL_340] (rows=589731268 width=932)
+                        Select Operator [SEL_334] (rows=589731268 width=932)
                           Output:["_col10"]
-                          Group By Operator [GBY_339] (rows=589731268 
width=932)
+                          Group By Operator [GBY_333] (rows=589731268 
width=932)
                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7, 
KEY._col8, KEY._col9
                           <-Reducer 10 [SIMPLE_EDGE]
                             SHUFFLE [RS_79]
@@ -168,11 +165,11 @@ Stage-0
                               Group By Operator [GBY_78] (rows=589731268 
width=932)
                                 
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"],aggregations:["sum(_col4)"],keys:_col9,
 _col10, _col13, _col17, _col18, _col21, _col22, _col23, _col24, _col25
                                 Merge Join Operator [MERGEJOIN_296] 
(rows=589731268 width=928)
-                                  
Conds:RS_74._col0=RS_314._col0(Inner),Output:["_col4","_col9","_col10","_col13","_col17","_col18","_col21","_col22","_col23","_col24","_col25"]
-                                <-Map 22 [SIMPLE_EDGE] vectorized
-                                  SHUFFLE [RS_314]
+                                  
Conds:RS_74._col0=RS_301._col0(Inner),Output:["_col4","_col9","_col10","_col13","_col17","_col18","_col21","_col22","_col23","_col24","_col25"]
+                                <-Map 19 [SIMPLE_EDGE] vectorized
+                                  SHUFFLE [RS_301]
                                     PartitionCols:_col0
-                                    Select Operator [SEL_312] (rows=462000 
width=384)
+                                    Select Operator [SEL_299] (rows=462000 
width=384)
                                       
Output:["_col0","_col1","_col2","_col3","_col4","_col5"]
                                       TableScan [TS_22] (rows=462000 width=384)
                                         
default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_current_price","i_size","i_color","i_units","i_manager_id"]
@@ -189,13 +186,13 @@ Stage-0
                                           Filter Operator [FIL_20] 
(rows=7276996 width=724)
                                             predicate:(_col12 <> _col3)
                                             Merge Join Operator 
[MERGEJOIN_289] (rows=7276996 width=724)
-                                              
Conds:RS_17._col0=RS_306._col1(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col8","_col10","_col11","_col12"]
-                                            <-Map 21 [SIMPLE_EDGE] vectorized
-                                              SHUFFLE [RS_306]
+                                              
Conds:RS_17._col0=RS_322._col1(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col8","_col10","_col11","_col12"]
+                                            <-Map 18 [SIMPLE_EDGE] vectorized
+                                              SHUFFLE [RS_322]
                                                 PartitionCols:_col1
-                                                Select Operator [SEL_305] 
(rows=80000000 width=280)
+                                                Select Operator [SEL_321] 
(rows=80000000 width=280)
                                                   
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                                  Filter Operator [FIL_304] 
(rows=80000000 width=280)
+                                                  Filter Operator [FIL_320] 
(rows=80000000 width=280)
                                                     
predicate:c_current_addr_sk is not null
                                                     TableScan [TS_11] 
(rows=80000000 width=280)
                                                       
default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk","c_first_name","c_last_name","c_birth_country"]
@@ -203,22 +200,22 @@ Stage-0
                                               SHUFFLE [RS_17]
                                                 PartitionCols:_col0
                                                 Merge Join Operator 
[MERGEJOIN_288] (rows=611379 width=452)
-                                                  
Conds:RS_300._col2=RS_303._col3(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6"]
+                                                  
Conds:RS_316._col2=RS_319._col3(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6"]
                                                 <-Map 13 [SIMPLE_EDGE] 
vectorized
-                                                  SHUFFLE [RS_300]
+                                                  SHUFFLE [RS_316]
                                                     PartitionCols:_col2
-                                                    Select Operator [SEL_299] 
(rows=40000000 width=363)
+                                                    Select Operator [SEL_315] 
(rows=40000000 width=363)
                                                       
Output:["_col0","_col1","_col2","_col3"]
-                                                      Filter Operator 
[FIL_298] (rows=40000000 width=276)
+                                                      Filter Operator 
[FIL_314] (rows=40000000 width=276)
                                                         predicate:ca_zip is 
not null
                                                         TableScan [TS_5] 
(rows=40000000 width=276)
                                                           
default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state","ca_zip","ca_country"]
-                                                <-Map 20 [SIMPLE_EDGE] 
vectorized
-                                                  SHUFFLE [RS_303]
+                                                <-Map 17 [SIMPLE_EDGE] 
vectorized
+                                                  SHUFFLE [RS_319]
                                                     PartitionCols:_col3
-                                                    Select Operator [SEL_302] 
(rows=155 width=267)
+                                                    Select Operator [SEL_318] 
(rows=155 width=267)
                                                       
Output:["_col0","_col1","_col2","_col3"]
-                                                      Filter Operator 
[FIL_301] (rows=155 width=271)
+                                                      Filter Operator 
[FIL_317] (rows=155 width=271)
                                                         
predicate:((s_market_id = 7) and s_zip is not null)
                                                         TableScan [TS_8] 
(rows=1704 width=270)
                                                           
default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_market_id","s_state","s_zip"]
@@ -226,37 +223,26 @@ Stage-0
                                       SHUFFLE [RS_71]
                                         PartitionCols:_col2, _col1
                                         Merge Join Operator [MERGEJOIN_292] 
(rows=537799798 width=118)
-                                          Conds:RS_338._col0, 
_col3=RS_326._col0, _col1(Inner),Output:["_col0","_col1","_col2","_col4"]
+                                          Conds:RS_332._col0, 
_col3=RS_313._col0, _col1(Inner),Output:["_col0","_col1","_col2","_col4"]
                                         <-Map 7 [SIMPLE_EDGE] vectorized
-                                          SHUFFLE [RS_326]
+                                          SHUFFLE [RS_313]
                                             PartitionCols:_col0, _col1
-                                            Select Operator [SEL_324] 
(rows=57591150 width=8)
+                                            Select Operator [SEL_311] 
(rows=57591150 width=8)
                                               Output:["_col0","_col1"]
                                               TableScan [TS_3] (rows=57591150 
width=8)
                                                 
default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number"]
-                                        <-Map 24 [SIMPLE_EDGE] vectorized
-                                          SHUFFLE [RS_338]
+                                        <-Map 21 [SIMPLE_EDGE] vectorized
+                                          SHUFFLE [RS_332]
                                             PartitionCols:_col0, _col3
-                                            Select Operator [SEL_337] 
(rows=525333486 width=122)
+                                            Select Operator [SEL_331] 
(rows=525333486 width=122)
                                               
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                              Filter Operator [FIL_336] 
(rows=525333486 width=122)
-                                                predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_72_customer_c_customer_sk_min) AND 
DynamicValue(RS_72_customer_c_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_72_customer_c_customer_sk_bloom_filter))) and (ss_store_sk 
BETWEEN DynamicValue(RS_72_store_s_store_sk_min) AND 
DynamicValue(RS_72_store_s_store_sk_max) and in_bloom_filter(ss_store_sk, 
DynamicValue(RS_72_store_s_store_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_store_sk is not null)
+                                              Filter Operator [FIL_330] 
(rows=525333486 width=122)
+                                                predicate:((ss_customer_sk 
BETWEEN DynamicValue(RS_72_customer_c_customer_sk_min) AND 
DynamicValue(RS_72_customer_c_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_72_customer_c_customer_sk_bloom_filter))) and ss_customer_sk is 
not null and ss_store_sk is not null)
                                                 TableScan [TS_44] 
(rows=575995635 width=122)
                                                   
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number","ss_sales_price"]
-                                                <-Reducer 18 [BROADCAST_EDGE] 
vectorized
-                                                  BROADCAST [RS_333]
-                                                    Group By Operator 
[GBY_332] (rows=1 width=12)
-                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                    <-Reducer 15 
[CUSTOM_SIMPLE_EDGE]
-                                                      SHUFFLE [RS_226]
-                                                        Group By Operator 
[GBY_225] (rows=1 width=12)
-                                                          
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                          Select Operator 
[SEL_224] (rows=7276996 width=8)
-                                                            Output:["_col0"]
-                                                             Please refer to 
the previous Select Operator [SEL_21]
-                                                <-Reducer 19 [BROADCAST_EDGE] 
vectorized
-                                                  BROADCAST [RS_335]
-                                                    Group By Operator 
[GBY_334] (rows=1 width=12)
+                                                <-Reducer 16 [BROADCAST_EDGE] 
vectorized
+                                                  BROADCAST [RS_329]
+                                                    Group By Operator 
[GBY_328] (rows=1 width=12)
                                                       
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=6636187)"]
                                                     <-Reducer 15 
[CUSTOM_SIMPLE_EDGE]
                                                       SHUFFLE [RS_231]
@@ -266,14 +252,14 @@ Stage-0
                                                             Output:["_col0"]
                                                              Please refer to 
the previous Select Operator [SEL_21]
             <-Reducer 5 [CUSTOM_SIMPLE_EDGE] vectorized
-              PARTITION_ONLY_SHUFFLE [RS_331]
-                Select Operator [SEL_330] (rows=15392 width=380)
+              PARTITION_ONLY_SHUFFLE [RS_327]
+                Select Operator [SEL_326] (rows=15392 width=380)
                   Output:["_col0","_col1","_col2","_col3"]
-                  Group By Operator [GBY_329] (rows=15392 width=380)
+                  Group By Operator [GBY_325] (rows=15392 width=380)
                     
Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col9)"],keys:_col0,
 _col1, _col3
-                    Select Operator [SEL_328] (rows=86004082 width=843)
+                    Select Operator [SEL_324] (rows=86004082 width=843)
                       Output:["_col0","_col1","_col3","_col9"]
-                      Group By Operator [GBY_327] (rows=86004082 width=843)
+                      Group By Operator [GBY_323] (rows=86004082 width=843)
                         
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0,
 KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7, 
KEY._col8
                       <-Reducer 4 [SIMPLE_EDGE]
                         SHUFFLE [RS_36]
@@ -281,13 +267,13 @@ Stage-0
                           Group By Operator [GBY_35] (rows=86004082 width=843)
                             
Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"],aggregations:["sum(_col4)"],keys:_col9,
 _col10, _col17, _col13, _col18, _col21, _col22, _col23, _col24
                             Merge Join Operator [MERGEJOIN_291] (rows=86004082 
width=813)
-                              
Conds:RS_31._col0=RS_315._col0(Inner),Output:["_col4","_col9","_col10","_col13","_col17","_col18","_col21","_col22","_col23","_col24"]
-                            <-Map 22 [SIMPLE_EDGE] vectorized
-                              SHUFFLE [RS_315]
+                              
Conds:RS_31._col0=RS_302._col0(Inner),Output:["_col4","_col9","_col10","_col13","_col17","_col18","_col21","_col22","_col23","_col24"]
+                            <-Map 19 [SIMPLE_EDGE] vectorized
+                              SHUFFLE [RS_302]
                                 PartitionCols:_col0
-                                Select Operator [SEL_313] (rows=7000 width=295)
+                                Select Operator [SEL_300] (rows=7000 width=295)
                                   
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                  Filter Operator [FIL_311] (rows=7000 
width=384)
+                                  Filter Operator [FIL_298] (rows=7000 
width=384)
                                     predicate:(i_color = 'orchid')
                                      Please refer to the previous TableScan 
[TS_22]
                             <-Reducer 3 [SIMPLE_EDGE]
@@ -303,51 +289,29 @@ Stage-0
                                   SHUFFLE [RS_28]
                                     PartitionCols:_col2, _col1
                                     Merge Join Operator [MERGEJOIN_287] 
(rows=537799798 width=118)
-                                      Conds:RS_323._col0, _col3=RS_325._col0, 
_col1(Inner),Output:["_col0","_col1","_col2","_col4"]
+                                      Conds:RS_310._col0, _col3=RS_312._col0, 
_col1(Inner),Output:["_col0","_col1","_col2","_col4"]
                                     <-Map 7 [SIMPLE_EDGE] vectorized
-                                      SHUFFLE [RS_325]
+                                      SHUFFLE [RS_312]
                                         PartitionCols:_col0, _col1
-                                         Please refer to the previous Select 
Operator [SEL_324]
+                                         Please refer to the previous Select 
Operator [SEL_311]
                                     <-Map 1 [SIMPLE_EDGE] vectorized
-                                      SHUFFLE [RS_323]
+                                      SHUFFLE [RS_310]
                                         PartitionCols:_col0, _col3
-                                        Select Operator [SEL_322] 
(rows=525333486 width=122)
+                                        Select Operator [SEL_309] 
(rows=525333486 width=122)
                                           
Output:["_col0","_col1","_col2","_col3","_col4"]
-                                          Filter Operator [FIL_321] 
(rows=525333486 width=122)
-                                            predicate:((ss_customer_sk BETWEEN 
DynamicValue(RS_29_customer_c_customer_sk_min) AND 
DynamicValue(RS_29_customer_c_customer_sk_max) and 
in_bloom_filter(ss_customer_sk, 
DynamicValue(RS_29_customer_c_customer_sk_bloom_filter))) and (ss_item_sk 
BETWEEN DynamicValue(RS_32_item_i_item_sk_min) AND 
DynamicValue(RS_32_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, 
DynamicValue(RS_32_item_i_item_sk_bloom_filter))) and (ss_store_sk BETWEEN 
DynamicValue(RS_29_store_s_store_sk_min) AND 
DynamicValue(RS_29_store_s_store_sk_max) and in_bloom_filter(ss_store_sk, 
DynamicValue(RS_29_store_s_store_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_store_sk is not null)
+                                          Filter Operator [FIL_308] 
(rows=525333486 width=122)
+                                            predicate:((ss_item_sk BETWEEN 
DynamicValue(RS_32_item_i_item_sk_min) AND 
DynamicValue(RS_32_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, 
DynamicValue(RS_32_item_i_item_sk_bloom_filter))) and ss_customer_sk is not 
null and ss_store_sk is not null)
                                             TableScan [TS_0] (rows=575995635 
width=122)
                                               
default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number","ss_sales_price"]
-                                            <-Reducer 16 [BROADCAST_EDGE] 
vectorized
-                                              BROADCAST [RS_308]
-                                                Group By Operator [GBY_307] 
(rows=1 width=12)
-                                                  
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                <-Reducer 15 
[CUSTOM_SIMPLE_EDGE]
-                                                  SHUFFLE [RS_153]
-                                                    Group By Operator 
[GBY_152] (rows=1 width=12)
-                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                      Select Operator 
[SEL_151] (rows=7276996 width=8)
-                                                        Output:["_col0"]
-                                                         Please refer to the 
previous Select Operator [SEL_21]
-                                            <-Reducer 17 [BROADCAST_EDGE] 
vectorized
-                                              BROADCAST [RS_310]
-                                                Group By Operator [GBY_309] 
(rows=1 width=12)
-                                                  
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=6636187)"]
-                                                <-Reducer 15 
[CUSTOM_SIMPLE_EDGE]
-                                                  SHUFFLE [RS_158]
-                                                    Group By Operator 
[GBY_157] (rows=1 width=12)
-                                                      
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=6636187)"]
-                                                      Select Operator 
[SEL_156] (rows=7276996 width=4)
-                                                        Output:["_col0"]
-                                                         Please refer to the 
previous Select Operator [SEL_21]
-                                            <-Reducer 23 [BROADCAST_EDGE] 
vectorized
-                                              BROADCAST [RS_320]
-                                                Group By Operator [GBY_319] 
(rows=1 width=12)
+                                            <-Reducer 20 [BROADCAST_EDGE] 
vectorized
+                                              BROADCAST [RS_307]
+                                                Group By Operator [GBY_306] 
(rows=1 width=12)
                                                   
Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2,
 expectedEntries=1000000)"]
-                                                <-Map 22 [CUSTOM_SIMPLE_EDGE] 
vectorized
-                                                  SHUFFLE [RS_318]
-                                                    Group By Operator 
[GBY_317] (rows=1 width=12)
+                                                <-Map 19 [CUSTOM_SIMPLE_EDGE] 
vectorized
+                                                  SHUFFLE [RS_305]
+                                                    Group By Operator 
[GBY_304] (rows=1 width=12)
                                                       
Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0,
 expectedEntries=1000000)"]
-                                                      Select Operator 
[SEL_316] (rows=7000 width=4)
+                                                      Select Operator 
[SEL_303] (rows=7000 width=4)
                                                         Output:["_col0"]
-                                                         Please refer to the 
previous Select Operator [SEL_313]
+                                                         Please refer to the 
previous Select Operator [SEL_300]
 

Reply via email to