hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jcama...@apache.org
Subject [11/32] hive git commit: HIVE-11865: Disable Hive PPD optimizer when CBO has optimized the plan (Jesus Camacho Rodriguez, reviewed by Laljo John Pullokkaran)
Date Mon, 21 Dec 2015 01:06:52 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/6f44fc81/ql/src/test/results/clientpositive/perf/query88.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/perf/query88.q.out b/ql/src/test/results/clientpositive/perf/query88.q.out
index f70bc7f..f139dd1 100644
--- a/ql/src/test/results/clientpositive/perf/query88.q.out
+++ b/ql/src/test/results/clientpositive/perf/query88.q.out
@@ -1,10 +1,10 @@
-Warning: Shuffle Join MERGEJOIN[421][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product
-Warning: Shuffle Join MERGEJOIN[422][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 7' is a cross product
-Warning: Shuffle Join MERGEJOIN[423][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3]] in Stage 'Reducer 8' is a cross product
-Warning: Shuffle Join MERGEJOIN[424][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4]] in Stage 'Reducer 9' is a cross product
-Warning: Shuffle Join MERGEJOIN[425][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5]] in Stage 'Reducer 10' is a cross product
-Warning: Shuffle Join MERGEJOIN[426][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 11' is a cross product
-Warning: Shuffle Join MERGEJOIN[427][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5, $hdt$_6, $hdt$_7]] in Stage 'Reducer 12' is a cross product
+Warning: Shuffle Join MERGEJOIN[366][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product
+Warning: Shuffle Join MERGEJOIN[367][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 7' is a cross product
+Warning: Shuffle Join MERGEJOIN[368][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3]] in Stage 'Reducer 8' is a cross product
+Warning: Shuffle Join MERGEJOIN[369][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4]] in Stage 'Reducer 9' is a cross product
+Warning: Shuffle Join MERGEJOIN[370][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5]] in Stage 'Reducer 10' is a cross product
+Warning: Shuffle Join MERGEJOIN[371][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 11' is a cross product
+Warning: Shuffle Join MERGEJOIN[372][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5, $hdt$_6, $hdt$_7]] in Stage 'Reducer 12' is a cross product
 PREHOOK: query: explain
 select  *
 from
@@ -237,629 +237,629 @@ Stage-0
       limit:-1
       Stage-1
          Reducer 12
-         File Output Operator [FS_285]
+         File Output Operator [FS_237]
             compressed:false
             Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             table:{"input format:":"org.apache.hadoop.mapred.TextInputFormat","output format:":"org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat","serde:":"org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe"}
-            Merge Join Operator [MERGEJOIN_427]
+            Merge Join Operator [MERGEJOIN_372]
             |  condition map:[{"":"Inner Join 0 to 1"}]
             |  keys:{}
             |  outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"]
             |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |<-Reducer 11 [SIMPLE_EDGE]
-            |  Reduce Output Operator [RS_281]
+            |  Reduce Output Operator [RS_233]
             |     sort order:
             |     Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     value expressions:_col0 (type: bigint), _col1 (type: bigint), _col2 (type: bigint), _col3 (type: bigint), _col4 (type: bigint), _col5 (type: bigint), _col6 (type: bigint)
-            |     Merge Join Operator [MERGEJOIN_426]
+            |     Merge Join Operator [MERGEJOIN_371]
             |     |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |  keys:{}
             |     |  outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"]
             |     |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |<-Reducer 10 [SIMPLE_EDGE]
-            |     |  Reduce Output Operator [RS_278]
+            |     |  Reduce Output Operator [RS_230]
             |     |     sort order:
             |     |     Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |     value expressions:_col0 (type: bigint), _col1 (type: bigint), _col2 (type: bigint), _col3 (type: bigint), _col4 (type: bigint), _col5 (type: bigint)
-            |     |     Merge Join Operator [MERGEJOIN_425]
+            |     |     Merge Join Operator [MERGEJOIN_370]
             |     |     |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |     |  keys:{}
             |     |     |  outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5"]
             |     |     |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |     |<-Reducer 52 [SIMPLE_EDGE]
-            |     |     |  Reduce Output Operator [RS_276]
+            |     |     |  Reduce Output Operator [RS_228]
             |     |     |     sort order:
             |     |     |     Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |     |     value expressions:_col0 (type: bigint)
-            |     |     |     Group By Operator [GBY_190]
+            |     |     |     Group By Operator [GBY_154]
             |     |     |     |  aggregations:["count(VALUE._col0)"]
             |     |     |     |  outputColumnNames:["_col0"]
             |     |     |     |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |     |     |<-Reducer 51 [SIMPLE_EDGE]
-            |     |     |        Reduce Output Operator [RS_189]
+            |     |     |        Reduce Output Operator [RS_153]
             |     |     |           sort order:
             |     |     |           Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |     |           value expressions:_col0 (type: bigint)
-            |     |     |           Group By Operator [GBY_188]
+            |     |     |           Group By Operator [GBY_152]
             |     |     |              aggregations:["count()"]
             |     |     |              outputColumnNames:["_col0"]
             |     |     |              Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
-            |     |     |              Merge Join Operator [MERGEJOIN_414]
+            |     |     |              Merge Join Operator [MERGEJOIN_359]
             |     |     |              |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |     |              |  keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"}
             |     |     |              |  Statistics:Num rows: 17424 Data size: 8206704 Basic stats: COMPLETE Column stats: NONE
             |     |     |              |<-Map 55 [SIMPLE_EDGE]
-            |     |     |              |  Reduce Output Operator [RS_185]
+            |     |     |              |  Reduce Output Operator [RS_149]
             |     |     |              |     key expressions:_col0 (type: int)
             |     |     |              |     Map-reduce partition columns:_col0 (type: int)
             |     |     |              |     sort order:+
             |     |     |              |     Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |     |              |     Select Operator [SEL_171]
+            |     |     |              |     Select Operator [SEL_141]
             |     |     |              |        outputColumnNames:["_col0"]
             |     |     |              |        Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |     |              |        Filter Operator [FIL_388]
+            |     |     |              |        Filter Operator [FIL_333]
             |     |     |              |           predicate:((s_store_name = 'ese') and s_store_sk is not null) (type: boolean)
             |     |     |              |           Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |     |              |           TableScan [TS_169]
+            |     |     |              |           TableScan [TS_139]
             |     |     |              |              alias:store
             |     |     |              |              Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE
             |     |     |              |<-Reducer 50 [SIMPLE_EDGE]
-            |     |     |                 Reduce Output Operator [RS_183]
+            |     |     |                 Reduce Output Operator [RS_148]
             |     |     |                    key expressions:_col2 (type: int)
             |     |     |                    Map-reduce partition columns:_col2 (type: int)
             |     |     |                    sort order:+
             |     |     |                    Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
-            |     |     |                    Merge Join Operator [MERGEJOIN_413]
+            |     |     |                    Merge Join Operator [MERGEJOIN_358]
             |     |     |                    |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |     |                    |  keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"}
             |     |     |                    |  outputColumnNames:["_col2"]
             |     |     |                    |  Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
             |     |     |                    |<-Map 54 [SIMPLE_EDGE]
-            |     |     |                    |  Reduce Output Operator [RS_180]
+            |     |     |                    |  Reduce Output Operator [RS_146]
             |     |     |                    |     key expressions:_col0 (type: int)
             |     |     |                    |     Map-reduce partition columns:_col0 (type: int)
             |     |     |                    |     sort order:+
             |     |     |                    |     Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |     |                    |     Select Operator [SEL_168]
+            |     |     |                    |     Select Operator [SEL_138]
             |     |     |                    |        outputColumnNames:["_col0"]
             |     |     |                    |        Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |     |                    |        Filter Operator [FIL_387]
+            |     |     |                    |        Filter Operator [FIL_332]
             |     |     |                    |           predicate:(((t_hour = 11) and (t_minute < 30)) and t_time_sk is not null) (type: boolean)
             |     |     |                    |           Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |     |                    |           TableScan [TS_166]
+            |     |     |                    |           TableScan [TS_136]
             |     |     |                    |              alias:time_dim
             |     |     |                    |              Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE
             |     |     |                    |<-Reducer 49 [SIMPLE_EDGE]
-            |     |     |                       Reduce Output Operator [RS_178]
+            |     |     |                       Reduce Output Operator [RS_145]
             |     |     |                          key expressions:_col0 (type: int)
             |     |     |                          Map-reduce partition columns:_col0 (type: int)
             |     |     |                          sort order:+
             |     |     |                          Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |     |                          value expressions:_col2 (type: int)
-            |     |     |                          Merge Join Operator [MERGEJOIN_412]
+            |     |     |                          Merge Join Operator [MERGEJOIN_357]
             |     |     |                          |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |     |                          |  keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"}
             |     |     |                          |  outputColumnNames:["_col0","_col2"]
             |     |     |                          |  Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |     |                          |<-Map 48 [SIMPLE_EDGE]
-            |     |     |                          |  Reduce Output Operator [RS_173]
+            |     |     |                          |  Reduce Output Operator [RS_142]
             |     |     |                          |     key expressions:_col1 (type: int)
             |     |     |                          |     Map-reduce partition columns:_col1 (type: int)
             |     |     |                          |     sort order:+
             |     |     |                          |     Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |     |                          |     value expressions:_col0 (type: int), _col2 (type: int)
-            |     |     |                          |     Select Operator [SEL_162]
+            |     |     |                          |     Select Operator [SEL_132]
             |     |     |                          |        outputColumnNames:["_col0","_col1","_col2"]
             |     |     |                          |        Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |     |                          |        Filter Operator [FIL_385]
+            |     |     |                          |        Filter Operator [FIL_330]
             |     |     |                          |           predicate:((ss_hdemo_sk is not null and ss_sold_time_sk is not null) and ss_store_sk is not null) (type: boolean)
             |     |     |                          |           Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |     |                          |           TableScan [TS_160]
+            |     |     |                          |           TableScan [TS_130]
             |     |     |                          |              alias:store_sales
             |     |     |                          |              Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |     |                          |<-Map 53 [SIMPLE_EDGE]
-            |     |     |                             Reduce Output Operator [RS_175]
+            |     |     |                             Reduce Output Operator [RS_143]
             |     |     |                                key expressions:_col0 (type: int)
             |     |     |                                Map-reduce partition columns:_col0 (type: int)
             |     |     |                                sort order:+
             |     |     |                                Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |     |                                Select Operator [SEL_165]
+            |     |     |                                Select Operator [SEL_135]
             |     |     |                                   outputColumnNames:["_col0"]
             |     |     |                                   Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |     |                                   Filter Operator [FIL_386]
+            |     |     |                                   Filter Operator [FIL_331]
             |     |     |                                      predicate:((((hd_dep_count = 3) and (hd_vehicle_count <= 5)) or ((hd_dep_count = 0) and (hd_vehicle_count <= 2)) or ((hd_dep_count = 1) and (hd_vehicle_count <= 3))) and hd_demo_sk is not null) (type: boolean)
             |     |     |                                      Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |     |                                      TableScan [TS_163]
+            |     |     |                                      TableScan [TS_133]
             |     |     |                                         alias:household_demographics
             |     |     |                                         Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE
             |     |     |<-Reducer 9 [SIMPLE_EDGE]
-            |     |        Reduce Output Operator [RS_275]
+            |     |        Reduce Output Operator [RS_227]
             |     |           sort order:
             |     |           Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |           value expressions:_col0 (type: bigint), _col1 (type: bigint), _col2 (type: bigint), _col3 (type: bigint), _col4 (type: bigint)
-            |     |           Merge Join Operator [MERGEJOIN_424]
+            |     |           Merge Join Operator [MERGEJOIN_369]
             |     |           |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |           |  keys:{}
             |     |           |  outputColumnNames:["_col0","_col1","_col2","_col3","_col4"]
             |     |           |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |           |<-Reducer 44 [SIMPLE_EDGE]
-            |     |           |  Reduce Output Operator [RS_273]
+            |     |           |  Reduce Output Operator [RS_225]
             |     |           |     sort order:
             |     |           |     Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |           |     value expressions:_col0 (type: bigint)
-            |     |           |     Group By Operator [GBY_158]
+            |     |           |     Group By Operator [GBY_128]
             |     |           |     |  aggregations:["count(VALUE._col0)"]
             |     |           |     |  outputColumnNames:["_col0"]
             |     |           |     |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |           |     |<-Reducer 43 [SIMPLE_EDGE]
-            |     |           |        Reduce Output Operator [RS_157]
+            |     |           |        Reduce Output Operator [RS_127]
             |     |           |           sort order:
             |     |           |           Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |           |           value expressions:_col0 (type: bigint)
-            |     |           |           Group By Operator [GBY_156]
+            |     |           |           Group By Operator [GBY_126]
             |     |           |              aggregations:["count()"]
             |     |           |              outputColumnNames:["_col0"]
             |     |           |              Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
-            |     |           |              Merge Join Operator [MERGEJOIN_411]
+            |     |           |              Merge Join Operator [MERGEJOIN_356]
             |     |           |              |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |           |              |  keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"}
             |     |           |              |  Statistics:Num rows: 17424 Data size: 8206704 Basic stats: COMPLETE Column stats: NONE
             |     |           |              |<-Map 47 [SIMPLE_EDGE]
-            |     |           |              |  Reduce Output Operator [RS_153]
+            |     |           |              |  Reduce Output Operator [RS_123]
             |     |           |              |     key expressions:_col0 (type: int)
             |     |           |              |     Map-reduce partition columns:_col0 (type: int)
             |     |           |              |     sort order:+
             |     |           |              |     Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |           |              |     Select Operator [SEL_139]
+            |     |           |              |     Select Operator [SEL_115]
             |     |           |              |        outputColumnNames:["_col0"]
             |     |           |              |        Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |           |              |        Filter Operator [FIL_384]
+            |     |           |              |        Filter Operator [FIL_329]
             |     |           |              |           predicate:((s_store_name = 'ese') and s_store_sk is not null) (type: boolean)
             |     |           |              |           Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |           |              |           TableScan [TS_137]
+            |     |           |              |           TableScan [TS_113]
             |     |           |              |              alias:store
             |     |           |              |              Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE
             |     |           |              |<-Reducer 42 [SIMPLE_EDGE]
-            |     |           |                 Reduce Output Operator [RS_151]
+            |     |           |                 Reduce Output Operator [RS_122]
             |     |           |                    key expressions:_col2 (type: int)
             |     |           |                    Map-reduce partition columns:_col2 (type: int)
             |     |           |                    sort order:+
             |     |           |                    Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
-            |     |           |                    Merge Join Operator [MERGEJOIN_410]
+            |     |           |                    Merge Join Operator [MERGEJOIN_355]
             |     |           |                    |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |           |                    |  keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"}
             |     |           |                    |  outputColumnNames:["_col2"]
             |     |           |                    |  Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
             |     |           |                    |<-Map 46 [SIMPLE_EDGE]
-            |     |           |                    |  Reduce Output Operator [RS_148]
+            |     |           |                    |  Reduce Output Operator [RS_120]
             |     |           |                    |     key expressions:_col0 (type: int)
             |     |           |                    |     Map-reduce partition columns:_col0 (type: int)
             |     |           |                    |     sort order:+
             |     |           |                    |     Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |           |                    |     Select Operator [SEL_136]
+            |     |           |                    |     Select Operator [SEL_112]
             |     |           |                    |        outputColumnNames:["_col0"]
             |     |           |                    |        Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |           |                    |        Filter Operator [FIL_383]
+            |     |           |                    |        Filter Operator [FIL_328]
             |     |           |                    |           predicate:(((t_hour = 10) and (t_minute >= 30)) and t_time_sk is not null) (type: boolean)
             |     |           |                    |           Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |           |                    |           TableScan [TS_134]
+            |     |           |                    |           TableScan [TS_110]
             |     |           |                    |              alias:time_dim
             |     |           |                    |              Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE
             |     |           |                    |<-Reducer 41 [SIMPLE_EDGE]
-            |     |           |                       Reduce Output Operator [RS_146]
+            |     |           |                       Reduce Output Operator [RS_119]
             |     |           |                          key expressions:_col0 (type: int)
             |     |           |                          Map-reduce partition columns:_col0 (type: int)
             |     |           |                          sort order:+
             |     |           |                          Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |           |                          value expressions:_col2 (type: int)
-            |     |           |                          Merge Join Operator [MERGEJOIN_409]
+            |     |           |                          Merge Join Operator [MERGEJOIN_354]
             |     |           |                          |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |           |                          |  keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"}
             |     |           |                          |  outputColumnNames:["_col0","_col2"]
             |     |           |                          |  Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |           |                          |<-Map 40 [SIMPLE_EDGE]
-            |     |           |                          |  Reduce Output Operator [RS_141]
+            |     |           |                          |  Reduce Output Operator [RS_116]
             |     |           |                          |     key expressions:_col1 (type: int)
             |     |           |                          |     Map-reduce partition columns:_col1 (type: int)
             |     |           |                          |     sort order:+
             |     |           |                          |     Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |           |                          |     value expressions:_col0 (type: int), _col2 (type: int)
-            |     |           |                          |     Select Operator [SEL_130]
+            |     |           |                          |     Select Operator [SEL_106]
             |     |           |                          |        outputColumnNames:["_col0","_col1","_col2"]
             |     |           |                          |        Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |           |                          |        Filter Operator [FIL_381]
+            |     |           |                          |        Filter Operator [FIL_326]
             |     |           |                          |           predicate:((ss_hdemo_sk is not null and ss_sold_time_sk is not null) and ss_store_sk is not null) (type: boolean)
             |     |           |                          |           Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |           |                          |           TableScan [TS_128]
+            |     |           |                          |           TableScan [TS_104]
             |     |           |                          |              alias:store_sales
             |     |           |                          |              Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |           |                          |<-Map 45 [SIMPLE_EDGE]
-            |     |           |                             Reduce Output Operator [RS_143]
+            |     |           |                             Reduce Output Operator [RS_117]
             |     |           |                                key expressions:_col0 (type: int)
             |     |           |                                Map-reduce partition columns:_col0 (type: int)
             |     |           |                                sort order:+
             |     |           |                                Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |           |                                Select Operator [SEL_133]
+            |     |           |                                Select Operator [SEL_109]
             |     |           |                                   outputColumnNames:["_col0"]
             |     |           |                                   Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |           |                                   Filter Operator [FIL_382]
+            |     |           |                                   Filter Operator [FIL_327]
             |     |           |                                      predicate:((((hd_dep_count = 3) and (hd_vehicle_count <= 5)) or ((hd_dep_count = 0) and (hd_vehicle_count <= 2)) or ((hd_dep_count = 1) and (hd_vehicle_count <= 3))) and hd_demo_sk is not null) (type: boolean)
             |     |           |                                      Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |           |                                      TableScan [TS_131]
+            |     |           |                                      TableScan [TS_107]
             |     |           |                                         alias:household_demographics
             |     |           |                                         Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE
             |     |           |<-Reducer 8 [SIMPLE_EDGE]
-            |     |              Reduce Output Operator [RS_272]
+            |     |              Reduce Output Operator [RS_224]
             |     |                 sort order:
             |     |                 Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                 value expressions:_col0 (type: bigint), _col1 (type: bigint), _col2 (type: bigint), _col3 (type: bigint)
-            |     |                 Merge Join Operator [MERGEJOIN_423]
+            |     |                 Merge Join Operator [MERGEJOIN_368]
             |     |                 |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                 |  keys:{}
             |     |                 |  outputColumnNames:["_col0","_col1","_col2","_col3"]
             |     |                 |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                 |<-Reducer 36 [SIMPLE_EDGE]
-            |     |                 |  Reduce Output Operator [RS_270]
+            |     |                 |  Reduce Output Operator [RS_222]
             |     |                 |     sort order:
             |     |                 |     Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                 |     value expressions:_col0 (type: bigint)
-            |     |                 |     Group By Operator [GBY_126]
+            |     |                 |     Group By Operator [GBY_102]
             |     |                 |     |  aggregations:["count(VALUE._col0)"]
             |     |                 |     |  outputColumnNames:["_col0"]
             |     |                 |     |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                 |     |<-Reducer 35 [SIMPLE_EDGE]
-            |     |                 |        Reduce Output Operator [RS_125]
+            |     |                 |        Reduce Output Operator [RS_101]
             |     |                 |           sort order:
             |     |                 |           Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                 |           value expressions:_col0 (type: bigint)
-            |     |                 |           Group By Operator [GBY_124]
+            |     |                 |           Group By Operator [GBY_100]
             |     |                 |              aggregations:["count()"]
             |     |                 |              outputColumnNames:["_col0"]
             |     |                 |              Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |              Merge Join Operator [MERGEJOIN_408]
+            |     |                 |              Merge Join Operator [MERGEJOIN_353]
             |     |                 |              |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                 |              |  keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"}
             |     |                 |              |  Statistics:Num rows: 17424 Data size: 8206704 Basic stats: COMPLETE Column stats: NONE
             |     |                 |              |<-Map 39 [SIMPLE_EDGE]
-            |     |                 |              |  Reduce Output Operator [RS_121]
+            |     |                 |              |  Reduce Output Operator [RS_97]
             |     |                 |              |     key expressions:_col0 (type: int)
             |     |                 |              |     Map-reduce partition columns:_col0 (type: int)
             |     |                 |              |     sort order:+
             |     |                 |              |     Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |              |     Select Operator [SEL_107]
+            |     |                 |              |     Select Operator [SEL_89]
             |     |                 |              |        outputColumnNames:["_col0"]
             |     |                 |              |        Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |              |        Filter Operator [FIL_380]
+            |     |                 |              |        Filter Operator [FIL_325]
             |     |                 |              |           predicate:((s_store_name = 'ese') and s_store_sk is not null) (type: boolean)
             |     |                 |              |           Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |              |           TableScan [TS_105]
+            |     |                 |              |           TableScan [TS_87]
             |     |                 |              |              alias:store
             |     |                 |              |              Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE
             |     |                 |              |<-Reducer 34 [SIMPLE_EDGE]
-            |     |                 |                 Reduce Output Operator [RS_119]
+            |     |                 |                 Reduce Output Operator [RS_96]
             |     |                 |                    key expressions:_col2 (type: int)
             |     |                 |                    Map-reduce partition columns:_col2 (type: int)
             |     |                 |                    sort order:+
             |     |                 |                    Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |                    Merge Join Operator [MERGEJOIN_407]
+            |     |                 |                    Merge Join Operator [MERGEJOIN_352]
             |     |                 |                    |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                 |                    |  keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"}
             |     |                 |                    |  outputColumnNames:["_col2"]
             |     |                 |                    |  Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
             |     |                 |                    |<-Map 38 [SIMPLE_EDGE]
-            |     |                 |                    |  Reduce Output Operator [RS_116]
+            |     |                 |                    |  Reduce Output Operator [RS_94]
             |     |                 |                    |     key expressions:_col0 (type: int)
             |     |                 |                    |     Map-reduce partition columns:_col0 (type: int)
             |     |                 |                    |     sort order:+
             |     |                 |                    |     Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |                    |     Select Operator [SEL_104]
+            |     |                 |                    |     Select Operator [SEL_86]
             |     |                 |                    |        outputColumnNames:["_col0"]
             |     |                 |                    |        Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |                    |        Filter Operator [FIL_379]
+            |     |                 |                    |        Filter Operator [FIL_324]
             |     |                 |                    |           predicate:(((t_hour = 10) and (t_minute < 30)) and t_time_sk is not null) (type: boolean)
             |     |                 |                    |           Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |                    |           TableScan [TS_102]
+            |     |                 |                    |           TableScan [TS_84]
             |     |                 |                    |              alias:time_dim
             |     |                 |                    |              Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE
             |     |                 |                    |<-Reducer 33 [SIMPLE_EDGE]
-            |     |                 |                       Reduce Output Operator [RS_114]
+            |     |                 |                       Reduce Output Operator [RS_93]
             |     |                 |                          key expressions:_col0 (type: int)
             |     |                 |                          Map-reduce partition columns:_col0 (type: int)
             |     |                 |                          sort order:+
             |     |                 |                          Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |                 |                          value expressions:_col2 (type: int)
-            |     |                 |                          Merge Join Operator [MERGEJOIN_406]
+            |     |                 |                          Merge Join Operator [MERGEJOIN_351]
             |     |                 |                          |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                 |                          |  keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"}
             |     |                 |                          |  outputColumnNames:["_col0","_col2"]
             |     |                 |                          |  Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |                 |                          |<-Map 32 [SIMPLE_EDGE]
-            |     |                 |                          |  Reduce Output Operator [RS_109]
+            |     |                 |                          |  Reduce Output Operator [RS_90]
             |     |                 |                          |     key expressions:_col1 (type: int)
             |     |                 |                          |     Map-reduce partition columns:_col1 (type: int)
             |     |                 |                          |     sort order:+
             |     |                 |                          |     Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |                 |                          |     value expressions:_col0 (type: int), _col2 (type: int)
-            |     |                 |                          |     Select Operator [SEL_98]
+            |     |                 |                          |     Select Operator [SEL_80]
             |     |                 |                          |        outputColumnNames:["_col0","_col1","_col2"]
             |     |                 |                          |        Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |                 |                          |        Filter Operator [FIL_377]
+            |     |                 |                          |        Filter Operator [FIL_322]
             |     |                 |                          |           predicate:((ss_hdemo_sk is not null and ss_sold_time_sk is not null) and ss_store_sk is not null) (type: boolean)
             |     |                 |                          |           Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |                 |                          |           TableScan [TS_96]
+            |     |                 |                          |           TableScan [TS_78]
             |     |                 |                          |              alias:store_sales
             |     |                 |                          |              Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |                 |                          |<-Map 37 [SIMPLE_EDGE]
-            |     |                 |                             Reduce Output Operator [RS_111]
+            |     |                 |                             Reduce Output Operator [RS_91]
             |     |                 |                                key expressions:_col0 (type: int)
             |     |                 |                                Map-reduce partition columns:_col0 (type: int)
             |     |                 |                                sort order:+
             |     |                 |                                Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |                                Select Operator [SEL_101]
+            |     |                 |                                Select Operator [SEL_83]
             |     |                 |                                   outputColumnNames:["_col0"]
             |     |                 |                                   Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |                                   Filter Operator [FIL_378]
+            |     |                 |                                   Filter Operator [FIL_323]
             |     |                 |                                      predicate:((((hd_dep_count = 3) and (hd_vehicle_count <= 5)) or ((hd_dep_count = 0) and (hd_vehicle_count <= 2)) or ((hd_dep_count = 1) and (hd_vehicle_count <= 3))) and hd_demo_sk is not null) (type: boolean)
             |     |                 |                                      Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |                 |                                      TableScan [TS_99]
+            |     |                 |                                      TableScan [TS_81]
             |     |                 |                                         alias:household_demographics
             |     |                 |                                         Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE
             |     |                 |<-Reducer 7 [SIMPLE_EDGE]
-            |     |                    Reduce Output Operator [RS_269]
+            |     |                    Reduce Output Operator [RS_221]
             |     |                       sort order:
             |     |                       Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                       value expressions:_col0 (type: bigint), _col1 (type: bigint), _col2 (type: bigint)
-            |     |                       Merge Join Operator [MERGEJOIN_422]
+            |     |                       Merge Join Operator [MERGEJOIN_367]
             |     |                       |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                       |  keys:{}
             |     |                       |  outputColumnNames:["_col0","_col1","_col2"]
             |     |                       |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                       |<-Reducer 28 [SIMPLE_EDGE]
-            |     |                       |  Reduce Output Operator [RS_267]
+            |     |                       |  Reduce Output Operator [RS_219]
             |     |                       |     sort order:
             |     |                       |     Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                       |     value expressions:_col0 (type: bigint)
-            |     |                       |     Group By Operator [GBY_94]
+            |     |                       |     Group By Operator [GBY_76]
             |     |                       |     |  aggregations:["count(VALUE._col0)"]
             |     |                       |     |  outputColumnNames:["_col0"]
             |     |                       |     |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                       |     |<-Reducer 27 [SIMPLE_EDGE]
-            |     |                       |        Reduce Output Operator [RS_93]
+            |     |                       |        Reduce Output Operator [RS_75]
             |     |                       |           sort order:
             |     |                       |           Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                       |           value expressions:_col0 (type: bigint)
-            |     |                       |           Group By Operator [GBY_92]
+            |     |                       |           Group By Operator [GBY_74]
             |     |                       |              aggregations:["count()"]
             |     |                       |              outputColumnNames:["_col0"]
             |     |                       |              Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |              Merge Join Operator [MERGEJOIN_405]
+            |     |                       |              Merge Join Operator [MERGEJOIN_350]
             |     |                       |              |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                       |              |  keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"}
             |     |                       |              |  Statistics:Num rows: 17424 Data size: 8206704 Basic stats: COMPLETE Column stats: NONE
             |     |                       |              |<-Map 31 [SIMPLE_EDGE]
-            |     |                       |              |  Reduce Output Operator [RS_89]
+            |     |                       |              |  Reduce Output Operator [RS_71]
             |     |                       |              |     key expressions:_col0 (type: int)
             |     |                       |              |     Map-reduce partition columns:_col0 (type: int)
             |     |                       |              |     sort order:+
             |     |                       |              |     Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |              |     Select Operator [SEL_75]
+            |     |                       |              |     Select Operator [SEL_63]
             |     |                       |              |        outputColumnNames:["_col0"]
             |     |                       |              |        Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |              |        Filter Operator [FIL_376]
+            |     |                       |              |        Filter Operator [FIL_321]
             |     |                       |              |           predicate:((s_store_name = 'ese') and s_store_sk is not null) (type: boolean)
             |     |                       |              |           Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |              |           TableScan [TS_73]
+            |     |                       |              |           TableScan [TS_61]
             |     |                       |              |              alias:store
             |     |                       |              |              Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE
             |     |                       |              |<-Reducer 26 [SIMPLE_EDGE]
-            |     |                       |                 Reduce Output Operator [RS_87]
+            |     |                       |                 Reduce Output Operator [RS_70]
             |     |                       |                    key expressions:_col2 (type: int)
             |     |                       |                    Map-reduce partition columns:_col2 (type: int)
             |     |                       |                    sort order:+
             |     |                       |                    Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |                    Merge Join Operator [MERGEJOIN_404]
+            |     |                       |                    Merge Join Operator [MERGEJOIN_349]
             |     |                       |                    |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                       |                    |  keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"}
             |     |                       |                    |  outputColumnNames:["_col2"]
             |     |                       |                    |  Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
             |     |                       |                    |<-Map 30 [SIMPLE_EDGE]
-            |     |                       |                    |  Reduce Output Operator [RS_84]
+            |     |                       |                    |  Reduce Output Operator [RS_68]
             |     |                       |                    |     key expressions:_col0 (type: int)
             |     |                       |                    |     Map-reduce partition columns:_col0 (type: int)
             |     |                       |                    |     sort order:+
             |     |                       |                    |     Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |                    |     Select Operator [SEL_72]
+            |     |                       |                    |     Select Operator [SEL_60]
             |     |                       |                    |        outputColumnNames:["_col0"]
             |     |                       |                    |        Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |                    |        Filter Operator [FIL_375]
+            |     |                       |                    |        Filter Operator [FIL_320]
             |     |                       |                    |           predicate:(((t_minute >= 30) and (t_hour = 9)) and t_time_sk is not null) (type: boolean)
             |     |                       |                    |           Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |                    |           TableScan [TS_70]
+            |     |                       |                    |           TableScan [TS_58]
             |     |                       |                    |              alias:time_dim
             |     |                       |                    |              Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE
             |     |                       |                    |<-Reducer 25 [SIMPLE_EDGE]
-            |     |                       |                       Reduce Output Operator [RS_82]
+            |     |                       |                       Reduce Output Operator [RS_67]
             |     |                       |                          key expressions:_col0 (type: int)
             |     |                       |                          Map-reduce partition columns:_col0 (type: int)
             |     |                       |                          sort order:+
             |     |                       |                          Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |                       |                          value expressions:_col2 (type: int)
-            |     |                       |                          Merge Join Operator [MERGEJOIN_403]
+            |     |                       |                          Merge Join Operator [MERGEJOIN_348]
             |     |                       |                          |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                       |                          |  keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"}
             |     |                       |                          |  outputColumnNames:["_col0","_col2"]
             |     |                       |                          |  Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |                       |                          |<-Map 24 [SIMPLE_EDGE]
-            |     |                       |                          |  Reduce Output Operator [RS_77]
+            |     |                       |                          |  Reduce Output Operator [RS_64]
             |     |                       |                          |     key expressions:_col1 (type: int)
             |     |                       |                          |     Map-reduce partition columns:_col1 (type: int)
             |     |                       |                          |     sort order:+
             |     |                       |                          |     Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |                       |                          |     value expressions:_col0 (type: int), _col2 (type: int)
-            |     |                       |                          |     Select Operator [SEL_66]
+            |     |                       |                          |     Select Operator [SEL_54]
             |     |                       |                          |        outputColumnNames:["_col0","_col1","_col2"]
             |     |                       |                          |        Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |                       |                          |        Filter Operator [FIL_373]
+            |     |                       |                          |        Filter Operator [FIL_318]
             |     |                       |                          |           predicate:((ss_hdemo_sk is not null and ss_sold_time_sk is not null) and ss_store_sk is not null) (type: boolean)
             |     |                       |                          |           Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |                       |                          |           TableScan [TS_64]
+            |     |                       |                          |           TableScan [TS_52]
             |     |                       |                          |              alias:store_sales
             |     |                       |                          |              Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |                       |                          |<-Map 29 [SIMPLE_EDGE]
-            |     |                       |                             Reduce Output Operator [RS_79]
+            |     |                       |                             Reduce Output Operator [RS_65]
             |     |                       |                                key expressions:_col0 (type: int)
             |     |                       |                                Map-reduce partition columns:_col0 (type: int)
             |     |                       |                                sort order:+
             |     |                       |                                Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |                                Select Operator [SEL_69]
+            |     |                       |                                Select Operator [SEL_57]
             |     |                       |                                   outputColumnNames:["_col0"]
             |     |                       |                                   Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |                                   Filter Operator [FIL_374]
+            |     |                       |                                   Filter Operator [FIL_319]
             |     |                       |                                      predicate:((((hd_dep_count = 3) and (hd_vehicle_count <= 5)) or ((hd_dep_count = 0) and (hd_vehicle_count <= 2)) or ((hd_dep_count = 1) and (hd_vehicle_count <= 3))) and hd_demo_sk is not null) (type: boolean)
             |     |                       |                                      Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |                       |                                      TableScan [TS_67]
+            |     |                       |                                      TableScan [TS_55]
             |     |                       |                                         alias:household_demographics
             |     |                       |                                         Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE
             |     |                       |<-Reducer 6 [SIMPLE_EDGE]
-            |     |                          Reduce Output Operator [RS_266]
+            |     |                          Reduce Output Operator [RS_218]
             |     |                             sort order:
             |     |                             Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                             value expressions:_col0 (type: bigint), _col1 (type: bigint)
-            |     |                             Merge Join Operator [MERGEJOIN_421]
+            |     |                             Merge Join Operator [MERGEJOIN_366]
             |     |                             |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                             |  keys:{}
             |     |                             |  outputColumnNames:["_col0","_col1"]
             |     |                             |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                             |<-Reducer 20 [SIMPLE_EDGE]
-            |     |                             |  Reduce Output Operator [RS_264]
+            |     |                             |  Reduce Output Operator [RS_216]
             |     |                             |     sort order:
             |     |                             |     Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                             |     value expressions:_col0 (type: bigint)
-            |     |                             |     Group By Operator [GBY_62]
+            |     |                             |     Group By Operator [GBY_50]
             |     |                             |     |  aggregations:["count(VALUE._col0)"]
             |     |                             |     |  outputColumnNames:["_col0"]
             |     |                             |     |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                             |     |<-Reducer 19 [SIMPLE_EDGE]
-            |     |                             |        Reduce Output Operator [RS_61]
+            |     |                             |        Reduce Output Operator [RS_49]
             |     |                             |           sort order:
             |     |                             |           Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                             |           value expressions:_col0 (type: bigint)
-            |     |                             |           Group By Operator [GBY_60]
+            |     |                             |           Group By Operator [GBY_48]
             |     |                             |              aggregations:["count()"]
             |     |                             |              outputColumnNames:["_col0"]
             |     |                             |              Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |              Merge Join Operator [MERGEJOIN_402]
+            |     |                             |              Merge Join Operator [MERGEJOIN_347]
             |     |                             |              |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                             |              |  keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"}
             |     |                             |              |  Statistics:Num rows: 17424 Data size: 8206704 Basic stats: COMPLETE Column stats: NONE
             |     |                             |              |<-Map 23 [SIMPLE_EDGE]
-            |     |                             |              |  Reduce Output Operator [RS_57]
+            |     |                             |              |  Reduce Output Operator [RS_45]
             |     |                             |              |     key expressions:_col0 (type: int)
             |     |                             |              |     Map-reduce partition columns:_col0 (type: int)
             |     |                             |              |     sort order:+
             |     |                             |              |     Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |              |     Select Operator [SEL_43]
+            |     |                             |              |     Select Operator [SEL_37]
             |     |                             |              |        outputColumnNames:["_col0"]
             |     |                             |              |        Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |              |        Filter Operator [FIL_372]
+            |     |                             |              |        Filter Operator [FIL_317]
             |     |                             |              |           predicate:((s_store_name = 'ese') and s_store_sk is not null) (type: boolean)
             |     |                             |              |           Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |              |           TableScan [TS_41]
+            |     |                             |              |           TableScan [TS_35]
             |     |                             |              |              alias:store
             |     |                             |              |              Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE
             |     |                             |              |<-Reducer 18 [SIMPLE_EDGE]
-            |     |                             |                 Reduce Output Operator [RS_55]
+            |     |                             |                 Reduce Output Operator [RS_44]
             |     |                             |                    key expressions:_col2 (type: int)
             |     |                             |                    Map-reduce partition columns:_col2 (type: int)
             |     |                             |                    sort order:+
             |     |                             |                    Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |                    Merge Join Operator [MERGEJOIN_401]
+            |     |                             |                    Merge Join Operator [MERGEJOIN_346]
             |     |                             |                    |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                             |                    |  keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"}
             |     |                             |                    |  outputColumnNames:["_col2"]
             |     |                             |                    |  Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
             |     |                             |                    |<-Map 22 [SIMPLE_EDGE]
-            |     |                             |                    |  Reduce Output Operator [RS_52]
+            |     |                             |                    |  Reduce Output Operator [RS_42]
             |     |                             |                    |     key expressions:_col0 (type: int)
             |     |                             |                    |     Map-reduce partition columns:_col0 (type: int)
             |     |                             |                    |     sort order:+
             |     |                             |                    |     Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |                    |     Select Operator [SEL_40]
+            |     |                             |                    |     Select Operator [SEL_34]
             |     |                             |                    |        outputColumnNames:["_col0"]
             |     |                             |                    |        Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |                    |        Filter Operator [FIL_371]
+            |     |                             |                    |        Filter Operator [FIL_316]
             |     |                             |                    |           predicate:(((t_hour = 9) and (t_minute < 30)) and t_time_sk is not null) (type: boolean)
             |     |                             |                    |           Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |                    |           TableScan [TS_38]
+            |     |                             |                    |           TableScan [TS_32]
             |     |                             |                    |              alias:time_dim
             |     |                             |                    |              Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE
             |     |                             |                    |<-Reducer 17 [SIMPLE_EDGE]
-            |     |                             |                       Reduce Output Operator [RS_50]
+            |     |                             |                       Reduce Output Operator [RS_41]
             |     |                             |                          key expressions:_col0 (type: int)
             |     |                             |                          Map-reduce partition columns:_col0 (type: int)
             |     |                             |                          sort order:+
             |     |                             |                          Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |                             |                          value expressions:_col2 (type: int)
-            |     |                             |                          Merge Join Operator [MERGEJOIN_400]
+            |     |                             |                          Merge Join Operator [MERGEJOIN_345]
             |     |                             |                          |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                             |                          |  keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"}
             |     |                             |                          |  outputColumnNames:["_col0","_col2"]
             |     |                             |                          |  Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |                             |                          |<-Map 16 [SIMPLE_EDGE]
-            |     |                             |                          |  Reduce Output Operator [RS_45]
+            |     |                             |                          |  Reduce Output Operator [RS_38]
             |     |                             |                          |     key expressions:_col1 (type: int)
             |     |                             |                          |     Map-reduce partition columns:_col1 (type: int)
             |     |                             |                          |     sort order:+
             |     |                             |                          |     Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |                             |                          |     value expressions:_col0 (type: int), _col2 (type: int)
-            |     |                             |                          |     Select Operator [SEL_34]
+            |     |                             |                          |     Select Operator [SEL_28]
             |     |                             |                          |        outputColumnNames:["_col0","_col1","_col2"]
             |     |                             |                          |        Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |                             |                          |        Filter Operator [FIL_369]
+            |     |                             |                          |        Filter Operator [FIL_314]
             |     |                             |                          |           predicate:((ss_hdemo_sk is not null and ss_sold_time_sk is not null) and ss_store_sk is not null) (type: boolean)
             |     |                             |                          |           Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |                             |                          |           TableScan [TS_32]
+            |     |                             |                          |           TableScan [TS_26]
             |     |                             |                          |              alias:store_sales
             |     |                             |                          |              Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |                             |                          |<-Map 21 [SIMPLE_EDGE]
-            |     |                             |                             Reduce Output Operator [RS_47]
+            |     |                             |                             Reduce Output Operator [RS_39]
             |     |                             |                                key expressions:_col0 (type: int)
             |     |                             |                                Map-reduce partition columns:_col0 (type: int)
             |     |                             |                                sort order:+
             |     |                             |                                Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |                                Select Operator [SEL_37]
+            |     |                             |                                Select Operator [SEL_31]
             |     |                             |                                   outputColumnNames:["_col0"]
             |     |                             |                                   Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |                                   Filter Operator [FIL_370]
+            |     |                             |                                   Filter Operator [FIL_315]
             |     |                             |                                      predicate:((((hd_dep_count = 3) and (hd_vehicle_count <= 5)) or ((hd_dep_count = 0) and (hd_vehicle_count <= 2)) or ((hd_dep_count = 1) and (hd_vehicle_count <= 3))) and hd_demo_sk is not null) (type: boolean)
             |     |                             |                                      Statistics:Num rows: 3600 Data size: 385200 Basic stats: COMPLETE Column stats: NONE
-            |     |                             |                                      TableScan [TS_35]
+            |     |                             |                                      TableScan [TS_29]
             |     |                             |                                         alias:household_demographics
             |     |                             |                                         Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE
             |     |                             |<-Reducer 5 [SIMPLE_EDGE]
-            |     |                                Reduce Output Operator [RS_263]
+            |     |                                Reduce Output Operator [RS_215]
             |     |                                   sort order:
             |     |                                   Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                                   value expressions:_col0 (type: bigint)
-            |     |                                   Group By Operator [GBY_30]
+            |     |                                   Group By Operator [GBY_24]
             |     |                                   |  aggregations:["count(VALUE._col0)"]
             |     |                                   |  outputColumnNames:["_col0"]
             |     |                                   |  Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                                   |<-Reducer 4 [SIMPLE_EDGE]
-            |     |                                      Reduce Output Operator [RS_29]
+            |     |                                      Reduce Output Operator [RS_23]
             |     |                                         sort order:
             |     |                                         Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
             |     |                                         value expressions:_col0 (type: bigint)
-            |     |                                         Group By Operator [GBY_28]
+            |     |                                         Group By Operator [GBY_22]
             |     |                                            aggregations:["count()"]
             |     |                                            outputColumnNames:["_col0"]
             |     |                                            Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE
-            |     |                                            Merge Join Operator [MERGEJOIN_399]
+            |     |                                            Merge Join Operator [MERGEJOIN_344]
             |     |                                            |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                                            |  keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"}
             |     |                                            |  Statistics:Num rows: 17424 Data size: 8206704 Basic stats: COMPLETE Column stats: NONE
             |     |                                            |<-Map 15 [SIMPLE_EDGE]
-            |     |                                            |  Reduce Output Operator [RS_25]
+            |     |                                            |  Reduce Output Operator [RS_19]
             |     |                                            |     key expressions:_col0 (type: int)
             |     |                                            |     Map-reduce partition columns:_col0 (type: int)
             |     |                                            |     sort order:+
@@ -867,25 +867,25 @@ Stage-0
             |     |                                            |     Select Operator [SEL_11]
             |     |                                            |        outputColumnNames:["_col0"]
             |     |                                            |        Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
-            |     |                                            |        Filter Operator [FIL_368]
+            |     |                                            |        Filter Operator [FIL_313]
             |     |                                            |           predicate:((s_store_name = 'ese') and s_store_sk is not null) (type: boolean)
             |     |                                            |           Statistics:Num rows: 852 Data size: 1628138 Basic stats: COMPLETE Column stats: NONE
             |     |                                            |           TableScan [TS_9]
             |     |                                            |              alias:store
             |     |                                            |              Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE
             |     |                                            |<-Reducer 3 [SIMPLE_EDGE]
-            |     |                                               Reduce Output Operator [RS_23]
+            |     |                                               Reduce Output Operator [RS_18]
             |     |                                                  key expressions:_col2 (type: int)
             |     |                                                  Map-reduce partition columns:_col2 (type: int)
             |     |                                                  sort order:+
             |     |                                                  Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
-            |     |                                                  Merge Join Operator [MERGEJOIN_398]
+            |     |                                                  Merge Join Operator [MERGEJOIN_343]
             |     |                                                  |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                                                  |  keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"}
             |     |                                                  |  outputColumnNames:["_col2"]
             |     |                                                  |  Statistics:Num rows: 15840 Data size: 7460640 Basic stats: COMPLETE Column stats: NONE
             |     |                                                  |<-Map 14 [SIMPLE_EDGE]
-            |     |                                                  |  Reduce Output Operator [RS_20]
+            |     |                                                  |  Reduce Output Operator [RS_16]
             |     |                                                  |     key expressions:_col0 (type: int)
             |     |                                                  |     Map-reduce partition columns:_col0 (type: int)
             |     |                                                  |     sort order:+
@@ -893,26 +893,26 @@ Stage-0
             |     |                                                  |     Select Operator [SEL_8]
             |     |                                                  |        outputColumnNames:["_col0"]
             |     |                                                  |        Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
-            |     |                                                  |        Filter Operator [FIL_367]
+            |     |                                                  |        Filter Operator [FIL_312]
             |     |                                                  |           predicate:(((t_minute >= 30) and (t_hour = 8)) and t_time_sk is not null) (type: boolean)
             |     |                                                  |           Statistics:Num rows: 14400 Data size: 6782400 Basic stats: COMPLETE Column stats: NONE
             |     |                                                  |           TableScan [TS_6]
             |     |                                                  |              alias:time_dim
             |     |                                                  |              Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE
             |     |                                                  |<-Reducer 2 [SIMPLE_EDGE]
-            |     |                                                     Reduce Output Operator [RS_18]
+            |     |                                                     Reduce Output Operator [RS_15]
             |     |                                                        key expressions:_col0 (type: int)
             |     |                                                        Map-reduce partition columns:_col0 (type: int)
             |     |                                                        sort order:+
             |     |                                                        Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |                                                        value expressions:_col2 (type: int)
-            |     |                                                        Merge Join Operator [MERGEJOIN_397]
+            |     |                                                        Merge Join Operator [MERGEJOIN_342]
             |     |                                                        |  condition map:[{"":"Inner Join 0 to 1"}]
             |     |                                                        |  keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"}
             |     |                                                        |  outputColumnNames:["_col0","_col2"]
             |     |                                                        |  Statistics:Num rows: 3960 Data size: 423720 Basic stats: COMPLETE Column stats: NONE
             |     |                                                        |<-Map 1 [SIMPLE_EDGE]
-            |     |                                                        |  Reduce Output Operator [RS_13]
+            |     |                                                        |  Reduce Output Operator [RS_12]
             |     |                                                        |     key expressions:_col1 (type: int)
             |     |                                                        |     Map-reduce partition columns:_col1 (type: int)
             |     |                                                        |     sort order:+
@@ -921,14 +921,14 @@ Stage-0
             |     |                                                        |     Select Operator [SEL_2]
             |     |                                                        |        outputColumnNames:["_col0","_col1","_col2"]
             |     |                                                        |        Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
-            |     |                                                        |        Filter Operator [FIL_365]
+            |     |                                                        |        Filter Operator [FIL_310]
             |     |                                                        |           predicate:((ss_hdemo_sk is not null and ss_sold_time_sk is not null) and ss_store_sk is not null) (type: boolean)
             |     |                                                        |           Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |                                                        |           TableScan [TS_0]
             |     |                                                        |              alias:store_sales
             |     |                                                        |              Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE
             |     |                                                        |<-Map 13 [SIMPLE_EDGE]
-            |     |                                                    

<TRUNCATED>

Mime
View raw message