commit 94e5c17126650b23c249bc07b91358e27f1ac390 Author: Pengcheng Xiong Date: Sun Jun 18 00:31:41 2017 -0700 ko diff --git a/itests/src/test/resources/testconfiguration.properties b/itests/src/test/resources/testconfiguration.properties index 1f6939bc91..07fd5bfe48 100644 --- a/itests/src/test/resources/testconfiguration.properties +++ b/itests/src/test/resources/testconfiguration.properties @@ -164,6 +164,7 @@ minillaplocal.shared.query.files=alter_merge_2_orc.q,\ enforce_order.q,\ filter_join_breaktask.q,\ filter_join_breaktask2.q,\ + filter_union.q,\ groupby1.q,\ groupby2.q,\ groupby3.q,\ diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterSetOpTransposeRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterSetOpTransposeRule.java index 3ee29e0482..8772d5989f 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterSetOpTransposeRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterSetOpTransposeRule.java @@ -17,14 +17,31 @@ */ package org.apache.hadoop.hive.ql.optimizer.calcite.rules; +import java.util.ArrayList; +import java.util.List; + +import org.apache.calcite.plan.RelOptPredicateList; import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.plan.RelOptUtil; +import org.apache.calcite.rel.RelNode; import org.apache.calcite.rel.core.Filter; +import org.apache.calcite.rel.core.SetOp; +import org.apache.calcite.rel.core.Union; +import org.apache.calcite.rel.metadata.RelMetadataQuery; import org.apache.calcite.rel.rules.FilterSetOpTransposeRule; +import org.apache.calcite.rel.type.RelDataTypeField; +import org.apache.calcite.rex.RexBuilder; +import org.apache.calcite.rex.RexExecutor; import org.apache.calcite.rex.RexNode; +import org.apache.calcite.rex.RexSimplify; +import org.apache.calcite.rex.RexUtil; +import org.apache.calcite.tools.RelBuilder; import org.apache.calcite.tools.RelBuilderFactory; +import org.apache.calcite.util.Util; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveCalciteUtil; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; +import com.google.common.collect.ImmutableList; public class HiveFilterSetOpTransposeRule extends FilterSetOpTransposeRule { @@ -32,7 +49,24 @@ new HiveFilterSetOpTransposeRule(HiveRelFactories.HIVE_BUILDER); /** - * Creates a HiveFilterSetOpTransposeRule. + * Creates a HiveFilterSetOpTransposeRule. + * This rule rewrites + * Fil + * | + * Union + * / \ + * Op1 Op2 + * + * to + * Union + * /\ + * FIL + * | | + * Op1 Op2 + * + * + * It additionally can remove branch(es) of filter if its able to determine + * that they are going to generate empty result set. */ private HiveFilterSetOpTransposeRule(RelBuilderFactory relBuilderFactory) { super(relBuilderFactory); @@ -48,4 +82,66 @@ public boolean matches(RelOptRuleCall call) { return super.matches(call); } + + + //~ Methods ---------------------------------------------------------------- + + // implement RelOptRule + // We override the rule in order to do union all branch elimination + public void onMatch(RelOptRuleCall call) { + Filter filterRel = call.rel(0); + SetOp setOp = call.rel(1); + + RexNode condition = filterRel.getCondition(); + + // create filters on top of each setop child, modifying the filter + // condition to reference each setop child + RexBuilder rexBuilder = filterRel.getCluster().getRexBuilder(); + final RelBuilder relBuilder = call.builder(); + List origFields = setOp.getRowType().getFieldList(); + int[] adjustments = new int[origFields.size()]; + final List newSetOpInputs = new ArrayList<>(); + RelNode lastInput = null; + for (int index = 0; index < setOp.getInputs().size(); index++) { + RelNode input = setOp.getInput(index); + RexNode newCondition = condition.accept(new RelOptUtil.RexInputConverter(rexBuilder, + origFields, input.getRowType().getFieldList(), adjustments)); + if (setOp instanceof Union && setOp.all) { + final RelMetadataQuery mq = RelMetadataQuery.instance(); + final RelOptPredicateList predicates = mq.getPulledUpPredicates(input); + if (predicates != null) { + ImmutableList.Builder listBuilder = ImmutableList.builder(); + listBuilder.addAll(predicates.pulledUpPredicates); + listBuilder.add(newCondition); + RexExecutor executor = + Util.first(filterRel.getCluster().getPlanner().getExecutor(), RexUtil.EXECUTOR); + final RexSimplify simplify = + new RexSimplify(rexBuilder, true, executor); + final RexNode x = simplify.simplifyAnds(listBuilder.build()); + if (x.isAlwaysFalse()) { + // this is the last branch, and it is always false + // We assume alwaysFalse filter will get pushed down to TS so this + // branch so it won't read any data. + if (index == setOp.getInputs().size() - 1) { + lastInput = relBuilder.push(input).filter(newCondition).build(); + } + // remove this branch + continue; + } + } + } + newSetOpInputs.add(relBuilder.push(input).filter(newCondition).build()); + } + if (newSetOpInputs.size() > 1) { + // create a new setop whose children are the filters created above + SetOp newSetOp = setOp.copy(setOp.getTraitSet(), newSetOpInputs); + call.transformTo(newSetOp); + } else if (newSetOpInputs.size() == 1) { + call.transformTo(newSetOpInputs.get(0)); + } else { + // we have to keep at least a branch before we support empty values() in + // hive + call.transformTo(lastInput); + } + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveUnionMergeRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveUnionMergeRule.java new file mode 100644 index 0000000000..832c87fc77 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveUnionMergeRule.java @@ -0,0 +1,84 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.optimizer.calcite.rules; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.calcite.plan.RelOptRule; +import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.rel.RelNode; +import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveIntersect; +import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveUnion; +import org.apache.calcite.util.Util; + +/** + * Planner rule that merges multiple union into one + * Before the rule, it is + * union all-branch1 + * |-----union all-branch2 + * |-----branch3 + * After the rule, it becomes + * union all-branch1 + * |-----branch2 + * |-----branch3 + * {@link org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveUnion} + */ +public class HiveUnionMergeRule extends RelOptRule { + + public static final HiveUnionMergeRule INSTANCE = new HiveUnionMergeRule(); + + // ~ Constructors ----------------------------------------------------------- + + private HiveUnionMergeRule() { + super( + operand(HiveUnion.class, operand(RelNode.class, any()), operand(RelNode.class, any()))); + } + + // ~ Methods ---------------------------------------------------------------- + + public void onMatch(RelOptRuleCall call) { + final HiveUnion topUnion = call.rel(0); + + final HiveUnion bottomUnion; + if (call.rel(2) instanceof HiveUnion) { + bottomUnion = call.rel(2); + } else if (call.rel(1) instanceof HiveUnion) { + bottomUnion = call.rel(1); + } else { + return; + } + + List inputs = new ArrayList<>(); + if (call.rel(2) instanceof HiveUnion) { + for (int i = 0; i < topUnion.getInputs().size(); i++) { + if (i != 1) { + inputs.add(topUnion.getInput(i)); + } + } + inputs.addAll(bottomUnion.getInputs()); + } else { + inputs.addAll(bottomUnion.getInputs()); + inputs.addAll(Util.skip(topUnion.getInputs())); + } + + HiveUnion newUnion = (HiveUnion) topUnion.copy( + topUnion.getTraitSet(), inputs, true); + call.transformTo(newUnion); + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java index 348331e052..931e074f3e 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java @@ -92,7 +92,6 @@ import org.apache.calcite.rel.rules.SemiJoinFilterTransposeRule; import org.apache.calcite.rel.rules.SemiJoinJoinTransposeRule; import org.apache.calcite.rel.rules.SemiJoinProjectTransposeRule; -import org.apache.calcite.rel.rules.UnionMergeRule; import org.apache.calcite.rel.type.RelDataType; import org.apache.calcite.rel.type.RelDataTypeFactory; import org.apache.calcite.rel.type.RelDataTypeField; @@ -209,6 +208,7 @@ import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveSortRemoveRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveSortUnionReduceRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveSubQueryRemoveRule; +import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveUnionMergeRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveUnionPullUpConstantsRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveWindowingFixRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.views.HiveMaterializedViewFilterScanRule; @@ -260,6 +260,7 @@ import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; + import org.apache.calcite.config.CalciteConnectionConfig; public class CalcitePlanner extends SemanticAnalyzer { @@ -1437,7 +1438,7 @@ public RelNode apply(RelOptCluster cluster, RelOptSchema relOptSchema, SchemaPlu // 4. Run other optimizations that do not need stats perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, false, mdProvider.getMetadataProvider(), null, - HepMatchOrder.BOTTOM_UP, ProjectRemoveRule.INSTANCE, UnionMergeRule.INSTANCE, + HepMatchOrder.BOTTOM_UP, ProjectRemoveRule.INSTANCE, HiveUnionMergeRule.INSTANCE, HiveProjectMergeRule.INSTANCE_NO_FORCE, HiveAggregateProjectMergeRule.INSTANCE, HiveJoinCommuteRule.INSTANCE); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Optimizations without stats"); @@ -1618,9 +1619,10 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv //0. SetOp rewrite perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); basePlan = hepPlan(basePlan, true, mdProvider, null, HepMatchOrder.BOTTOM_UP, - HiveProjectOverIntersectRemoveRule.INSTANCE, HiveIntersectMergeRule.INSTANCE); + HiveProjectOverIntersectRemoveRule.INSTANCE, HiveIntersectMergeRule.INSTANCE, + HiveUnionMergeRule.INSTANCE); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, - "Calcite: HiveProjectOverIntersectRemoveRule and HiveIntersectMerge rules"); + "Calcite: HiveProjectOverIntersectRemoveRule, HiveIntersectMerge and HiveUnionMergeRule rules"); perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); basePlan = hepPlan(basePlan, false, mdProvider, executorProvider, HepMatchOrder.BOTTOM_UP, diff --git a/ql/src/test/queries/clientpositive/filter_union.q b/ql/src/test/queries/clientpositive/filter_union.q new file mode 100644 index 0000000000..c3f380dfff --- /dev/null +++ b/ql/src/test/queries/clientpositive/filter_union.q @@ -0,0 +1,56 @@ +set hive.mapred.mode=nonstrict; +set hive.optimize.metadataonly=true; + +explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m >2; + + +explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 1; + +explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 4; + + +explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 5; diff --git a/ql/src/test/queries/clientpositive/perf/query11.q b/ql/src/test/queries/clientpositive/perf/query11.q new file mode 100644 index 0000000000..6017c89790 --- /dev/null +++ b/ql/src/test/queries/clientpositive/perf/query11.q @@ -0,0 +1,77 @@ +set hive.mapred.mode=nonstrict; +-- start query 1 in stream 0 using template query11.tpl and seed 1819994127 +explain +with year_total as ( + select c_customer_id customer_id + ,c_first_name customer_first_name + ,c_last_name customer_last_name + ,c_preferred_cust_flag + ,c_birth_country customer_birth_country + ,c_login customer_login + ,c_email_address customer_email_address + ,d_year dyear + ,sum(ss_ext_list_price-ss_ext_discount_amt) year_total + ,'s' sale_type + from customer + ,store_sales + ,date_dim + where c_customer_sk = ss_customer_sk + and ss_sold_date_sk = d_date_sk + group by c_customer_id + ,c_first_name + ,c_last_name + ,d_year + ,c_preferred_cust_flag + ,c_birth_country + ,c_login + ,c_email_address + ,d_year + union all + select c_customer_id customer_id + ,c_first_name customer_first_name + ,c_last_name customer_last_name + ,c_preferred_cust_flag + ,c_birth_country customer_birth_country + ,c_login customer_login + ,c_email_address customer_email_address + ,d_year dyear + ,sum(ws_ext_list_price-ws_ext_discount_amt) year_total + ,'w' sale_type + from customer + ,web_sales + ,date_dim + where c_customer_sk = ws_bill_customer_sk + and ws_sold_date_sk = d_date_sk + group by c_customer_id + ,c_first_name + ,c_last_name + ,c_preferred_cust_flag + ,c_birth_country + ,c_login + ,c_email_address + ,d_year + ) + select t_s_secyear.c_preferred_cust_flag + from year_total t_s_firstyear + ,year_total t_s_secyear + ,year_total t_w_firstyear + ,year_total t_w_secyear + where t_s_secyear.customer_id = t_s_firstyear.customer_id + and t_s_firstyear.customer_id = t_w_secyear.customer_id + and t_s_firstyear.customer_id = t_w_firstyear.customer_id + and t_s_firstyear.sale_type = 's' + and t_w_firstyear.sale_type = 'w' + and t_s_secyear.sale_type = 's' + and t_w_secyear.sale_type = 'w' + and t_s_firstyear.dyear = 2001 + and t_s_secyear.dyear = 2001+1 + and t_w_firstyear.dyear = 2001 + and t_w_secyear.dyear = 2001+1 + and t_s_firstyear.year_total > 0 + and t_w_firstyear.year_total > 0 + and case when t_w_firstyear.year_total > 0 then t_w_secyear.year_total / t_w_firstyear.year_total else null end + > case when t_s_firstyear.year_total > 0 then t_s_secyear.year_total / t_s_firstyear.year_total else null end + order by t_s_secyear.c_preferred_cust_flag +limit 100; + +-- end query 1 in stream 0 using template query11.tpl diff --git a/ql/src/test/results/clientpositive/filter_aggr.q.out b/ql/src/test/results/clientpositive/filter_aggr.q.out index db7dcaed3f..008b7d65cf 100644 --- a/ql/src/test/results/clientpositive/filter_aggr.q.out +++ b/ql/src/test/results/clientpositive/filter_aggr.q.out @@ -18,9 +18,7 @@ where m = 1 POSTHOOK: type: QUERY STAGE DEPENDENCIES: Stage-1 is a root stage - Stage-2 depends on stages: Stage-1, Stage-3 - Stage-3 is a root stage - Stage-0 depends on stages: Stage-2 + Stage-0 depends on stages: Stage-1 STAGE PLANS: Stage: Stage-1 @@ -99,7 +97,7 @@ STAGE PLANS: name: default.src name: default.src Truncated Path -> Alias: - /src [null-subquery1:$hdt$_0-subquery1:src] + /src [src] Needs Tagging: false Reduce Operator Tree: Group By Operator @@ -117,228 +115,20 @@ STAGE PLANS: GlobalTableId: 0 #### A masked pattern was here #### NumFilesPerFileSink: 1 - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - column.name.delimiter , - columns _col0,_col1,_col2 - columns.types string,bigint,int - escape.delim \ - serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - TotalFiles: 1 - GatherStats: false - MultiFileSpray: false - - Stage: Stage-2 - Map Reduce - Map Operator Tree: - TableScan - GatherStats: false - Union - Statistics: Num rows: 251 Data size: 2666 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - GlobalTableId: 0 -#### A masked pattern was here #### - NumFilesPerFileSink: 1 - Statistics: Num rows: 251 Data size: 2666 Basic stats: COMPLETE Column stats: NONE -#### A masked pattern was here #### - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - columns _col0,_col1,_col2 - columns.types string:bigint:int - escape.delim \ - hive.serialization.extend.additional.nesting.levels true - serialization.escape.crlf true - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - TotalFiles: 1 - GatherStats: false - MultiFileSpray: false - TableScan - GatherStats: false - Union - Statistics: Num rows: 251 Data size: 2666 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - GlobalTableId: 0 -#### A masked pattern was here #### - NumFilesPerFileSink: 1 - Statistics: Num rows: 251 Data size: 2666 Basic stats: COMPLETE Column stats: NONE -#### A masked pattern was here #### - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - columns _col0,_col1,_col2 - columns.types string:bigint:int - escape.delim \ - hive.serialization.extend.additional.nesting.levels true - serialization.escape.crlf true - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - TotalFiles: 1 - GatherStats: false - MultiFileSpray: false - Path -> Alias: -#### A masked pattern was here #### - Path -> Partition: -#### A masked pattern was here #### - Partition - base file name: -mr-10004 - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - column.name.delimiter , - columns _col0,_col1,_col2 - columns.types string,bigint,int - escape.delim \ - serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - column.name.delimiter , - columns _col0,_col1,_col2 - columns.types string,bigint,int - escape.delim \ - serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe -#### A masked pattern was here #### - Partition - base file name: -mr-10005 - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - column.name.delimiter , - columns _col0,_col1,_col2 - columns.types string,bigint,int - escape.delim \ - serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - column.name.delimiter , - columns _col0,_col1,_col2 - columns.types string,bigint,int - escape.delim \ - serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - Truncated Path -> Alias: -#### A masked pattern was here #### - - Stage: Stage-3 - Map Reduce - Map Operator Tree: - TableScan - alias: src - Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE - GatherStats: false - Filter Operator - isSamplingPred: false - predicate: false (type: boolean) - Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE - Group By Operator - aggregations: count(key) - keys: key (type: string) - mode: hash - outputColumnNames: _col0, _col1 - Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: a - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE - tag: -1 - value expressions: _col1 (type: bigint) - auto parallelism: false - Path -> Alias: - nullscan://null/default.src/part_ [null-subquery2:$hdt$_0-subquery2:src] - Path -> Partition: - nullscan://null/default.src/part_ - Partition - input format: org.apache.hadoop.hive.ql.io.OneNullRowInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - properties: - COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} - bucket_count -1 - column.name.delimiter , - columns key,value - columns.comments 'default','default' - columns.types string:string -#### A masked pattern was here #### - name default.src - numFiles 1 - numRows 500 - rawDataSize 5312 - serialization.ddl struct src { string key, string value} - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.NullStructSerDe - totalSize 5812 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.serde2.NullStructSerDe - - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - properties: - COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} - bucket_count -1 - column.name.delimiter , - columns key,value - columns.comments 'default','default' - columns.types string:string + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE #### A masked pattern was here #### - name default.src - numFiles 1 - numRows 500 - rawDataSize 5312 - serialization.ddl struct src { string key, string value} - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - totalSize 5812 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - name: default.src - name: default.src - Truncated Path -> Alias: - nullscan://null/default.src/part_ [null-subquery2:$hdt$_0-subquery2:src] - Needs Tagging: false - Reduce Operator Tree: - Group By Operator - aggregations: count(VALUE._col0) - keys: KEY._col0 (type: string) - mode: mergepartial - outputColumnNames: _col0, _col1 - Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: bigint), 2 (type: int) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - GlobalTableId: 0 -#### A masked pattern was here #### - NumFilesPerFileSink: 1 table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat properties: - column.name.delimiter , columns _col0,_col1,_col2 - columns.types string,bigint,int + columns.types string:bigint:int escape.delim \ - serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + hive.serialization.extend.additional.nesting.levels true + serialization.escape.crlf true + serialization.format 1 + serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe TotalFiles: 1 GatherStats: false MultiFileSpray: false diff --git a/ql/src/test/results/clientpositive/filter_union.q.out b/ql/src/test/results/clientpositive/filter_union.q.out new file mode 100644 index 0000000000..038e4626b5 --- /dev/null +++ b/ql/src/test/results/clientpositive/filter_union.q.out @@ -0,0 +1,476 @@ +PREHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m >2 +PREHOOK: type: QUERY +POSTHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m >2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1, Stage-3, Stage-4, Stage-5 + Stage-3 is a root stage + Stage-4 is a root stage + Stage-5 is a root stage + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: false (type: boolean) + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 1 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Union + Statistics: Num rows: 502 Data size: 5332 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 502 Data size: 5332 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + TableScan + Union + Statistics: Num rows: 502 Data size: 5332 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 502 Data size: 5332 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + TableScan + Union + Statistics: Num rows: 502 Data size: 5332 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 502 Data size: 5332 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + TableScan + Union + Statistics: Num rows: 502 Data size: 5332 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 502 Data size: 5332 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-3 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: false (type: boolean) + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 2 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-4 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: key (type: string) + outputColumnNames: key + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 3 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-5 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: key (type: string) + outputColumnNames: key + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 4 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 1 +PREHOOK: type: QUERY +POSTHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 1 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: key (type: string) + outputColumnNames: key + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 1 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 4 +PREHOOK: type: QUERY +POSTHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 4 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: key (type: string) + outputColumnNames: key + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 4 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 5 +PREHOOK: type: QUERY +POSTHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 5 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: false (type: boolean) + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 4 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + diff --git a/ql/src/test/results/clientpositive/llap/explainuser_1.q.out b/ql/src/test/results/clientpositive/llap/explainuser_1.q.out index 8b04bc9261..28ca13b6d4 100644 --- a/ql/src/test/results/clientpositive/llap/explainuser_1.q.out +++ b/ql/src/test/results/clientpositive/llap/explainuser_1.q.out @@ -787,12 +787,12 @@ Stage-0 limit:-1 Stage-1 Reducer 4 llap - File Output Operator [FS_26] - Select Operator [SEL_25] (rows=3 width=87) + File Output Operator [FS_25] + Select Operator [SEL_24] (rows=3 width=87) Output:["_col0"] <-Union 3 [SIMPLE_EDGE] <-Reducer 2 [CONTAINS] llap - Reduce Output Operator [RS_24] + Reduce Output Operator [RS_23] Select Operator [SEL_5] (rows=1 width=87) Output:["_col0"] Group By Operator [GBY_4] (rows=1 width=8) @@ -806,7 +806,7 @@ Stage-0 TableScan [TS_0] (rows=20 width=80) default@cbo_t3,s1,Tbl:COMPLETE,Col:COMPLETE,Output:["key"] <-Reducer 6 [CONTAINS] llap - Reduce Output Operator [RS_24] + Reduce Output Operator [RS_23] Select Operator [SEL_12] (rows=1 width=87) Output:["_col0"] Group By Operator [GBY_11] (rows=1 width=8) @@ -820,18 +820,18 @@ Stage-0 TableScan [TS_7] (rows=20 width=80) default@cbo_t3,s2,Tbl:COMPLETE,Col:COMPLETE,Output:["key"] <-Reducer 8 [CONTAINS] llap - Reduce Output Operator [RS_24] - Select Operator [SEL_21] (rows=1 width=87) + Reduce Output Operator [RS_23] + Select Operator [SEL_20] (rows=1 width=87) Output:["_col0"] - Group By Operator [GBY_20] (rows=1 width=8) + Group By Operator [GBY_19] (rows=1 width=8) Output:["_col0"],aggregations:["count(VALUE._col0)"] <-Map 7 [CUSTOM_SIMPLE_EDGE] llap - PARTITION_ONLY_SHUFFLE [RS_19] - Group By Operator [GBY_18] (rows=1 width=8) + PARTITION_ONLY_SHUFFLE [RS_18] + Group By Operator [GBY_17] (rows=1 width=8) Output:["_col0"],aggregations:["count(key)"] - Select Operator [SEL_17] (rows=20 width=80) + Select Operator [SEL_16] (rows=20 width=80) Output:["key"] - TableScan [TS_16] (rows=20 width=80) + TableScan [TS_15] (rows=20 width=80) default@cbo_t3,s3,Tbl:COMPLETE,Col:COMPLETE,Output:["key"] PREHOOK: query: explain select unionsrc.key, count(1) FROM (select 'max' as key, max(c_int) as value from cbo_t3 s1 @@ -860,18 +860,18 @@ Stage-0 limit:-1 Stage-1 Reducer 5 llap - File Output Operator [FS_31] - Select Operator [SEL_30] (rows=1 width=95) + File Output Operator [FS_30] + Select Operator [SEL_29] (rows=1 width=95) Output:["_col0","_col1"] <-Reducer 4 [SIMPLE_EDGE] llap - SHUFFLE [RS_29] - Group By Operator [GBY_27] (rows=1 width=95) + SHUFFLE [RS_28] + Group By Operator [GBY_26] (rows=1 width=95) Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 <-Union 3 [SIMPLE_EDGE] <-Reducer 2 [CONTAINS] llap - Reduce Output Operator [RS_26] + Reduce Output Operator [RS_25] PartitionCols:_col0 - Group By Operator [GBY_25] (rows=1 width=95) + Group By Operator [GBY_24] (rows=1 width=95) Output:["_col0","_col1"],aggregations:["count(1)"],keys:_col0 Select Operator [SEL_5] (rows=1 width=87) Output:["_col0"] @@ -886,9 +886,9 @@ Stage-0 TableScan [TS_0] (rows=20 width=80) default@cbo_t3,s1,Tbl:COMPLETE,Col:COMPLETE,Output:["key"] <-Reducer 7 [CONTAINS] llap - Reduce Output Operator [RS_26] + Reduce Output Operator [RS_25] PartitionCols:_col0 - Group By Operator [GBY_25] (rows=1 width=95) + Group By Operator [GBY_24] (rows=1 width=95) Output:["_col0","_col1"],aggregations:["count(1)"],keys:_col0 Select Operator [SEL_12] (rows=1 width=87) Output:["_col0"] @@ -903,21 +903,21 @@ Stage-0 TableScan [TS_7] (rows=20 width=80) default@cbo_t3,s2,Tbl:COMPLETE,Col:COMPLETE,Output:["key"] <-Reducer 9 [CONTAINS] llap - Reduce Output Operator [RS_26] + Reduce Output Operator [RS_25] PartitionCols:_col0 - Group By Operator [GBY_25] (rows=1 width=95) + Group By Operator [GBY_24] (rows=1 width=95) Output:["_col0","_col1"],aggregations:["count(1)"],keys:_col0 - Select Operator [SEL_21] (rows=1 width=87) + Select Operator [SEL_20] (rows=1 width=87) Output:["_col0"] - Group By Operator [GBY_20] (rows=1 width=8) + Group By Operator [GBY_19] (rows=1 width=8) Output:["_col0"],aggregations:["count(VALUE._col0)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] llap - PARTITION_ONLY_SHUFFLE [RS_19] - Group By Operator [GBY_18] (rows=1 width=8) + PARTITION_ONLY_SHUFFLE [RS_18] + Group By Operator [GBY_17] (rows=1 width=8) Output:["_col0"],aggregations:["count(key)"] - Select Operator [SEL_17] (rows=20 width=80) + Select Operator [SEL_16] (rows=20 width=80) Output:["key"] - TableScan [TS_16] (rows=20 width=80) + TableScan [TS_15] (rows=20 width=80) default@cbo_t3,s3,Tbl:COMPLETE,Col:COMPLETE,Output:["key"] PREHOOK: query: explain select cbo_t1.key from cbo_t1 join cbo_t3 where cbo_t1.key=cbo_t3.key and cbo_t1.key >= 1 diff --git a/ql/src/test/results/clientpositive/llap/explainuser_2.q.out b/ql/src/test/results/clientpositive/llap/explainuser_2.q.out index e3f70b097f..a250fd6527 100644 --- a/ql/src/test/results/clientpositive/llap/explainuser_2.q.out +++ b/ql/src/test/results/clientpositive/llap/explainuser_2.q.out @@ -2059,97 +2059,97 @@ Stage-0 Stage-1 Union 4 <-Map 16 [CONTAINS] llap - File Output Operator [FS_78] - Select Operator [SEL_76] (rows=1677 width=10) + File Output Operator [FS_74] + Select Operator [SEL_72] (rows=1677 width=10) Output:["_col0","_col1"] - Map Join Operator [MAPJOIN_123] (rows=1677 width=10) - Conds:RS_73._col1=SEL_56._col0(Inner),Output:["_col0","_col3"] + Map Join Operator [MAPJOIN_119] (rows=1677 width=10) + Conds:RS_69._col1=SEL_54._col0(Inner),Output:["_col0","_col3"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_73] + BROADCAST [RS_69] PartitionCols:_col1 - Map Join Operator [MAPJOIN_122] (rows=27 width=7) - Conds:SEL_50._col0=RS_71._col0(Inner),Output:["_col0","_col1","_col3"] + Map Join Operator [MAPJOIN_118] (rows=27 width=7) + Conds:SEL_48._col0=RS_67._col0(Inner),Output:["_col0","_col1","_col3"] <-Map 15 [BROADCAST_EDGE] llap - BROADCAST [RS_71] + BROADCAST [RS_67] PartitionCols:_col0 - Select Operator [SEL_53] (rows=25 width=7) + Select Operator [SEL_51] (rows=25 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_113] (rows=25 width=7) + Filter Operator [FIL_109] (rows=25 width=7) predicate:key is not null - TableScan [TS_51] (rows=25 width=7) + TableScan [TS_49] (rows=25 width=7) default@src1,y,Tbl:COMPLETE,Col:NONE,Output:["key","value"] - <-Select Operator [SEL_50] (rows=25 width=7) + <-Select Operator [SEL_48] (rows=25 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_112] (rows=25 width=7) + Filter Operator [FIL_108] (rows=25 width=7) predicate:(key is not null and value is not null) TableScan [TS_8] (rows=25 width=7) default@src1,x,Tbl:COMPLETE,Col:NONE,Output:["key","value"] - <-Select Operator [SEL_56] (rows=25 width=7) + <-Select Operator [SEL_54] (rows=25 width=7) Output:["_col0"] - Filter Operator [FIL_114] (rows=25 width=7) + Filter Operator [FIL_110] (rows=25 width=7) predicate:value is not null - TableScan [TS_54] (rows=25 width=7) + TableScan [TS_52] (rows=25 width=7) Output:["value"] <-Map 17 [CONTAINS] llap - File Output Operator [FS_78] - Select Operator [SEL_76] (rows=1677 width=10) + File Output Operator [FS_74] + Select Operator [SEL_72] (rows=1677 width=10) Output:["_col0","_col1"] - Map Join Operator [MAPJOIN_123] (rows=1677 width=10) - Conds:RS_128._col1=SEL_59._col0(Inner),Output:["_col0","_col3"] + Map Join Operator [MAPJOIN_119] (rows=1677 width=10) + Conds:RS_124._col1=SEL_57._col0(Inner),Output:["_col0","_col3"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_128] + BROADCAST [RS_124] PartitionCols:_col1 - Please refer to the previous Map Join Operator [MAPJOIN_122] - <-Select Operator [SEL_59] (rows=500 width=10) + Please refer to the previous Map Join Operator [MAPJOIN_118] + <-Select Operator [SEL_57] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_115] (rows=500 width=10) + Filter Operator [FIL_111] (rows=500 width=10) predicate:value is not null - TableScan [TS_57] (rows=500 width=10) + TableScan [TS_55] (rows=500 width=10) Output:["value"] <-Map 18 [CONTAINS] llap - File Output Operator [FS_78] - Select Operator [SEL_76] (rows=1677 width=10) + File Output Operator [FS_74] + Select Operator [SEL_72] (rows=1677 width=10) Output:["_col0","_col1"] - Map Join Operator [MAPJOIN_123] (rows=1677 width=10) - Conds:RS_129._col1=SEL_64._col0(Inner),Output:["_col0","_col3"] + Map Join Operator [MAPJOIN_119] (rows=1677 width=10) + Conds:RS_125._col1=SEL_61._col0(Inner),Output:["_col0","_col3"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_129] + BROADCAST [RS_125] PartitionCols:_col1 - Please refer to the previous Map Join Operator [MAPJOIN_122] - <-Select Operator [SEL_64] (rows=500 width=10) + Please refer to the previous Map Join Operator [MAPJOIN_118] + <-Select Operator [SEL_61] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_116] (rows=500 width=10) + Filter Operator [FIL_112] (rows=500 width=10) predicate:value is not null - TableScan [TS_62] (rows=500 width=10) + TableScan [TS_59] (rows=500 width=10) Output:["value"] <-Map 19 [CONTAINS] llap - File Output Operator [FS_78] - Select Operator [SEL_76] (rows=1677 width=10) + File Output Operator [FS_74] + Select Operator [SEL_72] (rows=1677 width=10) Output:["_col0","_col1"] - Map Join Operator [MAPJOIN_123] (rows=1677 width=10) - Conds:RS_130._col1=SEL_68._col0(Inner),Output:["_col0","_col3"] + Map Join Operator [MAPJOIN_119] (rows=1677 width=10) + Conds:RS_126._col1=SEL_64._col0(Inner),Output:["_col0","_col3"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_130] + BROADCAST [RS_126] PartitionCols:_col1 - Please refer to the previous Map Join Operator [MAPJOIN_122] - <-Select Operator [SEL_68] (rows=500 width=10) + Please refer to the previous Map Join Operator [MAPJOIN_118] + <-Select Operator [SEL_64] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_117] (rows=500 width=10) + Filter Operator [FIL_113] (rows=500 width=10) predicate:value is not null - TableScan [TS_66] (rows=500 width=10) + TableScan [TS_62] (rows=500 width=10) Output:["value"] <-Reducer 3 [CONTAINS] llap - File Output Operator [FS_78] + File Output Operator [FS_74] Select Operator [SEL_20] (rows=634 width=10) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_119] (rows=634 width=10) + Merge Join Operator [MERGEJOIN_115] (rows=634 width=10) Conds:Union 2._col1=RS_18._col0(Inner),Output:["_col1","_col4"] <-Map 7 [SIMPLE_EDGE] llap SHUFFLE [RS_18] PartitionCols:_col0 Select Operator [SEL_13] (rows=500 width=10) Output:["_col0","_col1"] - Filter Operator [FIL_106] (rows=500 width=10) + Filter Operator [FIL_102] (rows=500 width=10) predicate:key is not null TableScan [TS_11] (rows=500 width=10) default@src,y,Tbl:COMPLETE,Col:NONE,Output:["key","value"] @@ -2157,92 +2157,92 @@ Stage-0 <-Map 1 [CONTAINS] llap Reduce Output Operator [RS_17] PartitionCols:_col1 - Map Join Operator [MAPJOIN_118] (rows=577 width=10) + Map Join Operator [MAPJOIN_114] (rows=577 width=10) Conds:SEL_2._col0=RS_15._col1(Inner),Output:["_col1"] <-Map 6 [BROADCAST_EDGE] llap BROADCAST [RS_15] PartitionCols:_col1 Select Operator [SEL_10] (rows=25 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_105] (rows=25 width=7) + Filter Operator [FIL_101] (rows=25 width=7) predicate:(key is not null and value is not null) Please refer to the previous TableScan [TS_8] <-Select Operator [SEL_2] (rows=25 width=7) Output:["_col0"] - Filter Operator [FIL_103] (rows=25 width=7) + Filter Operator [FIL_99] (rows=25 width=7) predicate:value is not null TableScan [TS_0] (rows=25 width=7) Output:["value"] <-Map 5 [CONTAINS] llap Reduce Output Operator [RS_17] PartitionCols:_col1 - Map Join Operator [MAPJOIN_118] (rows=577 width=10) - Conds:SEL_5._col0=RS_124._col1(Inner),Output:["_col1"] + Map Join Operator [MAPJOIN_114] (rows=577 width=10) + Conds:SEL_5._col0=RS_120._col1(Inner),Output:["_col1"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_124] + BROADCAST [RS_120] PartitionCols:_col1 Please refer to the previous Select Operator [SEL_10] <-Select Operator [SEL_5] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_104] (rows=500 width=10) + Filter Operator [FIL_100] (rows=500 width=10) predicate:value is not null TableScan [TS_3] (rows=500 width=10) Output:["value"] <-Reducer 9 [CONTAINS] llap - File Output Operator [FS_78] - Select Operator [SEL_45] (rows=1239 width=10) + File Output Operator [FS_74] + Select Operator [SEL_44] (rows=1239 width=10) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_121] (rows=1239 width=10) - Conds:RS_42._col1=RS_43._col0(Inner),Output:["_col1","_col4"] + Merge Join Operator [MERGEJOIN_117] (rows=1239 width=10) + Conds:RS_41._col1=RS_42._col0(Inner),Output:["_col1","_col4"] <-Map 14 [SIMPLE_EDGE] llap - SHUFFLE [RS_43] + SHUFFLE [RS_42] PartitionCols:_col0 - Select Operator [SEL_38] (rows=500 width=10) + Select Operator [SEL_37] (rows=500 width=10) Output:["_col0","_col1"] - Filter Operator [FIL_111] (rows=500 width=10) + Filter Operator [FIL_107] (rows=500 width=10) predicate:key is not null - TableScan [TS_36] (rows=500 width=10) + TableScan [TS_35] (rows=500 width=10) default@src,y,Tbl:COMPLETE,Col:NONE,Output:["key","value"] <-Reducer 8 [SIMPLE_EDGE] llap - SHUFFLE [RS_42] + SHUFFLE [RS_41] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_120] (rows=1127 width=10) - Conds:Union 11._col0=RS_40._col1(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_116] (rows=1127 width=10) + Conds:Union 11._col0=RS_39._col1(Inner),Output:["_col1"] <-Map 7 [SIMPLE_EDGE] llap - SHUFFLE [RS_40] + SHUFFLE [RS_39] PartitionCols:_col1 - Select Operator [SEL_35] (rows=500 width=10) + Select Operator [SEL_34] (rows=500 width=10) Output:["_col0","_col1"] - Filter Operator [FIL_110] (rows=500 width=10) + Filter Operator [FIL_106] (rows=500 width=10) predicate:(key is not null and value is not null) Please refer to the previous TableScan [TS_11] <-Union 11 [SIMPLE_EDGE] <-Map 10 [CONTAINS] llap - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col0 Select Operator [SEL_23] (rows=25 width=7) Output:["_col0"] - Filter Operator [FIL_107] (rows=25 width=7) + Filter Operator [FIL_103] (rows=25 width=7) predicate:value is not null TableScan [TS_21] (rows=25 width=7) Output:["value"] <-Map 12 [CONTAINS] llap - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col0 Select Operator [SEL_26] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_108] (rows=500 width=10) + Filter Operator [FIL_104] (rows=500 width=10) predicate:value is not null TableScan [TS_24] (rows=500 width=10) Output:["value"] <-Map 13 [CONTAINS] llap - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col0 - Select Operator [SEL_31] (rows=500 width=10) + Select Operator [SEL_30] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_109] (rows=500 width=10) + Filter Operator [FIL_105] (rows=500 width=10) predicate:value is not null - TableScan [TS_29] (rows=500 width=10) + TableScan [TS_28] (rows=500 width=10) Output:["value"] PREHOOK: query: explain @@ -2641,126 +2641,126 @@ Stage-5 Stage-3 Union 4 <-Map 16 [CONTAINS] llap - File Output Operator [FS_79] + File Output Operator [FS_75] table:{"name:":"default.a"} - Select Operator [SEL_76] (rows=1677 width=10) + Select Operator [SEL_72] (rows=1677 width=10) Output:["_col0","_col1"] - Map Join Operator [MAPJOIN_128] (rows=1677 width=10) - Conds:RS_73._col1=SEL_56._col0(Inner),Output:["_col0","_col3"] + Map Join Operator [MAPJOIN_124] (rows=1677 width=10) + Conds:RS_69._col1=SEL_54._col0(Inner),Output:["_col0","_col3"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_73] + BROADCAST [RS_69] PartitionCols:_col1 - Map Join Operator [MAPJOIN_127] (rows=27 width=7) - Conds:SEL_50._col0=RS_71._col0(Inner),Output:["_col0","_col1","_col3"] + Map Join Operator [MAPJOIN_123] (rows=27 width=7) + Conds:SEL_48._col0=RS_67._col0(Inner),Output:["_col0","_col1","_col3"] <-Map 15 [BROADCAST_EDGE] llap - BROADCAST [RS_71] + BROADCAST [RS_67] PartitionCols:_col0 - Select Operator [SEL_53] (rows=25 width=7) + Select Operator [SEL_51] (rows=25 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_118] (rows=25 width=7) + Filter Operator [FIL_114] (rows=25 width=7) predicate:key is not null - TableScan [TS_51] (rows=25 width=7) + TableScan [TS_49] (rows=25 width=7) default@src1,y,Tbl:COMPLETE,Col:NONE,Output:["key","value"] - <-Select Operator [SEL_50] (rows=25 width=7) + <-Select Operator [SEL_48] (rows=25 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_117] (rows=25 width=7) + Filter Operator [FIL_113] (rows=25 width=7) predicate:(key is not null and value is not null) TableScan [TS_8] (rows=25 width=7) default@src1,x,Tbl:COMPLETE,Col:NONE,Output:["key","value"] - <-Select Operator [SEL_56] (rows=25 width=7) + <-Select Operator [SEL_54] (rows=25 width=7) Output:["_col0"] - Filter Operator [FIL_119] (rows=25 width=7) + Filter Operator [FIL_115] (rows=25 width=7) predicate:value is not null - TableScan [TS_54] (rows=25 width=7) + TableScan [TS_52] (rows=25 width=7) Output:["value"] - File Output Operator [FS_81] + File Output Operator [FS_77] table:{"name:":"default.b"} - Please refer to the previous Select Operator [SEL_76] - File Output Operator [FS_83] + Please refer to the previous Select Operator [SEL_72] + File Output Operator [FS_79] table:{"name:":"default.c"} - Please refer to the previous Select Operator [SEL_76] + Please refer to the previous Select Operator [SEL_72] <-Map 17 [CONTAINS] llap - File Output Operator [FS_79] + File Output Operator [FS_75] table:{"name:":"default.a"} - Select Operator [SEL_76] (rows=1677 width=10) + Select Operator [SEL_72] (rows=1677 width=10) Output:["_col0","_col1"] - Map Join Operator [MAPJOIN_128] (rows=1677 width=10) - Conds:RS_133._col1=SEL_59._col0(Inner),Output:["_col0","_col3"] + Map Join Operator [MAPJOIN_124] (rows=1677 width=10) + Conds:RS_129._col1=SEL_57._col0(Inner),Output:["_col0","_col3"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_133] + BROADCAST [RS_129] PartitionCols:_col1 - Please refer to the previous Map Join Operator [MAPJOIN_127] - <-Select Operator [SEL_59] (rows=500 width=10) + Please refer to the previous Map Join Operator [MAPJOIN_123] + <-Select Operator [SEL_57] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_120] (rows=500 width=10) + Filter Operator [FIL_116] (rows=500 width=10) predicate:value is not null - TableScan [TS_57] (rows=500 width=10) + TableScan [TS_55] (rows=500 width=10) Output:["value"] - File Output Operator [FS_81] + File Output Operator [FS_77] table:{"name:":"default.b"} - Please refer to the previous Select Operator [SEL_76] - File Output Operator [FS_83] + Please refer to the previous Select Operator [SEL_72] + File Output Operator [FS_79] table:{"name:":"default.c"} - Please refer to the previous Select Operator [SEL_76] + Please refer to the previous Select Operator [SEL_72] <-Map 18 [CONTAINS] llap - File Output Operator [FS_79] + File Output Operator [FS_75] table:{"name:":"default.a"} - Select Operator [SEL_76] (rows=1677 width=10) + Select Operator [SEL_72] (rows=1677 width=10) Output:["_col0","_col1"] - Map Join Operator [MAPJOIN_128] (rows=1677 width=10) - Conds:RS_134._col1=SEL_64._col0(Inner),Output:["_col0","_col3"] + Map Join Operator [MAPJOIN_124] (rows=1677 width=10) + Conds:RS_130._col1=SEL_61._col0(Inner),Output:["_col0","_col3"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_134] + BROADCAST [RS_130] PartitionCols:_col1 - Please refer to the previous Map Join Operator [MAPJOIN_127] - <-Select Operator [SEL_64] (rows=500 width=10) + Please refer to the previous Map Join Operator [MAPJOIN_123] + <-Select Operator [SEL_61] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_121] (rows=500 width=10) + Filter Operator [FIL_117] (rows=500 width=10) predicate:value is not null - TableScan [TS_62] (rows=500 width=10) + TableScan [TS_59] (rows=500 width=10) Output:["value"] - File Output Operator [FS_81] + File Output Operator [FS_77] table:{"name:":"default.b"} - Please refer to the previous Select Operator [SEL_76] - File Output Operator [FS_83] + Please refer to the previous Select Operator [SEL_72] + File Output Operator [FS_79] table:{"name:":"default.c"} - Please refer to the previous Select Operator [SEL_76] + Please refer to the previous Select Operator [SEL_72] <-Map 19 [CONTAINS] llap - File Output Operator [FS_79] + File Output Operator [FS_75] table:{"name:":"default.a"} - Select Operator [SEL_76] (rows=1677 width=10) + Select Operator [SEL_72] (rows=1677 width=10) Output:["_col0","_col1"] - Map Join Operator [MAPJOIN_128] (rows=1677 width=10) - Conds:RS_135._col1=SEL_68._col0(Inner),Output:["_col0","_col3"] + Map Join Operator [MAPJOIN_124] (rows=1677 width=10) + Conds:RS_131._col1=SEL_64._col0(Inner),Output:["_col0","_col3"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_135] + BROADCAST [RS_131] PartitionCols:_col1 - Please refer to the previous Map Join Operator [MAPJOIN_127] - <-Select Operator [SEL_68] (rows=500 width=10) + Please refer to the previous Map Join Operator [MAPJOIN_123] + <-Select Operator [SEL_64] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_122] (rows=500 width=10) + Filter Operator [FIL_118] (rows=500 width=10) predicate:value is not null - TableScan [TS_66] (rows=500 width=10) + TableScan [TS_62] (rows=500 width=10) Output:["value"] - File Output Operator [FS_81] + File Output Operator [FS_77] table:{"name:":"default.b"} - Please refer to the previous Select Operator [SEL_76] - File Output Operator [FS_83] + Please refer to the previous Select Operator [SEL_72] + File Output Operator [FS_79] table:{"name:":"default.c"} - Please refer to the previous Select Operator [SEL_76] + Please refer to the previous Select Operator [SEL_72] <-Reducer 3 [CONTAINS] llap - File Output Operator [FS_79] + File Output Operator [FS_75] table:{"name:":"default.a"} Select Operator [SEL_20] (rows=634 width=10) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_124] (rows=634 width=10) + Merge Join Operator [MERGEJOIN_120] (rows=634 width=10) Conds:Union 2._col1=RS_18._col0(Inner),Output:["_col1","_col4"] <-Map 7 [SIMPLE_EDGE] llap SHUFFLE [RS_18] PartitionCols:_col0 Select Operator [SEL_13] (rows=500 width=10) Output:["_col0","_col1"] - Filter Operator [FIL_111] (rows=500 width=10) + Filter Operator [FIL_107] (rows=500 width=10) predicate:key is not null TableScan [TS_11] (rows=500 width=10) default@src,y,Tbl:COMPLETE,Col:NONE,Output:["key","value"] @@ -2768,106 +2768,106 @@ Stage-5 <-Map 1 [CONTAINS] llap Reduce Output Operator [RS_17] PartitionCols:_col1 - Map Join Operator [MAPJOIN_123] (rows=577 width=10) + Map Join Operator [MAPJOIN_119] (rows=577 width=10) Conds:SEL_2._col0=RS_15._col1(Inner),Output:["_col1"] <-Map 6 [BROADCAST_EDGE] llap BROADCAST [RS_15] PartitionCols:_col1 Select Operator [SEL_10] (rows=25 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_110] (rows=25 width=7) + Filter Operator [FIL_106] (rows=25 width=7) predicate:(key is not null and value is not null) Please refer to the previous TableScan [TS_8] <-Select Operator [SEL_2] (rows=25 width=7) Output:["_col0"] - Filter Operator [FIL_108] (rows=25 width=7) + Filter Operator [FIL_104] (rows=25 width=7) predicate:value is not null TableScan [TS_0] (rows=25 width=7) Output:["value"] <-Map 5 [CONTAINS] llap Reduce Output Operator [RS_17] PartitionCols:_col1 - Map Join Operator [MAPJOIN_123] (rows=577 width=10) - Conds:SEL_5._col0=RS_129._col1(Inner),Output:["_col1"] + Map Join Operator [MAPJOIN_119] (rows=577 width=10) + Conds:SEL_5._col0=RS_125._col1(Inner),Output:["_col1"] <-Map 6 [BROADCAST_EDGE] llap - BROADCAST [RS_129] + BROADCAST [RS_125] PartitionCols:_col1 Please refer to the previous Select Operator [SEL_10] <-Select Operator [SEL_5] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_109] (rows=500 width=10) + Filter Operator [FIL_105] (rows=500 width=10) predicate:value is not null TableScan [TS_3] (rows=500 width=10) Output:["value"] - File Output Operator [FS_81] + File Output Operator [FS_77] table:{"name:":"default.b"} Please refer to the previous Select Operator [SEL_20] - File Output Operator [FS_83] + File Output Operator [FS_79] table:{"name:":"default.c"} Please refer to the previous Select Operator [SEL_20] <-Reducer 9 [CONTAINS] llap - File Output Operator [FS_79] + File Output Operator [FS_75] table:{"name:":"default.a"} - Select Operator [SEL_45] (rows=1239 width=10) + Select Operator [SEL_44] (rows=1239 width=10) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_126] (rows=1239 width=10) - Conds:RS_42._col1=RS_43._col0(Inner),Output:["_col1","_col4"] + Merge Join Operator [MERGEJOIN_122] (rows=1239 width=10) + Conds:RS_41._col1=RS_42._col0(Inner),Output:["_col1","_col4"] <-Map 14 [SIMPLE_EDGE] llap - SHUFFLE [RS_43] + SHUFFLE [RS_42] PartitionCols:_col0 - Select Operator [SEL_38] (rows=500 width=10) + Select Operator [SEL_37] (rows=500 width=10) Output:["_col0","_col1"] - Filter Operator [FIL_116] (rows=500 width=10) + Filter Operator [FIL_112] (rows=500 width=10) predicate:key is not null - TableScan [TS_36] (rows=500 width=10) + TableScan [TS_35] (rows=500 width=10) default@src,y,Tbl:COMPLETE,Col:NONE,Output:["key","value"] <-Reducer 8 [SIMPLE_EDGE] llap - SHUFFLE [RS_42] + SHUFFLE [RS_41] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_125] (rows=1127 width=10) - Conds:Union 11._col0=RS_40._col1(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_121] (rows=1127 width=10) + Conds:Union 11._col0=RS_39._col1(Inner),Output:["_col1"] <-Map 7 [SIMPLE_EDGE] llap - SHUFFLE [RS_40] + SHUFFLE [RS_39] PartitionCols:_col1 - Select Operator [SEL_35] (rows=500 width=10) + Select Operator [SEL_34] (rows=500 width=10) Output:["_col0","_col1"] - Filter Operator [FIL_115] (rows=500 width=10) + Filter Operator [FIL_111] (rows=500 width=10) predicate:(key is not null and value is not null) Please refer to the previous TableScan [TS_11] <-Union 11 [SIMPLE_EDGE] <-Map 10 [CONTAINS] llap - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col0 Select Operator [SEL_23] (rows=25 width=7) Output:["_col0"] - Filter Operator [FIL_112] (rows=25 width=7) + Filter Operator [FIL_108] (rows=25 width=7) predicate:value is not null TableScan [TS_21] (rows=25 width=7) Output:["value"] <-Map 12 [CONTAINS] llap - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col0 Select Operator [SEL_26] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_113] (rows=500 width=10) + Filter Operator [FIL_109] (rows=500 width=10) predicate:value is not null TableScan [TS_24] (rows=500 width=10) Output:["value"] <-Map 13 [CONTAINS] llap - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col0 - Select Operator [SEL_31] (rows=500 width=10) + Select Operator [SEL_30] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_114] (rows=500 width=10) + Filter Operator [FIL_110] (rows=500 width=10) predicate:value is not null - TableScan [TS_29] (rows=500 width=10) + TableScan [TS_28] (rows=500 width=10) Output:["value"] - File Output Operator [FS_81] + File Output Operator [FS_77] table:{"name:":"default.b"} - Please refer to the previous Select Operator [SEL_45] - File Output Operator [FS_83] + Please refer to the previous Select Operator [SEL_44] + File Output Operator [FS_79] table:{"name:":"default.c"} - Please refer to the previous Select Operator [SEL_45] + Please refer to the previous Select Operator [SEL_44] Stage-6 Stats-Aggr Operator Stage-1 @@ -3438,45 +3438,45 @@ Stage-4 Dependency Collection{} Stage-2 Reducer 4 llap - File Output Operator [FS_20] + File Output Operator [FS_19] table:{"name:":"default.dest1"} - Select Operator [SEL_18] (rows=1 width=272) + Select Operator [SEL_17] (rows=1 width=272) Output:["_col0","_col1"] - Group By Operator [GBY_17] (rows=1 width=96) + Group By Operator [GBY_16] (rows=1 width=96) Output:["_col0","_col1"],aggregations:["count(DISTINCT KEY._col1:0._col0)"],keys:KEY._col0 <-Union 3 [SIMPLE_EDGE] <-Map 6 [CONTAINS] llap - Reduce Output Operator [RS_16] + Reduce Output Operator [RS_15] PartitionCols:_col0 - Group By Operator [GBY_15] (rows=1 width=280) + Group By Operator [GBY_14] (rows=1 width=280) Output:["_col0","_col1","_col2"],aggregations:["count(DISTINCT substr(_col1, 5))"],keys:_col0, substr(_col1, 5) Select Operator [SEL_8] (rows=500 width=10) Output:["_col0","_col1"] TableScan [TS_7] (rows=500 width=10) Output:["key","value"] - Reduce Output Operator [RS_23] + Reduce Output Operator [RS_22] PartitionCols:_col0, _col1 - Group By Operator [GBY_22] (rows=1 width=464) + Group By Operator [GBY_21] (rows=1 width=464) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(DISTINCT substr(_col1, 5))"],keys:_col0, _col1, substr(_col1, 5) Please refer to the previous Select Operator [SEL_8] <-Map 7 [CONTAINS] llap - Reduce Output Operator [RS_16] + Reduce Output Operator [RS_15] PartitionCols:_col0 - Group By Operator [GBY_15] (rows=1 width=280) + Group By Operator [GBY_14] (rows=1 width=280) Output:["_col0","_col1","_col2"],aggregations:["count(DISTINCT substr(_col1, 5))"],keys:_col0, substr(_col1, 5) - Select Operator [SEL_12] (rows=500 width=10) + Select Operator [SEL_11] (rows=500 width=10) Output:["_col0","_col1"] - TableScan [TS_11] (rows=500 width=10) + TableScan [TS_10] (rows=500 width=10) Output:["key","value"] - Reduce Output Operator [RS_23] + Reduce Output Operator [RS_22] PartitionCols:_col0, _col1 - Group By Operator [GBY_22] (rows=1 width=464) + Group By Operator [GBY_21] (rows=1 width=464) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(DISTINCT substr(_col1, 5))"],keys:_col0, _col1, substr(_col1, 5) - Please refer to the previous Select Operator [SEL_12] + Please refer to the previous Select Operator [SEL_11] <-Reducer 2 [CONTAINS] llap - Reduce Output Operator [RS_16] + Reduce Output Operator [RS_15] PartitionCols:_col0 - Group By Operator [GBY_15] (rows=1 width=280) + Group By Operator [GBY_14] (rows=1 width=280) Output:["_col0","_col1","_col2"],aggregations:["count(DISTINCT substr(_col1, 5))"],keys:_col0, substr(_col1, 5) Select Operator [SEL_6] (rows=1 width=272) Output:["_col0","_col1"] @@ -3489,17 +3489,17 @@ Stage-4 Select Operator [SEL_1] (rows=500 width=10) TableScan [TS_0] (rows=500 width=10) default@src,s1,Tbl:COMPLETE,Col:COMPLETE - Reduce Output Operator [RS_23] + Reduce Output Operator [RS_22] PartitionCols:_col0, _col1 - Group By Operator [GBY_22] (rows=1 width=464) + Group By Operator [GBY_21] (rows=1 width=464) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(DISTINCT substr(_col1, 5))"],keys:_col0, _col1, substr(_col1, 5) Please refer to the previous Select Operator [SEL_6] Reducer 5 llap - File Output Operator [FS_27] + File Output Operator [FS_26] table:{"name:":"default.dest2"} - Select Operator [SEL_25] (rows=1 width=456) + Select Operator [SEL_24] (rows=1 width=456) Output:["_col0","_col1","_col2"] - Group By Operator [GBY_24] (rows=1 width=280) + Group By Operator [GBY_23] (rows=1 width=280) Output:["_col0","_col1","_col2"],aggregations:["count(DISTINCT KEY._col2:0._col0)"],keys:KEY._col0, KEY._col1 <- Please refer to the previous Union 3 [SIMPLE_EDGE] Stage-5 diff --git a/ql/src/test/results/clientpositive/llap/filter_union.q.out b/ql/src/test/results/clientpositive/llap/filter_union.q.out new file mode 100644 index 0000000000..da6e6c2f7a --- /dev/null +++ b/ql/src/test/results/clientpositive/llap/filter_union.q.out @@ -0,0 +1,483 @@ +PREHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m >2 +PREHOOK: type: QUERY +POSTHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m >2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Tez +#### A masked pattern was here #### + Edges: + Reducer 2 <- Map 1 (SIMPLE_EDGE), Union 3 (CONTAINS) + Reducer 5 <- Map 4 (SIMPLE_EDGE), Union 3 (CONTAINS) + Reducer 7 <- Map 6 (SIMPLE_EDGE), Union 3 (CONTAINS) + Reducer 9 <- Map 8 (SIMPLE_EDGE), Union 3 (CONTAINS) +#### A masked pattern was here #### + Vertices: + Map 1 + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Filter Operator + predicate: false (type: boolean) + Statistics: Num rows: 1 Data size: 87 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 95 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 1 Data size: 95 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col1 (type: bigint) + Execution mode: llap + LLAP IO: no inputs + Map 4 + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Filter Operator + predicate: false (type: boolean) + Statistics: Num rows: 1 Data size: 87 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 95 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 1 Data size: 95 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col1 (type: bigint) + Execution mode: llap + LLAP IO: no inputs + Map 6 + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: key (type: string) + outputColumnNames: key + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col1 (type: bigint) + Execution mode: llap + LLAP IO: no inputs + Map 8 + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: key (type: string) + outputColumnNames: key + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col1 (type: bigint) + Execution mode: llap + LLAP IO: no inputs + Reducer 2 + Execution mode: llap + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 95 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 1 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 99 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 412 Data size: 40788 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + Reducer 5 + Execution mode: llap + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 95 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 2 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 99 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 412 Data size: 40788 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + Reducer 7 + Execution mode: llap + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 3 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 205 Data size: 20295 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 412 Data size: 40788 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + Reducer 9 + Execution mode: llap + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 4 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 205 Data size: 20295 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 412 Data size: 40788 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + Union 3 + Vertex: Union 3 + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 1 +PREHOOK: type: QUERY +POSTHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 1 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Tez +#### A masked pattern was here #### + Edges: + Reducer 2 <- Map 1 (SIMPLE_EDGE) +#### A masked pattern was here #### + Vertices: + Map 1 + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: key (type: string) + outputColumnNames: key + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col1 (type: bigint) + Execution mode: llap + LLAP IO: no inputs + Reducer 2 + Execution mode: llap + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 1 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 205 Data size: 20295 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 205 Data size: 20295 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 4 +PREHOOK: type: QUERY +POSTHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 4 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Tez +#### A masked pattern was here #### + Edges: + Reducer 2 <- Map 1 (SIMPLE_EDGE) +#### A masked pattern was here #### + Vertices: + Map 1 + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: key (type: string) + outputColumnNames: key + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col1 (type: bigint) + Execution mode: llap + LLAP IO: no inputs + Reducer 2 + Execution mode: llap + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 205 Data size: 19475 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 4 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 205 Data size: 20295 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 205 Data size: 20295 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 5 +PREHOOK: type: QUERY +POSTHOOK: query: explain +select key, c, m from +( +select key, c, 1 as m from (select key, count(key) as c from src group by key)s1 +union all +select key, c, 2 as m from (select key, count(key) as c from src group by key)s2 +union all +select key, c, 3 as m from (select key, count(key) as c from src group by key)s3 +union all +select key, c, 4 as m from (select key, count(key) as c from src group by key)s4 +)sub +where m = 5 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Tez +#### A masked pattern was here #### + Edges: + Reducer 2 <- Map 1 (SIMPLE_EDGE) +#### A masked pattern was here #### + Vertices: + Map 1 + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + Filter Operator + predicate: false (type: boolean) + Statistics: Num rows: 1 Data size: 87 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(key) + keys: key (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 95 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 1 Data size: 95 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col1 (type: bigint) + Execution mode: llap + LLAP IO: no inputs + Reducer 2 + Execution mode: llap + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 95 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: _col0 (type: string), _col1 (type: bigint), 4 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 99 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 99 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + diff --git a/ql/src/test/results/clientpositive/llap/orc_ppd_basic.q.out b/ql/src/test/results/clientpositive/llap/orc_ppd_basic.q.out index 5382c42412..cd7a392e08 100644 --- a/ql/src/test/results/clientpositive/llap/orc_ppd_basic.q.out +++ b/ql/src/test/results/clientpositive/llap/orc_ppd_basic.q.out @@ -203,6 +203,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 16673 + HDFS_BYTES_WRITTEN: 104 + HDFS_READ_OPS: 5 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -221,6 +226,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 RECORDS_OUT_0: 1 @@ -230,6 +240,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 1344 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 4 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -252,6 +267,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -272,6 +292,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -292,6 +317,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -312,6 +342,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -332,6 +367,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -352,6 +392,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -372,6 +417,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 104 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -392,6 +442,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -412,6 +467,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 104 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -432,6 +492,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -452,6 +517,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -472,6 +542,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 103 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -492,6 +567,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 RECORDS_OUT_0: 1 @@ -501,6 +581,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 RECORDS_OUT_0: 1 @@ -510,6 +595,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -525,6 +615,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -540,6 +635,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 RECORDS_OUT_0: 1 @@ -549,6 +649,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 6786 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 4 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -572,6 +677,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -592,6 +702,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -612,6 +727,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 RECORDS_OUT_0: 1 @@ -621,6 +741,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 104 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -641,6 +766,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -656,6 +786,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -676,6 +811,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -696,6 +836,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -716,6 +861,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -736,6 +886,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -756,6 +911,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -776,6 +936,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 102 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -796,6 +961,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -816,6 +986,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -836,6 +1011,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -851,6 +1031,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -866,6 +1051,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -881,6 +1071,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -901,6 +1096,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -921,6 +1121,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -941,6 +1146,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -961,6 +1171,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 7718 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 4 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -984,6 +1199,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -1004,6 +1224,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 @@ -1024,6 +1249,11 @@ PREHOOK: type: QUERY PREHOOK: Input: default@orc_ppd #### A masked pattern was here #### Stage-1 FILE SYSTEM COUNTERS: + HDFS_BYTES_READ: 0 + HDFS_BYTES_WRITTEN: 101 + HDFS_READ_OPS: 2 + HDFS_LARGE_READ_OPS: 0 + HDFS_WRITE_OPS: 2 Stage-1 HIVE COUNTERS: CREATED_FILES: 1 DESERIALIZE_ERRORS: 0 diff --git a/ql/src/test/results/clientpositive/llap/tez_union_multiinsert.q.out b/ql/src/test/results/clientpositive/llap/tez_union_multiinsert.q.out index 14e8e4389f..07640a7f67 100644 --- a/ql/src/test/results/clientpositive/llap/tez_union_multiinsert.q.out +++ b/ql/src/test/results/clientpositive/llap/tez_union_multiinsert.q.out @@ -1187,11 +1187,11 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@src POSTHOOK: Output: default@dest1 POSTHOOK: Output: default@dest2 -POSTHOOK: Lineage: dest1.key EXPRESSION [(src)s2.FieldSchema(name:key, type:string, comment:default), (src)s0.FieldSchema(name:key, type:string, comment:default), ] -POSTHOOK: Lineage: dest1.value EXPRESSION [(src)s2.FieldSchema(name:value, type:string, comment:default), (src)s0.FieldSchema(name:value, type:string, comment:default), ] -POSTHOOK: Lineage: dest2.key EXPRESSION [(src)s2.FieldSchema(name:key, type:string, comment:default), (src)s0.FieldSchema(name:key, type:string, comment:default), ] -POSTHOOK: Lineage: dest2.val1 EXPRESSION [(src)s2.FieldSchema(name:value, type:string, comment:default), (src)s0.FieldSchema(name:value, type:string, comment:default), ] -POSTHOOK: Lineage: dest2.val2 EXPRESSION [(src)s2.FieldSchema(name:value, type:string, comment:default), (src)s0.FieldSchema(name:value, type:string, comment:default), ] +POSTHOOK: Lineage: dest1.key EXPRESSION [(src)s0.FieldSchema(name:key, type:string, comment:default), (src)s2.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: dest1.value EXPRESSION [(src)s0.FieldSchema(name:value, type:string, comment:default), (src)s2.FieldSchema(name:value, type:string, comment:default), ] +POSTHOOK: Lineage: dest2.key EXPRESSION [(src)s0.FieldSchema(name:key, type:string, comment:default), (src)s2.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: dest2.val1 EXPRESSION [(src)s0.FieldSchema(name:value, type:string, comment:default), (src)s2.FieldSchema(name:value, type:string, comment:default), ] +POSTHOOK: Lineage: dest2.val2 EXPRESSION [(src)s0.FieldSchema(name:value, type:string, comment:default), (src)s2.FieldSchema(name:value, type:string, comment:default), ] PREHOOK: query: select * from DEST1 PREHOOK: type: QUERY PREHOOK: Input: default@dest1 diff --git a/ql/src/test/results/clientpositive/perf/query11.q.out b/ql/src/test/results/clientpositive/perf/query11.q.out new file mode 100644 index 0000000000..cce6350f2c --- /dev/null +++ b/ql/src/test/results/clientpositive/perf/query11.q.out @@ -0,0 +1,375 @@ +PREHOOK: query: explain +with year_total as ( + select c_customer_id customer_id + ,c_first_name customer_first_name + ,c_last_name customer_last_name + ,c_preferred_cust_flag + ,c_birth_country customer_birth_country + ,c_login customer_login + ,c_email_address customer_email_address + ,d_year dyear + ,sum(ss_ext_list_price-ss_ext_discount_amt) year_total + ,'s' sale_type + from customer + ,store_sales + ,date_dim + where c_customer_sk = ss_customer_sk + and ss_sold_date_sk = d_date_sk + group by c_customer_id + ,c_first_name + ,c_last_name + ,d_year + ,c_preferred_cust_flag + ,c_birth_country + ,c_login + ,c_email_address + ,d_year + union all + select c_customer_id customer_id + ,c_first_name customer_first_name + ,c_last_name customer_last_name + ,c_preferred_cust_flag + ,c_birth_country customer_birth_country + ,c_login customer_login + ,c_email_address customer_email_address + ,d_year dyear + ,sum(ws_ext_list_price-ws_ext_discount_amt) year_total + ,'w' sale_type + from customer + ,web_sales + ,date_dim + where c_customer_sk = ws_bill_customer_sk + and ws_sold_date_sk = d_date_sk + group by c_customer_id + ,c_first_name + ,c_last_name + ,c_preferred_cust_flag + ,c_birth_country + ,c_login + ,c_email_address + ,d_year + ) + select t_s_secyear.c_preferred_cust_flag + from year_total t_s_firstyear + ,year_total t_s_secyear + ,year_total t_w_firstyear + ,year_total t_w_secyear + where t_s_secyear.customer_id = t_s_firstyear.customer_id + and t_s_firstyear.customer_id = t_w_secyear.customer_id + and t_s_firstyear.customer_id = t_w_firstyear.customer_id + and t_s_firstyear.sale_type = 's' + and t_w_firstyear.sale_type = 'w' + and t_s_secyear.sale_type = 's' + and t_w_secyear.sale_type = 'w' + and t_s_firstyear.dyear = 2001 + and t_s_secyear.dyear = 2001+1 + and t_w_firstyear.dyear = 2001 + and t_w_secyear.dyear = 2001+1 + and t_s_firstyear.year_total > 0 + and t_w_firstyear.year_total > 0 + and case when t_w_firstyear.year_total > 0 then t_w_secyear.year_total / t_w_firstyear.year_total else null end + > case when t_s_firstyear.year_total > 0 then t_s_secyear.year_total / t_s_firstyear.year_total else null end + order by t_s_secyear.c_preferred_cust_flag +limit 100 +PREHOOK: type: QUERY +POSTHOOK: query: explain +with year_total as ( + select c_customer_id customer_id + ,c_first_name customer_first_name + ,c_last_name customer_last_name + ,c_preferred_cust_flag + ,c_birth_country customer_birth_country + ,c_login customer_login + ,c_email_address customer_email_address + ,d_year dyear + ,sum(ss_ext_list_price-ss_ext_discount_amt) year_total + ,'s' sale_type + from customer + ,store_sales + ,date_dim + where c_customer_sk = ss_customer_sk + and ss_sold_date_sk = d_date_sk + group by c_customer_id + ,c_first_name + ,c_last_name + ,d_year + ,c_preferred_cust_flag + ,c_birth_country + ,c_login + ,c_email_address + ,d_year + union all + select c_customer_id customer_id + ,c_first_name customer_first_name + ,c_last_name customer_last_name + ,c_preferred_cust_flag + ,c_birth_country customer_birth_country + ,c_login customer_login + ,c_email_address customer_email_address + ,d_year dyear + ,sum(ws_ext_list_price-ws_ext_discount_amt) year_total + ,'w' sale_type + from customer + ,web_sales + ,date_dim + where c_customer_sk = ws_bill_customer_sk + and ws_sold_date_sk = d_date_sk + group by c_customer_id + ,c_first_name + ,c_last_name + ,c_preferred_cust_flag + ,c_birth_country + ,c_login + ,c_email_address + ,d_year + ) + select t_s_secyear.c_preferred_cust_flag + from year_total t_s_firstyear + ,year_total t_s_secyear + ,year_total t_w_firstyear + ,year_total t_w_secyear + where t_s_secyear.customer_id = t_s_firstyear.customer_id + and t_s_firstyear.customer_id = t_w_secyear.customer_id + and t_s_firstyear.customer_id = t_w_firstyear.customer_id + and t_s_firstyear.sale_type = 's' + and t_w_firstyear.sale_type = 'w' + and t_s_secyear.sale_type = 's' + and t_w_secyear.sale_type = 'w' + and t_s_firstyear.dyear = 2001 + and t_s_secyear.dyear = 2001+1 + and t_w_firstyear.dyear = 2001 + and t_w_secyear.dyear = 2001+1 + and t_s_firstyear.year_total > 0 + and t_w_firstyear.year_total > 0 + and case when t_w_firstyear.year_total > 0 then t_w_secyear.year_total / t_w_firstyear.year_total else null end + > case when t_s_firstyear.year_total > 0 then t_s_secyear.year_total / t_s_firstyear.year_total else null end + order by t_s_secyear.c_preferred_cust_flag +limit 100 +POSTHOOK: type: QUERY +Plan optimized by CBO. + +Vertex dependency in root stage +Reducer 11 <- Map 10 (SIMPLE_EDGE), Map 18 (SIMPLE_EDGE) +Reducer 12 <- Map 17 (SIMPLE_EDGE), Reducer 11 (SIMPLE_EDGE) +Reducer 13 <- Reducer 12 (SIMPLE_EDGE) +Reducer 14 <- Map 10 (SIMPLE_EDGE), Map 18 (SIMPLE_EDGE) +Reducer 15 <- Map 17 (SIMPLE_EDGE), Reducer 14 (SIMPLE_EDGE) +Reducer 16 <- Reducer 15 (SIMPLE_EDGE) +Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE) +Reducer 3 <- Map 17 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE) +Reducer 4 <- Reducer 3 (SIMPLE_EDGE) +Reducer 5 <- Reducer 13 (SIMPLE_EDGE), Reducer 16 (SIMPLE_EDGE), Reducer 4 (SIMPLE_EDGE), Reducer 9 (SIMPLE_EDGE) +Reducer 6 <- Reducer 5 (SIMPLE_EDGE) +Reducer 7 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE) +Reducer 8 <- Map 17 (SIMPLE_EDGE), Reducer 7 (SIMPLE_EDGE) +Reducer 9 <- Reducer 8 (SIMPLE_EDGE) + +Stage-0 + Fetch Operator + limit:100 + Stage-1 + Reducer 6 + File Output Operator [FS_96] + Limit [LIM_95] (rows=100 width=88) + Number of rows:100 + Select Operator [SEL_94] (rows=574987679 width=88) + Output:["_col0"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_93] + Select Operator [SEL_92] (rows=574987679 width=88) + Output:["_col0"] + Filter Operator [FIL_91] (rows=574987679 width=88) + predicate:CASE WHEN ((_col14 > 0)) THEN (CASE WHEN ((_col22 > 0)) THEN (((_col7 / _col22) > (_col30 / _col14))) ELSE ((null > (_col30 / _col14))) END) ELSE (CASE WHEN ((_col22 > 0)) THEN (((_col7 / _col22) > null)) ELSE (null) END) END + Merge Join Operator [MERGEJOIN_175] (rows=1149975359 width=88) + Conds:RS_86._col0=RS_87._col0(Inner),RS_87._col0=RS_88._col0(Inner),RS_87._col0=RS_89._col0(Inner),Output:["_col7","_col14","_col22","_col26","_col30"] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_87] + PartitionCols:_col0 + Select Operator [SEL_42] (rows=116159124 width=88) + Output:["_col0","_col6"] + Filter Operator [FIL_41] (rows=116159124 width=88) + predicate:(_col7 > 0) + Select Operator [SEL_166] (rows=348477374 width=88) + Output:["_col0","_col7"] + Group By Operator [GBY_40] (rows=348477374 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_39] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_38] (rows=696954748 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Select Operator [SEL_36] (rows=696954748 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_170] (rows=696954748 width=88) + Conds:RS_33._col1=RS_34._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + <-Map 17 [SIMPLE_EDGE] + SHUFFLE [RS_34] + PartitionCols:_col0 + Select Operator [SEL_29] (rows=80000000 width=860) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_158] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) + TableScan [TS_6] (rows=80000000 width=860) + default@customer,customer,Tbl:COMPLETE,Col:NONE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_169] (rows=633595212 width=88) + Conds:RS_30._col0=RS_31._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_31] + PartitionCols:_col0 + Select Operator [SEL_26] (rows=36524 width=1119) + Output:["_col0"] + Filter Operator [FIL_157] (rows=36524 width=1119) + predicate:((d_year = 2001) and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=1119) + default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year"] + <-Map 18 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col0 + Select Operator [SEL_23] (rows=575995635 width=88) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_156] (rows=575995635 width=88) + predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) + TableScan [TS_21] (rows=575995635 width=88) + default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_list_price"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_89] + PartitionCols:_col0 + Select Operator [SEL_85] (rows=348477374 width=88) + Output:["_col0","_col3","_col7"] + Group By Operator [GBY_84] (rows=348477374 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_83] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_82] (rows=696954748 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Select Operator [SEL_80] (rows=696954748 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_174] (rows=696954748 width=88) + Conds:RS_77._col1=RS_78._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + <-Map 17 [SIMPLE_EDGE] + SHUFFLE [RS_78] + PartitionCols:_col0 + Select Operator [SEL_73] (rows=80000000 width=860) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_164] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_77] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_173] (rows=633595212 width=88) + Conds:RS_74._col0=RS_75._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_75] + PartitionCols:_col0 + Select Operator [SEL_70] (rows=36524 width=1119) + Output:["_col0"] + Filter Operator [FIL_163] (rows=36524 width=1119) + predicate:((d_year = 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 18 [SIMPLE_EDGE] + SHUFFLE [RS_74] + PartitionCols:_col0 + Select Operator [SEL_67] (rows=575995635 width=88) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_162] (rows=575995635 width=88) + predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) + Please refer to the previous TableScan [TS_21] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_86] + PartitionCols:_col0 + Select Operator [SEL_20] (rows=87121617 width=135) + Output:["_col0","_col7"] + Group By Operator [GBY_19] (rows=87121617 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_17] (rows=174243235 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Select Operator [SEL_15] (rows=174243235 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_168] (rows=174243235 width=135) + Conds:RS_12._col1=RS_13._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + <-Map 17 [SIMPLE_EDGE] + SHUFFLE [RS_13] + PartitionCols:_col0 + Select Operator [SEL_8] (rows=80000000 width=860) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_155] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_167] (rows=158402938 width=135) + Conds:RS_9._col0=RS_10._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_10] + PartitionCols:_col0 + Select Operator [SEL_5] (rows=36524 width=1119) + Output:["_col0"] + Filter Operator [FIL_154] (rows=36524 width=1119) + predicate:((d_year = 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 1 [SIMPLE_EDGE] + SHUFFLE [RS_9] + PartitionCols:_col0 + Select Operator [SEL_2] (rows=144002668 width=135) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_153] (rows=144002668 width=135) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) + TableScan [TS_0] (rows=144002668 width=135) + default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_list_price"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_88] + PartitionCols:_col0 + Filter Operator [FIL_63] (rows=29040539 width=135) + predicate:(_col7 > 0) + Select Operator [SEL_165] (rows=87121617 width=135) + Output:["_col0","_col7"] + Group By Operator [GBY_62] (rows=87121617 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_61] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_60] (rows=174243235 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Select Operator [SEL_58] (rows=174243235 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_172] (rows=174243235 width=135) + Conds:RS_55._col1=RS_56._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + <-Map 17 [SIMPLE_EDGE] + SHUFFLE [RS_56] + PartitionCols:_col0 + Select Operator [SEL_51] (rows=80000000 width=860) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_161] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_55] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_171] (rows=158402938 width=135) + Conds:RS_52._col0=RS_53._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_53] + PartitionCols:_col0 + Select Operator [SEL_48] (rows=36524 width=1119) + Output:["_col0"] + Filter Operator [FIL_160] (rows=36524 width=1119) + predicate:((d_year = 2001) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 1 [SIMPLE_EDGE] + SHUFFLE [RS_52] + PartitionCols:_col0 + Select Operator [SEL_45] (rows=144002668 width=135) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_159] (rows=144002668 width=135) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) + Please refer to the previous TableScan [TS_0] + diff --git a/ql/src/test/results/clientpositive/perf/query14.q.out b/ql/src/test/results/clientpositive/perf/query14.q.out index 048a17f92f..64c5921436 100644 --- a/ql/src/test/results/clientpositive/perf/query14.q.out +++ b/ql/src/test/results/clientpositive/perf/query14.q.out @@ -1,6 +1,6 @@ -Warning: Shuffle Join MERGEJOIN[906][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 5' is a cross product -Warning: Shuffle Join MERGEJOIN[908][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 16' is a cross product -Warning: Shuffle Join MERGEJOIN[907][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 12' is a cross product +Warning: Shuffle Join MERGEJOIN[900][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 12' is a cross product +Warning: Shuffle Join MERGEJOIN[901][tables = [$hdt$_2, $hdt$_3, $hdt$_1]] in Stage 'Reducer 16' is a cross product +Warning: Shuffle Join MERGEJOIN[899][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 5' is a cross product PREHOOK: query: explain with cross_items as (select i_item_sk ss_item_sk @@ -290,1143 +290,1143 @@ Stage-0 limit:100 Stage-1 Reducer 8 - File Output Operator [FS_590] - Limit [LIM_589] (rows=100 width=405) + File Output Operator [FS_583] + Limit [LIM_582] (rows=100 width=405) Number of rows:100 - Select Operator [SEL_588] (rows=1016388080 width=405) + Select Operator [SEL_581] (rows=1016388080 width=405) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_587] - Select Operator [SEL_586] (rows=1016388080 width=405) + SHUFFLE [RS_580] + Select Operator [SEL_579] (rows=1016388080 width=405) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Group By Operator [GBY_585] (rows=1016388080 width=405) + Group By Operator [GBY_578] (rows=1016388080 width=405) Output:["_col0","_col1","_col2","_col3","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 6 [SIMPLE_EDGE] <-Reducer 12 [CONTAINS] - Reduce Output Operator [RS_584] + Reduce Output Operator [RS_577] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_583] (rows=2032776160 width=405) + Group By Operator [GBY_576] (rows=2032776160 width=405) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0 - Select Operator [SEL_385] (rows=116155905 width=432) + Select Operator [SEL_381] (rows=116155905 width=432) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_384] (rows=116155905 width=432) + Filter Operator [FIL_380] (rows=116155905 width=432) predicate:(_col5 > _col1) - Merge Join Operator [MERGEJOIN_907] (rows=348467716 width=432) + Merge Join Operator [MERGEJOIN_900] (rows=348467716 width=432) Conds:(Inner),(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 11 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_380] - Select Operator [SEL_237] (rows=1 width=8) - Filter Operator [FIL_236] (rows=1 width=8) + PARTITION_ONLY_SHUFFLE [RS_376] + Select Operator [SEL_234] (rows=1 width=8) + Filter Operator [FIL_233] (rows=1 width=8) predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_234] (rows=1 width=8) + Group By Operator [GBY_231] (rows=1 width=8) Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_229] (rows=1 width=8) - Group By Operator [GBY_228] (rows=1 width=8) + Select Operator [SEL_226] (rows=1 width=8) + Group By Operator [GBY_225] (rows=1 width=8) Output:["_col0"],aggregations:["count(VALUE._col0)"] <-Union 10 [CUSTOM_SIMPLE_EDGE] <-Reducer 74 [CONTAINS] - Reduce Output Operator [RS_227] - Group By Operator [GBY_226] (rows=1 width=8) + Reduce Output Operator [RS_224] + Group By Operator [GBY_223] (rows=1 width=8) Output:["_col0"],aggregations:["count(_col0)"] - Select Operator [SEL_225] (rows=1108786976 width=108) + Select Operator [SEL_222] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_212] (rows=316788826 width=135) + Select Operator [SEL_210] (rows=316788826 width=135) Output:["_col0"] - Merge Join Operator [MERGEJOIN_877] (rows=316788826 width=135) - Conds:RS_209._col0=RS_210._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_870] (rows=316788826 width=135) + Conds:RS_207._col0=RS_208._col0(Inner),Output:["_col1"] <-Map 76 [SIMPLE_EDGE] - SHUFFLE [RS_210] + SHUFFLE [RS_208] PartitionCols:_col0 - Select Operator [SEL_208] (rows=8116 width=1119) + Select Operator [SEL_206] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_814] (rows=8116 width=1119) + Filter Operator [FIL_807] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) TableScan [TS_13] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year"] <-Map 72 [SIMPLE_EDGE] - SHUFFLE [RS_209] + SHUFFLE [RS_207] PartitionCols:_col0 - Select Operator [SEL_205] (rows=287989836 width=135) + Select Operator [SEL_203] (rows=287989836 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_813] (rows=287989836 width=135) + Filter Operator [FIL_806] (rows=287989836 width=135) predicate:cs_sold_date_sk is not null TableScan [TS_10] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_quantity"] <-Reducer 82 [CONTAINS] - Reduce Output Operator [RS_227] - Group By Operator [GBY_226] (rows=1 width=8) + Reduce Output Operator [RS_224] + Group By Operator [GBY_223] (rows=1 width=8) Output:["_col0"],aggregations:["count(_col0)"] - Select Operator [SEL_225] (rows=1108786976 width=108) + Select Operator [SEL_222] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_224] (rows=158402938 width=135) + Select Operator [SEL_221] (rows=158402938 width=135) Output:["_col0"] - Merge Join Operator [MERGEJOIN_878] (rows=158402938 width=135) - Conds:RS_221._col0=RS_222._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_871] (rows=158402938 width=135) + Conds:RS_218._col0=RS_219._col0(Inner),Output:["_col1"] <-Map 84 [SIMPLE_EDGE] - SHUFFLE [RS_222] + SHUFFLE [RS_219] PartitionCols:_col0 - Select Operator [SEL_220] (rows=8116 width=1119) + Select Operator [SEL_217] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_816] (rows=8116 width=1119) + Filter Operator [FIL_809] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) - TableScan [TS_25] (rows=73049 width=1119) + TableScan [TS_24] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year"] <-Map 80 [SIMPLE_EDGE] - SHUFFLE [RS_221] + SHUFFLE [RS_218] PartitionCols:_col0 - Select Operator [SEL_217] (rows=144002668 width=135) + Select Operator [SEL_214] (rows=144002668 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_815] (rows=144002668 width=135) + Filter Operator [FIL_808] (rows=144002668 width=135) predicate:ws_sold_date_sk is not null - TableScan [TS_22] (rows=144002668 width=135) + TableScan [TS_21] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_quantity"] <-Reducer 9 [CONTAINS] - Reduce Output Operator [RS_227] - Group By Operator [GBY_226] (rows=1 width=8) + Reduce Output Operator [RS_224] + Group By Operator [GBY_223] (rows=1 width=8) Output:["_col0"],aggregations:["count(_col0)"] - Select Operator [SEL_225] (rows=1108786976 width=108) + Select Operator [SEL_222] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_202] (rows=633595212 width=88) + Select Operator [SEL_200] (rows=633595212 width=88) Output:["_col0"] - Merge Join Operator [MERGEJOIN_876] (rows=633595212 width=88) - Conds:RS_199._col0=RS_200._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_869] (rows=633595212 width=88) + Conds:RS_197._col0=RS_198._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_200] + SHUFFLE [RS_198] PartitionCols:_col0 - Select Operator [SEL_198] (rows=8116 width=1119) + Select Operator [SEL_196] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_812] (rows=8116 width=1119) + Filter Operator [FIL_805] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year"] <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_199] + SHUFFLE [RS_197] PartitionCols:_col0 - Select Operator [SEL_195] (rows=575995635 width=88) + Select Operator [SEL_193] (rows=575995635 width=88) Output:["_col0","_col1"] - Filter Operator [FIL_811] (rows=575995635 width=88) + Filter Operator [FIL_804] (rows=575995635 width=88) predicate:ss_sold_date_sk is not null TableScan [TS_0] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_quantity"] <-Reducer 38 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_381] - Group By Operator [GBY_274] (rows=1 width=288) + PARTITION_ONLY_SHUFFLE [RS_377] + Group By Operator [GBY_270] (rows=1 width=288) Output:["_col0"],aggregations:["avg(VALUE._col0)"] <-Union 37 [CUSTOM_SIMPLE_EDGE] <-Reducer 36 [CONTAINS] - Reduce Output Operator [RS_273] - Group By Operator [GBY_272] (rows=1 width=288) + Reduce Output Operator [RS_269] + Group By Operator [GBY_268] (rows=1 width=288) Output:["_col0"],aggregations:["avg(_col0)"] - Select Operator [SEL_270] (rows=1108786976 width=108) + Select Operator [SEL_266] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_247] (rows=633595212 width=88) + Select Operator [SEL_244] (rows=633595212 width=88) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_879] (rows=633595212 width=88) - Conds:RS_244._col0=RS_245._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_872] (rows=633595212 width=88) + Conds:RS_241._col0=RS_242._col0(Inner),Output:["_col1","_col2"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_245] + SHUFFLE [RS_242] PartitionCols:_col0 - Select Operator [SEL_243] (rows=8116 width=1119) + Select Operator [SEL_240] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_818] (rows=8116 width=1119) + Filter Operator [FIL_811] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 88 [SIMPLE_EDGE] - SHUFFLE [RS_244] + SHUFFLE [RS_241] PartitionCols:_col0 - Select Operator [SEL_240] (rows=575995635 width=88) + Select Operator [SEL_237] (rows=575995635 width=88) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_817] (rows=575995635 width=88) + Filter Operator [FIL_810] (rows=575995635 width=88) predicate:ss_sold_date_sk is not null - TableScan [TS_45] (rows=575995635 width=88) + TableScan [TS_44] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_quantity","ss_list_price"] <-Reducer 78 [CONTAINS] - Reduce Output Operator [RS_273] - Group By Operator [GBY_272] (rows=1 width=288) + Reduce Output Operator [RS_269] + Group By Operator [GBY_268] (rows=1 width=288) Output:["_col0"],aggregations:["avg(_col0)"] - Select Operator [SEL_270] (rows=1108786976 width=108) + Select Operator [SEL_266] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_257] (rows=316788826 width=135) + Select Operator [SEL_254] (rows=316788826 width=135) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_880] (rows=316788826 width=135) - Conds:RS_254._col0=RS_255._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_873] (rows=316788826 width=135) + Conds:RS_251._col0=RS_252._col0(Inner),Output:["_col1","_col2"] <-Map 76 [SIMPLE_EDGE] - SHUFFLE [RS_255] + SHUFFLE [RS_252] PartitionCols:_col0 - Select Operator [SEL_253] (rows=8116 width=1119) + Select Operator [SEL_250] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_820] (rows=8116 width=1119) + Filter Operator [FIL_813] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 89 [SIMPLE_EDGE] - SHUFFLE [RS_254] + SHUFFLE [RS_251] PartitionCols:_col0 - Select Operator [SEL_250] (rows=287989836 width=135) + Select Operator [SEL_247] (rows=287989836 width=135) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_819] (rows=287989836 width=135) + Filter Operator [FIL_812] (rows=287989836 width=135) predicate:cs_sold_date_sk is not null - TableScan [TS_55] (rows=287989836 width=135) + TableScan [TS_54] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_quantity","cs_list_price"] <-Reducer 86 [CONTAINS] - Reduce Output Operator [RS_273] - Group By Operator [GBY_272] (rows=1 width=288) + Reduce Output Operator [RS_269] + Group By Operator [GBY_268] (rows=1 width=288) Output:["_col0"],aggregations:["avg(_col0)"] - Select Operator [SEL_270] (rows=1108786976 width=108) + Select Operator [SEL_266] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_269] (rows=158402938 width=135) + Select Operator [SEL_265] (rows=158402938 width=135) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_881] (rows=158402938 width=135) - Conds:RS_266._col0=RS_267._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_874] (rows=158402938 width=135) + Conds:RS_262._col0=RS_263._col0(Inner),Output:["_col1","_col2"] <-Map 84 [SIMPLE_EDGE] - SHUFFLE [RS_267] + SHUFFLE [RS_263] PartitionCols:_col0 - Select Operator [SEL_265] (rows=8116 width=1119) + Select Operator [SEL_261] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_822] (rows=8116 width=1119) + Filter Operator [FIL_815] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) - Please refer to the previous TableScan [TS_25] + Please refer to the previous TableScan [TS_24] <-Map 90 [SIMPLE_EDGE] - SHUFFLE [RS_266] + SHUFFLE [RS_262] PartitionCols:_col0 - Select Operator [SEL_262] (rows=144002668 width=135) + Select Operator [SEL_258] (rows=144002668 width=135) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_821] (rows=144002668 width=135) + Filter Operator [FIL_814] (rows=144002668 width=135) predicate:ws_sold_date_sk is not null - TableScan [TS_67] (rows=144002668 width=135) + TableScan [TS_65] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_quantity","ws_list_price"] <-Reducer 47 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_382] - Group By Operator [GBY_378] (rows=348467716 width=135) + PARTITION_ONLY_SHUFFLE [RS_378] + Group By Operator [GBY_374] (rows=348467716 width=135) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 46 [SIMPLE_EDGE] - SHUFFLE [RS_377] + SHUFFLE [RS_373] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_376] (rows=696935432 width=135) + Group By Operator [GBY_372] (rows=696935432 width=135) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0, _col1, _col2 - Select Operator [SEL_374] (rows=696935432 width=135) + Select Operator [SEL_370] (rows=696935432 width=135) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_890] (rows=696935432 width=135) - Conds:RS_370._col1=RS_371._col0(Inner),RS_370._col1=RS_372._col0(Inner),Output:["_col2","_col3","_col8","_col9","_col10"] + Merge Join Operator [MERGEJOIN_883] (rows=696935432 width=135) + Conds:RS_366._col1=RS_367._col0(Inner),RS_366._col1=RS_368._col0(Inner),Output:["_col2","_col3","_col8","_col9","_col10"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_371] + SHUFFLE [RS_367] PartitionCols:_col0 - Select Operator [SEL_284] (rows=462000 width=1436) + Select Operator [SEL_280] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_825] (rows=462000 width=1436) + Filter Operator [FIL_818] (rows=462000 width=1436) predicate:i_item_sk is not null - TableScan [TS_89] (rows=462000 width=1436) + TableScan [TS_87] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_sk","i_brand_id","i_class_id","i_category_id"] <-Reducer 45 [SIMPLE_EDGE] - SHUFFLE [RS_372] + SHUFFLE [RS_368] PartitionCols:_col0 - Group By Operator [GBY_365] (rows=254100 width=1436) + Group By Operator [GBY_361] (rows=254100 width=1436) Output:["_col0"],keys:KEY._col0 <-Reducer 44 [SIMPLE_EDGE] - SHUFFLE [RS_364] + SHUFFLE [RS_360] PartitionCols:_col0 - Group By Operator [GBY_363] (rows=508200 width=1436) + Group By Operator [GBY_359] (rows=508200 width=1436) Output:["_col0"],keys:_col0 - Merge Join Operator [MERGEJOIN_889] (rows=508200 width=1436) - Conds:RS_359._col1, _col2, _col3=RS_360._col0, _col1, _col2(Inner),Output:["_col0"] + Merge Join Operator [MERGEJOIN_882] (rows=508200 width=1436) + Conds:RS_355._col1, _col2, _col3=RS_356._col0, _col1, _col2(Inner),Output:["_col0"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_359] + SHUFFLE [RS_355] PartitionCols:_col1, _col2, _col3 - Select Operator [SEL_287] (rows=462000 width=1436) + Select Operator [SEL_283] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_826] (rows=462000 width=1436) + Filter Operator [FIL_819] (rows=462000 width=1436) predicate:(i_brand_id is not null and i_class_id is not null and i_category_id is not null and i_item_sk is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 43 [SIMPLE_EDGE] - SHUFFLE [RS_360] + SHUFFLE [RS_356] PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_358] (rows=1 width=108) + Select Operator [SEL_354] (rows=1 width=108) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_357] (rows=1 width=108) + Filter Operator [FIL_353] (rows=1 width=108) predicate:(_col3 = 3) - Group By Operator [GBY_356] (rows=304916424 width=108) + Group By Operator [GBY_352] (rows=304916424 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 42 [SIMPLE_EDGE] <-Reducer 41 [CONTAINS] - Reduce Output Operator [RS_355] + Reduce Output Operator [RS_351] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_354] (rows=609832849 width=108) + Group By Operator [GBY_350] (rows=609832849 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_307] (rows=348477374 width=88) + Group By Operator [GBY_303] (rows=348477374 width=88) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 40 [SIMPLE_EDGE] - SHUFFLE [RS_306] + SHUFFLE [RS_302] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_305] (rows=696954748 width=88) + Group By Operator [GBY_301] (rows=696954748 width=88) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(1)"],keys:_col0, _col1, _col2 - Select Operator [SEL_303] (rows=696954748 width=88) + Select Operator [SEL_299] (rows=696954748 width=88) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_884] (rows=696954748 width=88) - Conds:RS_300._col1=RS_301._col0(Inner),Output:["_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_877] (rows=696954748 width=88) + Conds:RS_296._col1=RS_297._col0(Inner),Output:["_col5","_col6","_col7"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_301] + SHUFFLE [RS_297] PartitionCols:_col0 - Select Operator [SEL_296] (rows=462000 width=1436) + Select Operator [SEL_292] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_829] (rows=462000 width=1436) + Filter Operator [FIL_822] (rows=462000 width=1436) predicate:(i_item_sk is not null and i_brand_id is not null and i_class_id is not null and i_category_id is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 39 [SIMPLE_EDGE] - SHUFFLE [RS_300] + SHUFFLE [RS_296] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_883] (rows=633595212 width=88) - Conds:RS_297._col0=RS_298._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_876] (rows=633595212 width=88) + Conds:RS_293._col0=RS_294._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_298] + SHUFFLE [RS_294] PartitionCols:_col0 - Select Operator [SEL_293] (rows=8116 width=1119) + Select Operator [SEL_289] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_828] (rows=8116 width=1119) + Filter Operator [FIL_821] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 97 [SIMPLE_EDGE] - SHUFFLE [RS_297] + SHUFFLE [RS_293] PartitionCols:_col0 - Select Operator [SEL_290] (rows=575995635 width=88) + Select Operator [SEL_286] (rows=575995635 width=88) Output:["_col0","_col1"] - Filter Operator [FIL_827] (rows=575995635 width=88) + Filter Operator [FIL_820] (rows=575995635 width=88) predicate:(ss_item_sk is not null and ss_sold_date_sk is not null) - TableScan [TS_95] (rows=575995635 width=88) + TableScan [TS_93] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_item_sk"] <-Reducer 50 [CONTAINS] - Reduce Output Operator [RS_355] + Reduce Output Operator [RS_351] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_354] (rows=609832849 width=108) + Group By Operator [GBY_350] (rows=609832849 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_328] (rows=174233858 width=135) + Group By Operator [GBY_324] (rows=174233858 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 49 [SIMPLE_EDGE] - SHUFFLE [RS_327] + SHUFFLE [RS_323] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_326] (rows=348467716 width=135) + Group By Operator [GBY_322] (rows=348467716 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(1)"],keys:_col0, _col1, _col2 - Select Operator [SEL_324] (rows=348467716 width=135) + Select Operator [SEL_320] (rows=348467716 width=135) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_886] (rows=348467716 width=135) - Conds:RS_321._col1=RS_322._col0(Inner),Output:["_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_879] (rows=348467716 width=135) + Conds:RS_317._col1=RS_318._col0(Inner),Output:["_col5","_col6","_col7"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_322] + SHUFFLE [RS_318] PartitionCols:_col0 - Select Operator [SEL_317] (rows=462000 width=1436) + Select Operator [SEL_313] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_832] (rows=462000 width=1436) + Filter Operator [FIL_825] (rows=462000 width=1436) predicate:(i_item_sk is not null and i_brand_id is not null and i_class_id is not null and i_category_id is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 48 [SIMPLE_EDGE] - SHUFFLE [RS_321] + SHUFFLE [RS_317] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_885] (rows=316788826 width=135) - Conds:RS_318._col0=RS_319._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_878] (rows=316788826 width=135) + Conds:RS_314._col0=RS_315._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_319] + SHUFFLE [RS_315] PartitionCols:_col0 - Select Operator [SEL_314] (rows=8116 width=1119) + Select Operator [SEL_310] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_831] (rows=8116 width=1119) + Filter Operator [FIL_824] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 98 [SIMPLE_EDGE] - SHUFFLE [RS_318] + SHUFFLE [RS_314] PartitionCols:_col0 - Select Operator [SEL_311] (rows=287989836 width=135) + Select Operator [SEL_307] (rows=287989836 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_830] (rows=287989836 width=135) + Filter Operator [FIL_823] (rows=287989836 width=135) predicate:(cs_item_sk is not null and cs_sold_date_sk is not null) - TableScan [TS_116] (rows=287989836 width=135) + TableScan [TS_114] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_item_sk"] <-Reducer 53 [CONTAINS] - Reduce Output Operator [RS_355] + Reduce Output Operator [RS_351] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_354] (rows=609832849 width=108) + Group By Operator [GBY_350] (rows=609832849 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_350] (rows=87121617 width=135) + Group By Operator [GBY_346] (rows=87121617 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 52 [SIMPLE_EDGE] - SHUFFLE [RS_349] + SHUFFLE [RS_345] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_348] (rows=174243235 width=135) + Group By Operator [GBY_344] (rows=174243235 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(1)"],keys:_col0, _col1, _col2 - Select Operator [SEL_346] (rows=174243235 width=135) + Select Operator [SEL_342] (rows=174243235 width=135) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_888] (rows=174243235 width=135) - Conds:RS_343._col1=RS_344._col0(Inner),Output:["_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_881] (rows=174243235 width=135) + Conds:RS_339._col1=RS_340._col0(Inner),Output:["_col5","_col6","_col7"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_344] + SHUFFLE [RS_340] PartitionCols:_col0 - Select Operator [SEL_339] (rows=462000 width=1436) + Select Operator [SEL_335] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_835] (rows=462000 width=1436) + Filter Operator [FIL_828] (rows=462000 width=1436) predicate:(i_item_sk is not null and i_brand_id is not null and i_class_id is not null and i_category_id is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 51 [SIMPLE_EDGE] - SHUFFLE [RS_343] + SHUFFLE [RS_339] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_887] (rows=158402938 width=135) - Conds:RS_340._col0=RS_341._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_880] (rows=158402938 width=135) + Conds:RS_336._col0=RS_337._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_341] + SHUFFLE [RS_337] PartitionCols:_col0 - Select Operator [SEL_336] (rows=8116 width=1119) + Select Operator [SEL_332] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_834] (rows=8116 width=1119) + Filter Operator [FIL_827] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 99 [SIMPLE_EDGE] - SHUFFLE [RS_340] + SHUFFLE [RS_336] PartitionCols:_col0 - Select Operator [SEL_333] (rows=144002668 width=135) + Select Operator [SEL_329] (rows=144002668 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_833] (rows=144002668 width=135) + Filter Operator [FIL_826] (rows=144002668 width=135) predicate:(ws_item_sk is not null and ws_sold_date_sk is not null) - TableScan [TS_138] (rows=144002668 width=135) + TableScan [TS_136] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_item_sk"] <-Reducer 94 [SIMPLE_EDGE] - SHUFFLE [RS_370] + SHUFFLE [RS_366] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_882] (rows=316788826 width=135) - Conds:RS_367._col0=RS_368._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_875] (rows=316788826 width=135) + Conds:RS_363._col0=RS_364._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 93 [SIMPLE_EDGE] - SHUFFLE [RS_368] + SHUFFLE [RS_364] PartitionCols:_col0 - Select Operator [SEL_281] (rows=18262 width=1119) + Select Operator [SEL_277] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_824] (rows=18262 width=1119) + Filter Operator [FIL_817] (rows=18262 width=1119) predicate:((d_year = 2000) and (d_moy = 11) and d_date_sk is not null) - TableScan [TS_86] (rows=73049 width=1119) + TableScan [TS_84] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_moy"] <-Map 100 [SIMPLE_EDGE] - SHUFFLE [RS_367] + SHUFFLE [RS_363] PartitionCols:_col0 - Select Operator [SEL_278] (rows=287989836 width=135) + Select Operator [SEL_274] (rows=287989836 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_823] (rows=287989836 width=135) + Filter Operator [FIL_816] (rows=287989836 width=135) predicate:(cs_item_sk is not null and cs_sold_date_sk is not null) - TableScan [TS_276] (rows=287989836 width=135) + TableScan [TS_272] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_item_sk","cs_quantity","cs_list_price"] <-Reducer 16 [CONTAINS] - Reduce Output Operator [RS_584] + Reduce Output Operator [RS_577] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_583] (rows=2032776160 width=405) + Group By Operator [GBY_576] (rows=2032776160 width=405) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0 - Select Operator [SEL_580] (rows=58081078 width=432) + Select Operator [SEL_573] (rows=58081078 width=432) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_579] (rows=58081078 width=432) + Filter Operator [FIL_572] (rows=58081078 width=432) predicate:(_col5 > _col1) - Merge Join Operator [MERGEJOIN_908] (rows=174243235 width=432) + Merge Join Operator [MERGEJOIN_901] (rows=174243235 width=432) Conds:(Inner),(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 15 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_575] - Select Operator [SEL_432] (rows=1 width=8) - Filter Operator [FIL_431] (rows=1 width=8) + PARTITION_ONLY_SHUFFLE [RS_568] + Select Operator [SEL_426] (rows=1 width=8) + Filter Operator [FIL_425] (rows=1 width=8) predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_429] (rows=1 width=8) + Group By Operator [GBY_423] (rows=1 width=8) Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_424] (rows=1 width=8) - Group By Operator [GBY_423] (rows=1 width=8) + Select Operator [SEL_418] (rows=1 width=8) + Group By Operator [GBY_417] (rows=1 width=8) Output:["_col0"],aggregations:["count(VALUE._col0)"] <-Union 14 [CUSTOM_SIMPLE_EDGE] <-Reducer 13 [CONTAINS] - Reduce Output Operator [RS_422] - Group By Operator [GBY_421] (rows=1 width=8) + Reduce Output Operator [RS_416] + Group By Operator [GBY_415] (rows=1 width=8) Output:["_col0"],aggregations:["count(_col0)"] - Select Operator [SEL_420] (rows=1108786976 width=108) + Select Operator [SEL_414] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_397] (rows=633595212 width=88) + Select Operator [SEL_392] (rows=633595212 width=88) Output:["_col0"] - Merge Join Operator [MERGEJOIN_891] (rows=633595212 width=88) - Conds:RS_394._col0=RS_395._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_884] (rows=633595212 width=88) + Conds:RS_389._col0=RS_390._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_395] + SHUFFLE [RS_390] PartitionCols:_col0 - Select Operator [SEL_393] (rows=8116 width=1119) + Select Operator [SEL_388] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_837] (rows=8116 width=1119) + Filter Operator [FIL_830] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_394] + SHUFFLE [RS_389] PartitionCols:_col0 - Select Operator [SEL_390] (rows=575995635 width=88) + Select Operator [SEL_385] (rows=575995635 width=88) Output:["_col0","_col1"] - Filter Operator [FIL_836] (rows=575995635 width=88) + Filter Operator [FIL_829] (rows=575995635 width=88) predicate:ss_sold_date_sk is not null Please refer to the previous TableScan [TS_0] <-Reducer 75 [CONTAINS] - Reduce Output Operator [RS_422] - Group By Operator [GBY_421] (rows=1 width=8) + Reduce Output Operator [RS_416] + Group By Operator [GBY_415] (rows=1 width=8) Output:["_col0"],aggregations:["count(_col0)"] - Select Operator [SEL_420] (rows=1108786976 width=108) + Select Operator [SEL_414] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_407] (rows=316788826 width=135) + Select Operator [SEL_402] (rows=316788826 width=135) Output:["_col0"] - Merge Join Operator [MERGEJOIN_892] (rows=316788826 width=135) - Conds:RS_404._col0=RS_405._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_885] (rows=316788826 width=135) + Conds:RS_399._col0=RS_400._col0(Inner),Output:["_col1"] <-Map 76 [SIMPLE_EDGE] - SHUFFLE [RS_405] + SHUFFLE [RS_400] PartitionCols:_col0 - Select Operator [SEL_403] (rows=8116 width=1119) + Select Operator [SEL_398] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_839] (rows=8116 width=1119) + Filter Operator [FIL_832] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 72 [SIMPLE_EDGE] - SHUFFLE [RS_404] + SHUFFLE [RS_399] PartitionCols:_col0 - Select Operator [SEL_400] (rows=287989836 width=135) + Select Operator [SEL_395] (rows=287989836 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_838] (rows=287989836 width=135) + Filter Operator [FIL_831] (rows=287989836 width=135) predicate:cs_sold_date_sk is not null Please refer to the previous TableScan [TS_10] <-Reducer 83 [CONTAINS] - Reduce Output Operator [RS_422] - Group By Operator [GBY_421] (rows=1 width=8) + Reduce Output Operator [RS_416] + Group By Operator [GBY_415] (rows=1 width=8) Output:["_col0"],aggregations:["count(_col0)"] - Select Operator [SEL_420] (rows=1108786976 width=108) + Select Operator [SEL_414] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_419] (rows=158402938 width=135) + Select Operator [SEL_413] (rows=158402938 width=135) Output:["_col0"] - Merge Join Operator [MERGEJOIN_893] (rows=158402938 width=135) - Conds:RS_416._col0=RS_417._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_886] (rows=158402938 width=135) + Conds:RS_410._col0=RS_411._col0(Inner),Output:["_col1"] <-Map 84 [SIMPLE_EDGE] - SHUFFLE [RS_417] + SHUFFLE [RS_411] PartitionCols:_col0 - Select Operator [SEL_415] (rows=8116 width=1119) + Select Operator [SEL_409] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_841] (rows=8116 width=1119) + Filter Operator [FIL_834] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) - Please refer to the previous TableScan [TS_25] + Please refer to the previous TableScan [TS_24] <-Map 80 [SIMPLE_EDGE] - SHUFFLE [RS_416] + SHUFFLE [RS_410] PartitionCols:_col0 - Select Operator [SEL_412] (rows=144002668 width=135) + Select Operator [SEL_406] (rows=144002668 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_840] (rows=144002668 width=135) + Filter Operator [FIL_833] (rows=144002668 width=135) predicate:ws_sold_date_sk is not null - Please refer to the previous TableScan [TS_22] + Please refer to the previous TableScan [TS_21] <-Reducer 56 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_576] - Group By Operator [GBY_469] (rows=1 width=288) + PARTITION_ONLY_SHUFFLE [RS_569] + Group By Operator [GBY_462] (rows=1 width=288) Output:["_col0"],aggregations:["avg(VALUE._col0)"] <-Union 55 [CUSTOM_SIMPLE_EDGE] <-Reducer 54 [CONTAINS] - Reduce Output Operator [RS_468] - Group By Operator [GBY_467] (rows=1 width=288) + Reduce Output Operator [RS_461] + Group By Operator [GBY_460] (rows=1 width=288) Output:["_col0"],aggregations:["avg(_col0)"] - Select Operator [SEL_465] (rows=1108786976 width=108) + Select Operator [SEL_458] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_442] (rows=633595212 width=88) + Select Operator [SEL_436] (rows=633595212 width=88) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_894] (rows=633595212 width=88) - Conds:RS_439._col0=RS_440._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_887] (rows=633595212 width=88) + Conds:RS_433._col0=RS_434._col0(Inner),Output:["_col1","_col2"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_440] + SHUFFLE [RS_434] PartitionCols:_col0 - Select Operator [SEL_438] (rows=8116 width=1119) + Select Operator [SEL_432] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_843] (rows=8116 width=1119) + Filter Operator [FIL_836] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 88 [SIMPLE_EDGE] - SHUFFLE [RS_439] + SHUFFLE [RS_433] PartitionCols:_col0 - Select Operator [SEL_435] (rows=575995635 width=88) + Select Operator [SEL_429] (rows=575995635 width=88) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_842] (rows=575995635 width=88) + Filter Operator [FIL_835] (rows=575995635 width=88) predicate:ss_sold_date_sk is not null - Please refer to the previous TableScan [TS_45] + Please refer to the previous TableScan [TS_44] <-Reducer 79 [CONTAINS] - Reduce Output Operator [RS_468] - Group By Operator [GBY_467] (rows=1 width=288) + Reduce Output Operator [RS_461] + Group By Operator [GBY_460] (rows=1 width=288) Output:["_col0"],aggregations:["avg(_col0)"] - Select Operator [SEL_465] (rows=1108786976 width=108) + Select Operator [SEL_458] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_452] (rows=316788826 width=135) + Select Operator [SEL_446] (rows=316788826 width=135) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_895] (rows=316788826 width=135) - Conds:RS_449._col0=RS_450._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_888] (rows=316788826 width=135) + Conds:RS_443._col0=RS_444._col0(Inner),Output:["_col1","_col2"] <-Map 76 [SIMPLE_EDGE] - SHUFFLE [RS_450] + SHUFFLE [RS_444] PartitionCols:_col0 - Select Operator [SEL_448] (rows=8116 width=1119) + Select Operator [SEL_442] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_845] (rows=8116 width=1119) + Filter Operator [FIL_838] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 89 [SIMPLE_EDGE] - SHUFFLE [RS_449] + SHUFFLE [RS_443] PartitionCols:_col0 - Select Operator [SEL_445] (rows=287989836 width=135) + Select Operator [SEL_439] (rows=287989836 width=135) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_844] (rows=287989836 width=135) + Filter Operator [FIL_837] (rows=287989836 width=135) predicate:cs_sold_date_sk is not null - Please refer to the previous TableScan [TS_55] + Please refer to the previous TableScan [TS_54] <-Reducer 87 [CONTAINS] - Reduce Output Operator [RS_468] - Group By Operator [GBY_467] (rows=1 width=288) + Reduce Output Operator [RS_461] + Group By Operator [GBY_460] (rows=1 width=288) Output:["_col0"],aggregations:["avg(_col0)"] - Select Operator [SEL_465] (rows=1108786976 width=108) + Select Operator [SEL_458] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_464] (rows=158402938 width=135) + Select Operator [SEL_457] (rows=158402938 width=135) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_896] (rows=158402938 width=135) - Conds:RS_461._col0=RS_462._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_889] (rows=158402938 width=135) + Conds:RS_454._col0=RS_455._col0(Inner),Output:["_col1","_col2"] <-Map 84 [SIMPLE_EDGE] - SHUFFLE [RS_462] + SHUFFLE [RS_455] PartitionCols:_col0 - Select Operator [SEL_460] (rows=8116 width=1119) + Select Operator [SEL_453] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_847] (rows=8116 width=1119) + Filter Operator [FIL_840] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) - Please refer to the previous TableScan [TS_25] + Please refer to the previous TableScan [TS_24] <-Map 90 [SIMPLE_EDGE] - SHUFFLE [RS_461] + SHUFFLE [RS_454] PartitionCols:_col0 - Select Operator [SEL_457] (rows=144002668 width=135) + Select Operator [SEL_450] (rows=144002668 width=135) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_846] (rows=144002668 width=135) + Filter Operator [FIL_839] (rows=144002668 width=135) predicate:ws_sold_date_sk is not null - Please refer to the previous TableScan [TS_67] + Please refer to the previous TableScan [TS_65] <-Reducer 65 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_577] - Group By Operator [GBY_573] (rows=174243235 width=135) + PARTITION_ONLY_SHUFFLE [RS_570] + Group By Operator [GBY_566] (rows=174243235 width=135) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 64 [SIMPLE_EDGE] - SHUFFLE [RS_572] + SHUFFLE [RS_565] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_571] (rows=348486471 width=135) + Group By Operator [GBY_564] (rows=348486471 width=135) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0, _col1, _col2 - Select Operator [SEL_569] (rows=348486471 width=135) + Select Operator [SEL_562] (rows=348486471 width=135) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_905] (rows=348486471 width=135) - Conds:RS_565._col1=RS_566._col0(Inner),RS_565._col1=RS_567._col0(Inner),Output:["_col2","_col3","_col8","_col9","_col10"] + Merge Join Operator [MERGEJOIN_898] (rows=348486471 width=135) + Conds:RS_558._col1=RS_559._col0(Inner),RS_558._col1=RS_560._col0(Inner),Output:["_col2","_col3","_col8","_col9","_col10"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_566] + SHUFFLE [RS_559] PartitionCols:_col0 - Select Operator [SEL_479] (rows=462000 width=1436) + Select Operator [SEL_472] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_850] (rows=462000 width=1436) + Filter Operator [FIL_843] (rows=462000 width=1436) predicate:i_item_sk is not null - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 63 [SIMPLE_EDGE] - SHUFFLE [RS_567] + SHUFFLE [RS_560] PartitionCols:_col0 - Group By Operator [GBY_560] (rows=254100 width=1436) + Group By Operator [GBY_553] (rows=254100 width=1436) Output:["_col0"],keys:KEY._col0 <-Reducer 62 [SIMPLE_EDGE] - SHUFFLE [RS_559] + SHUFFLE [RS_552] PartitionCols:_col0 - Group By Operator [GBY_558] (rows=508200 width=1436) + Group By Operator [GBY_551] (rows=508200 width=1436) Output:["_col0"],keys:_col0 - Merge Join Operator [MERGEJOIN_904] (rows=508200 width=1436) - Conds:RS_554._col1, _col2, _col3=RS_555._col0, _col1, _col2(Inner),Output:["_col0"] + Merge Join Operator [MERGEJOIN_897] (rows=508200 width=1436) + Conds:RS_547._col1, _col2, _col3=RS_548._col0, _col1, _col2(Inner),Output:["_col0"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_554] + SHUFFLE [RS_547] PartitionCols:_col1, _col2, _col3 - Select Operator [SEL_482] (rows=462000 width=1436) + Select Operator [SEL_475] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_851] (rows=462000 width=1436) + Filter Operator [FIL_844] (rows=462000 width=1436) predicate:(i_brand_id is not null and i_class_id is not null and i_category_id is not null and i_item_sk is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 61 [SIMPLE_EDGE] - SHUFFLE [RS_555] + SHUFFLE [RS_548] PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_553] (rows=1 width=108) + Select Operator [SEL_546] (rows=1 width=108) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_552] (rows=1 width=108) + Filter Operator [FIL_545] (rows=1 width=108) predicate:(_col3 = 3) - Group By Operator [GBY_551] (rows=304916424 width=108) + Group By Operator [GBY_544] (rows=304916424 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 60 [SIMPLE_EDGE] <-Reducer 59 [CONTAINS] - Reduce Output Operator [RS_550] + Reduce Output Operator [RS_543] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_549] (rows=609832849 width=108) + Group By Operator [GBY_542] (rows=609832849 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_502] (rows=348477374 width=88) + Group By Operator [GBY_495] (rows=348477374 width=88) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 58 [SIMPLE_EDGE] - SHUFFLE [RS_501] + SHUFFLE [RS_494] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_500] (rows=696954748 width=88) + Group By Operator [GBY_493] (rows=696954748 width=88) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(1)"],keys:_col0, _col1, _col2 - Select Operator [SEL_498] (rows=696954748 width=88) + Select Operator [SEL_491] (rows=696954748 width=88) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_899] (rows=696954748 width=88) - Conds:RS_495._col1=RS_496._col0(Inner),Output:["_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_892] (rows=696954748 width=88) + Conds:RS_488._col1=RS_489._col0(Inner),Output:["_col5","_col6","_col7"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_496] + SHUFFLE [RS_489] PartitionCols:_col0 - Select Operator [SEL_491] (rows=462000 width=1436) + Select Operator [SEL_484] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_854] (rows=462000 width=1436) + Filter Operator [FIL_847] (rows=462000 width=1436) predicate:(i_item_sk is not null and i_brand_id is not null and i_class_id is not null and i_category_id is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 57 [SIMPLE_EDGE] - SHUFFLE [RS_495] + SHUFFLE [RS_488] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_898] (rows=633595212 width=88) - Conds:RS_492._col0=RS_493._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_891] (rows=633595212 width=88) + Conds:RS_485._col0=RS_486._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_493] + SHUFFLE [RS_486] PartitionCols:_col0 - Select Operator [SEL_488] (rows=8116 width=1119) + Select Operator [SEL_481] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_853] (rows=8116 width=1119) + Filter Operator [FIL_846] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 97 [SIMPLE_EDGE] - SHUFFLE [RS_492] + SHUFFLE [RS_485] PartitionCols:_col0 - Select Operator [SEL_485] (rows=575995635 width=88) + Select Operator [SEL_478] (rows=575995635 width=88) Output:["_col0","_col1"] - Filter Operator [FIL_852] (rows=575995635 width=88) + Filter Operator [FIL_845] (rows=575995635 width=88) predicate:(ss_item_sk is not null and ss_sold_date_sk is not null) - Please refer to the previous TableScan [TS_95] + Please refer to the previous TableScan [TS_93] <-Reducer 68 [CONTAINS] - Reduce Output Operator [RS_550] + Reduce Output Operator [RS_543] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_549] (rows=609832849 width=108) + Group By Operator [GBY_542] (rows=609832849 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_523] (rows=174233858 width=135) + Group By Operator [GBY_516] (rows=174233858 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 67 [SIMPLE_EDGE] - SHUFFLE [RS_522] + SHUFFLE [RS_515] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_521] (rows=348467716 width=135) + Group By Operator [GBY_514] (rows=348467716 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(1)"],keys:_col0, _col1, _col2 - Select Operator [SEL_519] (rows=348467716 width=135) + Select Operator [SEL_512] (rows=348467716 width=135) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_901] (rows=348467716 width=135) - Conds:RS_516._col1=RS_517._col0(Inner),Output:["_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_894] (rows=348467716 width=135) + Conds:RS_509._col1=RS_510._col0(Inner),Output:["_col5","_col6","_col7"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_517] + SHUFFLE [RS_510] PartitionCols:_col0 - Select Operator [SEL_512] (rows=462000 width=1436) + Select Operator [SEL_505] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_857] (rows=462000 width=1436) + Filter Operator [FIL_850] (rows=462000 width=1436) predicate:(i_item_sk is not null and i_brand_id is not null and i_class_id is not null and i_category_id is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 66 [SIMPLE_EDGE] - SHUFFLE [RS_516] + SHUFFLE [RS_509] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_900] (rows=316788826 width=135) - Conds:RS_513._col0=RS_514._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_893] (rows=316788826 width=135) + Conds:RS_506._col0=RS_507._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_514] + SHUFFLE [RS_507] PartitionCols:_col0 - Select Operator [SEL_509] (rows=8116 width=1119) + Select Operator [SEL_502] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_856] (rows=8116 width=1119) + Filter Operator [FIL_849] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 98 [SIMPLE_EDGE] - SHUFFLE [RS_513] + SHUFFLE [RS_506] PartitionCols:_col0 - Select Operator [SEL_506] (rows=287989836 width=135) + Select Operator [SEL_499] (rows=287989836 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_855] (rows=287989836 width=135) + Filter Operator [FIL_848] (rows=287989836 width=135) predicate:(cs_item_sk is not null and cs_sold_date_sk is not null) - Please refer to the previous TableScan [TS_116] + Please refer to the previous TableScan [TS_114] <-Reducer 71 [CONTAINS] - Reduce Output Operator [RS_550] + Reduce Output Operator [RS_543] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_549] (rows=609832849 width=108) + Group By Operator [GBY_542] (rows=609832849 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_545] (rows=87121617 width=135) + Group By Operator [GBY_538] (rows=87121617 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 70 [SIMPLE_EDGE] - SHUFFLE [RS_544] + SHUFFLE [RS_537] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_543] (rows=174243235 width=135) + Group By Operator [GBY_536] (rows=174243235 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(1)"],keys:_col0, _col1, _col2 - Select Operator [SEL_541] (rows=174243235 width=135) + Select Operator [SEL_534] (rows=174243235 width=135) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_903] (rows=174243235 width=135) - Conds:RS_538._col1=RS_539._col0(Inner),Output:["_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_896] (rows=174243235 width=135) + Conds:RS_531._col1=RS_532._col0(Inner),Output:["_col5","_col6","_col7"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_539] + SHUFFLE [RS_532] PartitionCols:_col0 - Select Operator [SEL_534] (rows=462000 width=1436) + Select Operator [SEL_527] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_860] (rows=462000 width=1436) + Filter Operator [FIL_853] (rows=462000 width=1436) predicate:(i_item_sk is not null and i_brand_id is not null and i_class_id is not null and i_category_id is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 69 [SIMPLE_EDGE] - SHUFFLE [RS_538] + SHUFFLE [RS_531] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_902] (rows=158402938 width=135) - Conds:RS_535._col0=RS_536._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_895] (rows=158402938 width=135) + Conds:RS_528._col0=RS_529._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_536] + SHUFFLE [RS_529] PartitionCols:_col0 - Select Operator [SEL_531] (rows=8116 width=1119) + Select Operator [SEL_524] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_859] (rows=8116 width=1119) + Filter Operator [FIL_852] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 99 [SIMPLE_EDGE] - SHUFFLE [RS_535] + SHUFFLE [RS_528] PartitionCols:_col0 - Select Operator [SEL_528] (rows=144002668 width=135) + Select Operator [SEL_521] (rows=144002668 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_858] (rows=144002668 width=135) + Filter Operator [FIL_851] (rows=144002668 width=135) predicate:(ws_item_sk is not null and ws_sold_date_sk is not null) - Please refer to the previous TableScan [TS_138] + Please refer to the previous TableScan [TS_136] <-Reducer 95 [SIMPLE_EDGE] - SHUFFLE [RS_565] + SHUFFLE [RS_558] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_897] (rows=158402938 width=135) - Conds:RS_562._col0=RS_563._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_890] (rows=158402938 width=135) + Conds:RS_555._col0=RS_556._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 93 [SIMPLE_EDGE] - SHUFFLE [RS_563] + SHUFFLE [RS_556] PartitionCols:_col0 - Select Operator [SEL_476] (rows=18262 width=1119) + Select Operator [SEL_469] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_849] (rows=18262 width=1119) + Filter Operator [FIL_842] (rows=18262 width=1119) predicate:((d_year = 2000) and (d_moy = 11) and d_date_sk is not null) - Please refer to the previous TableScan [TS_86] + Please refer to the previous TableScan [TS_84] <-Map 101 [SIMPLE_EDGE] - SHUFFLE [RS_562] + SHUFFLE [RS_555] PartitionCols:_col0 - Select Operator [SEL_473] (rows=144002668 width=135) + Select Operator [SEL_466] (rows=144002668 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_848] (rows=144002668 width=135) + Filter Operator [FIL_841] (rows=144002668 width=135) predicate:(ws_item_sk is not null and ws_sold_date_sk is not null) - TableScan [TS_471] (rows=144002668 width=135) + TableScan [TS_464] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_item_sk","ws_quantity","ws_list_price"] <-Reducer 5 [CONTAINS] - Reduce Output Operator [RS_584] + Reduce Output Operator [RS_577] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_583] (rows=2032776160 width=405) + Group By Operator [GBY_576] (rows=2032776160 width=405) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0 - Select Operator [SEL_192] (rows=232318249 width=385) + Select Operator [SEL_190] (rows=232318249 width=385) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_191] (rows=232318249 width=385) + Filter Operator [FIL_189] (rows=232318249 width=385) predicate:(_col5 > _col1) - Merge Join Operator [MERGEJOIN_906] (rows=696954748 width=385) + Merge Join Operator [MERGEJOIN_899] (rows=696954748 width=385) Conds:(Inner),(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 20 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_188] - Group By Operator [GBY_81] (rows=1 width=288) + PARTITION_ONLY_SHUFFLE [RS_186] + Group By Operator [GBY_79] (rows=1 width=288) Output:["_col0"],aggregations:["avg(VALUE._col0)"] <-Union 19 [CUSTOM_SIMPLE_EDGE] <-Reducer 18 [CONTAINS] - Reduce Output Operator [RS_80] - Group By Operator [GBY_79] (rows=1 width=288) + Reduce Output Operator [RS_78] + Group By Operator [GBY_77] (rows=1 width=288) Output:["_col0"],aggregations:["avg(_col0)"] - Select Operator [SEL_77] (rows=1108786976 width=108) + Select Operator [SEL_75] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_54] (rows=633595212 width=88) + Select Operator [SEL_53] (rows=633595212 width=88) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_864] (rows=633595212 width=88) - Conds:RS_51._col0=RS_52._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_857] (rows=633595212 width=88) + Conds:RS_50._col0=RS_51._col0(Inner),Output:["_col1","_col2"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_52] + SHUFFLE [RS_51] PartitionCols:_col0 - Select Operator [SEL_50] (rows=8116 width=1119) + Select Operator [SEL_49] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_793] (rows=8116 width=1119) + Filter Operator [FIL_786] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 88 [SIMPLE_EDGE] - SHUFFLE [RS_51] + SHUFFLE [RS_50] PartitionCols:_col0 - Select Operator [SEL_47] (rows=575995635 width=88) + Select Operator [SEL_46] (rows=575995635 width=88) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_792] (rows=575995635 width=88) + Filter Operator [FIL_785] (rows=575995635 width=88) predicate:ss_sold_date_sk is not null - Please refer to the previous TableScan [TS_45] + Please refer to the previous TableScan [TS_44] <-Reducer 77 [CONTAINS] - Reduce Output Operator [RS_80] - Group By Operator [GBY_79] (rows=1 width=288) + Reduce Output Operator [RS_78] + Group By Operator [GBY_77] (rows=1 width=288) Output:["_col0"],aggregations:["avg(_col0)"] - Select Operator [SEL_77] (rows=1108786976 width=108) + Select Operator [SEL_75] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_64] (rows=316788826 width=135) + Select Operator [SEL_63] (rows=316788826 width=135) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_865] (rows=316788826 width=135) - Conds:RS_61._col0=RS_62._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_858] (rows=316788826 width=135) + Conds:RS_60._col0=RS_61._col0(Inner),Output:["_col1","_col2"] <-Map 76 [SIMPLE_EDGE] - SHUFFLE [RS_62] + SHUFFLE [RS_61] PartitionCols:_col0 - Select Operator [SEL_60] (rows=8116 width=1119) + Select Operator [SEL_59] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_795] (rows=8116 width=1119) + Filter Operator [FIL_788] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 89 [SIMPLE_EDGE] - SHUFFLE [RS_61] + SHUFFLE [RS_60] PartitionCols:_col0 - Select Operator [SEL_57] (rows=287989836 width=135) + Select Operator [SEL_56] (rows=287989836 width=135) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_794] (rows=287989836 width=135) + Filter Operator [FIL_787] (rows=287989836 width=135) predicate:cs_sold_date_sk is not null - Please refer to the previous TableScan [TS_55] + Please refer to the previous TableScan [TS_54] <-Reducer 85 [CONTAINS] - Reduce Output Operator [RS_80] - Group By Operator [GBY_79] (rows=1 width=288) + Reduce Output Operator [RS_78] + Group By Operator [GBY_77] (rows=1 width=288) Output:["_col0"],aggregations:["avg(_col0)"] - Select Operator [SEL_77] (rows=1108786976 width=108) + Select Operator [SEL_75] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_76] (rows=158402938 width=135) + Select Operator [SEL_74] (rows=158402938 width=135) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_866] (rows=158402938 width=135) - Conds:RS_73._col0=RS_74._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_859] (rows=158402938 width=135) + Conds:RS_71._col0=RS_72._col0(Inner),Output:["_col1","_col2"] <-Map 84 [SIMPLE_EDGE] - SHUFFLE [RS_74] + SHUFFLE [RS_72] PartitionCols:_col0 - Select Operator [SEL_72] (rows=8116 width=1119) + Select Operator [SEL_70] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_797] (rows=8116 width=1119) + Filter Operator [FIL_790] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) - Please refer to the previous TableScan [TS_25] + Please refer to the previous TableScan [TS_24] <-Map 90 [SIMPLE_EDGE] - SHUFFLE [RS_73] + SHUFFLE [RS_71] PartitionCols:_col0 - Select Operator [SEL_69] (rows=144002668 width=135) + Select Operator [SEL_67] (rows=144002668 width=135) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_796] (rows=144002668 width=135) + Filter Operator [FIL_789] (rows=144002668 width=135) predicate:ws_sold_date_sk is not null - Please refer to the previous TableScan [TS_67] + Please refer to the previous TableScan [TS_65] <-Reducer 29 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_189] - Group By Operator [GBY_185] (rows=696954748 width=88) + PARTITION_ONLY_SHUFFLE [RS_187] + Group By Operator [GBY_183] (rows=696954748 width=88) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 28 [SIMPLE_EDGE] - SHUFFLE [RS_184] + SHUFFLE [RS_182] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_183] (rows=1393909496 width=88) + Group By Operator [GBY_181] (rows=1393909496 width=88) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0, _col1, _col2 - Select Operator [SEL_181] (rows=1393909496 width=88) + Select Operator [SEL_179] (rows=1393909496 width=88) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_875] (rows=1393909496 width=88) - Conds:RS_177._col1=RS_178._col0(Inner),RS_177._col1=RS_179._col0(Inner),Output:["_col2","_col3","_col8","_col9","_col10"] + Merge Join Operator [MERGEJOIN_868] (rows=1393909496 width=88) + Conds:RS_175._col1=RS_176._col0(Inner),RS_175._col1=RS_177._col0(Inner),Output:["_col2","_col3","_col8","_col9","_col10"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_178] + SHUFFLE [RS_176] PartitionCols:_col0 - Select Operator [SEL_91] (rows=462000 width=1436) + Select Operator [SEL_89] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_800] (rows=462000 width=1436) + Filter Operator [FIL_793] (rows=462000 width=1436) predicate:i_item_sk is not null - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 27 [SIMPLE_EDGE] - SHUFFLE [RS_179] + SHUFFLE [RS_177] PartitionCols:_col0 - Group By Operator [GBY_172] (rows=254100 width=1436) + Group By Operator [GBY_170] (rows=254100 width=1436) Output:["_col0"],keys:KEY._col0 <-Reducer 26 [SIMPLE_EDGE] - SHUFFLE [RS_171] + SHUFFLE [RS_169] PartitionCols:_col0 - Group By Operator [GBY_170] (rows=508200 width=1436) + Group By Operator [GBY_168] (rows=508200 width=1436) Output:["_col0"],keys:_col0 - Merge Join Operator [MERGEJOIN_874] (rows=508200 width=1436) - Conds:RS_166._col1, _col2, _col3=RS_167._col0, _col1, _col2(Inner),Output:["_col0"] + Merge Join Operator [MERGEJOIN_867] (rows=508200 width=1436) + Conds:RS_164._col1, _col2, _col3=RS_165._col0, _col1, _col2(Inner),Output:["_col0"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_166] + SHUFFLE [RS_164] PartitionCols:_col1, _col2, _col3 - Select Operator [SEL_94] (rows=462000 width=1436) + Select Operator [SEL_92] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_801] (rows=462000 width=1436) + Filter Operator [FIL_794] (rows=462000 width=1436) predicate:(i_brand_id is not null and i_class_id is not null and i_category_id is not null and i_item_sk is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 25 [SIMPLE_EDGE] - SHUFFLE [RS_167] + SHUFFLE [RS_165] PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_165] (rows=1 width=108) + Select Operator [SEL_163] (rows=1 width=108) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_164] (rows=1 width=108) + Filter Operator [FIL_162] (rows=1 width=108) predicate:(_col3 = 3) - Group By Operator [GBY_163] (rows=304916424 width=108) + Group By Operator [GBY_161] (rows=304916424 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 24 [SIMPLE_EDGE] <-Reducer 23 [CONTAINS] - Reduce Output Operator [RS_162] + Reduce Output Operator [RS_160] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_161] (rows=609832849 width=108) + Group By Operator [GBY_159] (rows=609832849 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_114] (rows=348477374 width=88) + Group By Operator [GBY_112] (rows=348477374 width=88) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_113] + SHUFFLE [RS_111] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_112] (rows=696954748 width=88) + Group By Operator [GBY_110] (rows=696954748 width=88) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(1)"],keys:_col0, _col1, _col2 - Select Operator [SEL_110] (rows=696954748 width=88) + Select Operator [SEL_108] (rows=696954748 width=88) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_869] (rows=696954748 width=88) - Conds:RS_107._col1=RS_108._col0(Inner),Output:["_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_862] (rows=696954748 width=88) + Conds:RS_105._col1=RS_106._col0(Inner),Output:["_col5","_col6","_col7"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_108] + SHUFFLE [RS_106] PartitionCols:_col0 - Select Operator [SEL_103] (rows=462000 width=1436) + Select Operator [SEL_101] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_804] (rows=462000 width=1436) + Filter Operator [FIL_797] (rows=462000 width=1436) predicate:(i_item_sk is not null and i_brand_id is not null and i_class_id is not null and i_category_id is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_107] + SHUFFLE [RS_105] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_868] (rows=633595212 width=88) - Conds:RS_104._col0=RS_105._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_861] (rows=633595212 width=88) + Conds:RS_102._col0=RS_103._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_105] + SHUFFLE [RS_103] PartitionCols:_col0 - Select Operator [SEL_100] (rows=8116 width=1119) + Select Operator [SEL_98] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_803] (rows=8116 width=1119) + Filter Operator [FIL_796] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 97 [SIMPLE_EDGE] - SHUFFLE [RS_104] + SHUFFLE [RS_102] PartitionCols:_col0 - Select Operator [SEL_97] (rows=575995635 width=88) + Select Operator [SEL_95] (rows=575995635 width=88) Output:["_col0","_col1"] - Filter Operator [FIL_802] (rows=575995635 width=88) + Filter Operator [FIL_795] (rows=575995635 width=88) predicate:(ss_item_sk is not null and ss_sold_date_sk is not null) - Please refer to the previous TableScan [TS_95] + Please refer to the previous TableScan [TS_93] <-Reducer 32 [CONTAINS] - Reduce Output Operator [RS_162] + Reduce Output Operator [RS_160] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_161] (rows=609832849 width=108) + Group By Operator [GBY_159] (rows=609832849 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_135] (rows=174233858 width=135) + Group By Operator [GBY_133] (rows=174233858 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 31 [SIMPLE_EDGE] - SHUFFLE [RS_134] + SHUFFLE [RS_132] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_133] (rows=348467716 width=135) + Group By Operator [GBY_131] (rows=348467716 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(1)"],keys:_col0, _col1, _col2 - Select Operator [SEL_131] (rows=348467716 width=135) + Select Operator [SEL_129] (rows=348467716 width=135) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_871] (rows=348467716 width=135) - Conds:RS_128._col1=RS_129._col0(Inner),Output:["_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_864] (rows=348467716 width=135) + Conds:RS_126._col1=RS_127._col0(Inner),Output:["_col5","_col6","_col7"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_129] + SHUFFLE [RS_127] PartitionCols:_col0 - Select Operator [SEL_124] (rows=462000 width=1436) + Select Operator [SEL_122] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_807] (rows=462000 width=1436) + Filter Operator [FIL_800] (rows=462000 width=1436) predicate:(i_item_sk is not null and i_brand_id is not null and i_class_id is not null and i_category_id is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 30 [SIMPLE_EDGE] - SHUFFLE [RS_128] + SHUFFLE [RS_126] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_870] (rows=316788826 width=135) - Conds:RS_125._col0=RS_126._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_863] (rows=316788826 width=135) + Conds:RS_123._col0=RS_124._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_126] + SHUFFLE [RS_124] PartitionCols:_col0 - Select Operator [SEL_121] (rows=8116 width=1119) + Select Operator [SEL_119] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_806] (rows=8116 width=1119) + Filter Operator [FIL_799] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 98 [SIMPLE_EDGE] - SHUFFLE [RS_125] + SHUFFLE [RS_123] PartitionCols:_col0 - Select Operator [SEL_118] (rows=287989836 width=135) + Select Operator [SEL_116] (rows=287989836 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_805] (rows=287989836 width=135) + Filter Operator [FIL_798] (rows=287989836 width=135) predicate:(cs_item_sk is not null and cs_sold_date_sk is not null) - Please refer to the previous TableScan [TS_116] + Please refer to the previous TableScan [TS_114] <-Reducer 35 [CONTAINS] - Reduce Output Operator [RS_162] + Reduce Output Operator [RS_160] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_161] (rows=609832849 width=108) + Group By Operator [GBY_159] (rows=609832849 width=108) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_157] (rows=87121617 width=135) + Group By Operator [GBY_155] (rows=87121617 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 34 [SIMPLE_EDGE] - SHUFFLE [RS_156] + SHUFFLE [RS_154] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_155] (rows=174243235 width=135) + Group By Operator [GBY_153] (rows=174243235 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(1)"],keys:_col0, _col1, _col2 - Select Operator [SEL_153] (rows=174243235 width=135) + Select Operator [SEL_151] (rows=174243235 width=135) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_873] (rows=174243235 width=135) - Conds:RS_150._col1=RS_151._col0(Inner),Output:["_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_866] (rows=174243235 width=135) + Conds:RS_148._col1=RS_149._col0(Inner),Output:["_col5","_col6","_col7"] <-Map 96 [SIMPLE_EDGE] - SHUFFLE [RS_151] + SHUFFLE [RS_149] PartitionCols:_col0 - Select Operator [SEL_146] (rows=462000 width=1436) + Select Operator [SEL_144] (rows=462000 width=1436) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_810] (rows=462000 width=1436) + Filter Operator [FIL_803] (rows=462000 width=1436) predicate:(i_item_sk is not null and i_brand_id is not null and i_class_id is not null and i_category_id is not null) - Please refer to the previous TableScan [TS_89] + Please refer to the previous TableScan [TS_87] <-Reducer 33 [SIMPLE_EDGE] - SHUFFLE [RS_150] + SHUFFLE [RS_148] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_872] (rows=158402938 width=135) - Conds:RS_147._col0=RS_148._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_865] (rows=158402938 width=135) + Conds:RS_145._col0=RS_146._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_148] + SHUFFLE [RS_146] PartitionCols:_col0 - Select Operator [SEL_143] (rows=8116 width=1119) + Select Operator [SEL_141] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_809] (rows=8116 width=1119) + Filter Operator [FIL_802] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 99 [SIMPLE_EDGE] - SHUFFLE [RS_147] + SHUFFLE [RS_145] PartitionCols:_col0 - Select Operator [SEL_140] (rows=144002668 width=135) + Select Operator [SEL_138] (rows=144002668 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_808] (rows=144002668 width=135) + Filter Operator [FIL_801] (rows=144002668 width=135) predicate:(ws_item_sk is not null and ws_sold_date_sk is not null) - Please refer to the previous TableScan [TS_138] + Please refer to the previous TableScan [TS_136] <-Reducer 92 [SIMPLE_EDGE] - SHUFFLE [RS_177] + SHUFFLE [RS_175] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_867] (rows=633595212 width=88) - Conds:RS_174._col0=RS_175._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_860] (rows=633595212 width=88) + Conds:RS_172._col0=RS_173._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 93 [SIMPLE_EDGE] - SHUFFLE [RS_175] + SHUFFLE [RS_173] PartitionCols:_col0 - Select Operator [SEL_88] (rows=18262 width=1119) + Select Operator [SEL_86] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_799] (rows=18262 width=1119) + Filter Operator [FIL_792] (rows=18262 width=1119) predicate:((d_year = 2000) and (d_moy = 11) and d_date_sk is not null) - Please refer to the previous TableScan [TS_86] + Please refer to the previous TableScan [TS_84] <-Map 91 [SIMPLE_EDGE] - SHUFFLE [RS_174] + SHUFFLE [RS_172] PartitionCols:_col0 - Select Operator [SEL_85] (rows=575995635 width=88) + Select Operator [SEL_83] (rows=575995635 width=88) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_798] (rows=575995635 width=88) + Filter Operator [FIL_791] (rows=575995635 width=88) predicate:(ss_item_sk is not null and ss_sold_date_sk is not null) - TableScan [TS_83] (rows=575995635 width=88) + TableScan [TS_81] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_item_sk","ss_quantity","ss_list_price"] <-Reducer 4 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_187] - Select Operator [SEL_44] (rows=1 width=8) - Filter Operator [FIL_43] (rows=1 width=8) + PARTITION_ONLY_SHUFFLE [RS_185] + Select Operator [SEL_43] (rows=1 width=8) + Filter Operator [FIL_42] (rows=1 width=8) predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_41] (rows=1 width=8) + Group By Operator [GBY_40] (rows=1 width=8) Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_36] (rows=1 width=8) - Group By Operator [GBY_35] (rows=1 width=8) + Select Operator [SEL_35] (rows=1 width=8) + Group By Operator [GBY_34] (rows=1 width=8) Output:["_col0"],aggregations:["count(VALUE._col0)"] <-Union 3 [CUSTOM_SIMPLE_EDGE] <-Reducer 2 [CONTAINS] - Reduce Output Operator [RS_34] - Group By Operator [GBY_33] (rows=1 width=8) + Reduce Output Operator [RS_33] + Group By Operator [GBY_32] (rows=1 width=8) Output:["_col0"],aggregations:["count(_col0)"] - Select Operator [SEL_32] (rows=1108786976 width=108) + Select Operator [SEL_31] (rows=1108786976 width=108) Output:["_col0"] Select Operator [SEL_9] (rows=633595212 width=88) Output:["_col0"] - Merge Join Operator [MERGEJOIN_861] (rows=633595212 width=88) + Merge Join Operator [MERGEJOIN_854] (rows=633595212 width=88) Conds:RS_6._col0=RS_7._col0(Inner),Output:["_col1"] <-Map 17 [SIMPLE_EDGE] SHUFFLE [RS_7] PartitionCols:_col0 Select Operator [SEL_5] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_787] (rows=8116 width=1119) + Filter Operator [FIL_780] (rows=8116 width=1119) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] @@ -1434,25 +1434,25 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_2] (rows=575995635 width=88) Output:["_col0","_col1"] - Filter Operator [FIL_786] (rows=575995635 width=88) + Filter Operator [FIL_779] (rows=575995635 width=88) predicate:ss_sold_date_sk is not null Please refer to the previous TableScan [TS_0] <-Reducer 73 [CONTAINS] - Reduce Output Operator [RS_34] - Group By Operator [GBY_33] (rows=1 width=8) + Reduce Output Operator [RS_33] + Group By Operator [GBY_32] (rows=1 width=8) Output:["_col0"],aggregations:["count(_col0)"] - Select Operator [SEL_32] (rows=1108786976 width=108) + Select Operator [SEL_31] (rows=1108786976 width=108) Output:["_col0"] Select Operator [SEL_19] (rows=316788826 width=135) Output:["_col0"] - Merge Join Operator [MERGEJOIN_862] (rows=316788826 width=135) + Merge Join Operator [MERGEJOIN_855] (rows=316788826 width=135) Conds:RS_16._col0=RS_17._col0(Inner),Output:["_col1"] <-Map 76 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 Select Operator [SEL_15] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_789] (rows=8116 width=1119) + Filter Operator [FIL_782] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 72 [SIMPLE_EDGE] @@ -1460,33 +1460,33 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_12] (rows=287989836 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_788] (rows=287989836 width=135) + Filter Operator [FIL_781] (rows=287989836 width=135) predicate:cs_sold_date_sk is not null Please refer to the previous TableScan [TS_10] <-Reducer 81 [CONTAINS] - Reduce Output Operator [RS_34] - Group By Operator [GBY_33] (rows=1 width=8) + Reduce Output Operator [RS_33] + Group By Operator [GBY_32] (rows=1 width=8) Output:["_col0"],aggregations:["count(_col0)"] - Select Operator [SEL_32] (rows=1108786976 width=108) + Select Operator [SEL_31] (rows=1108786976 width=108) Output:["_col0"] - Select Operator [SEL_31] (rows=158402938 width=135) + Select Operator [SEL_30] (rows=158402938 width=135) Output:["_col0"] - Merge Join Operator [MERGEJOIN_863] (rows=158402938 width=135) - Conds:RS_28._col0=RS_29._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_856] (rows=158402938 width=135) + Conds:RS_27._col0=RS_28._col0(Inner),Output:["_col1"] <-Map 84 [SIMPLE_EDGE] - SHUFFLE [RS_29] + SHUFFLE [RS_28] PartitionCols:_col0 - Select Operator [SEL_27] (rows=8116 width=1119) + Select Operator [SEL_26] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_791] (rows=8116 width=1119) + Filter Operator [FIL_784] (rows=8116 width=1119) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) - Please refer to the previous TableScan [TS_25] + Please refer to the previous TableScan [TS_24] <-Map 80 [SIMPLE_EDGE] - SHUFFLE [RS_28] + SHUFFLE [RS_27] PartitionCols:_col0 - Select Operator [SEL_24] (rows=144002668 width=135) + Select Operator [SEL_23] (rows=144002668 width=135) Output:["_col0","_col1"] - Filter Operator [FIL_790] (rows=144002668 width=135) + Filter Operator [FIL_783] (rows=144002668 width=135) predicate:ws_sold_date_sk is not null - Please refer to the previous TableScan [TS_22] + Please refer to the previous TableScan [TS_21] diff --git a/ql/src/test/results/clientpositive/perf/query23.q.out b/ql/src/test/results/clientpositive/perf/query23.q.out index 1fd8cb4f25..b8cdad3920 100644 --- a/ql/src/test/results/clientpositive/perf/query23.q.out +++ b/ql/src/test/results/clientpositive/perf/query23.q.out @@ -1,5 +1,5 @@ -Warning: Shuffle Join MERGEJOIN[369][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 30' is a cross product Warning: Shuffle Join MERGEJOIN[367][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 25' is a cross product +Warning: Shuffle Join MERGEJOIN[369][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 30' is a cross product PREHOOK: query: explain with frequent_ss_items as (select substr(i_item_desc,1,30) itemdesc,i_item_sk item_sk,d_date solddate,count(*) cnt diff --git a/ql/src/test/results/clientpositive/perf/query33.q.out b/ql/src/test/results/clientpositive/perf/query33.q.out index c1a5fa28ed..2058830420 100644 --- a/ql/src/test/results/clientpositive/perf/query33.q.out +++ b/ql/src/test/results/clientpositive/perf/query33.q.out @@ -175,20 +175,20 @@ Stage-0 limit:100 Stage-1 Reducer 7 - File Output Operator [FS_122] - Limit [LIM_121] (rows=100 width=108) + File Output Operator [FS_121] + Limit [LIM_120] (rows=100 width=108) Number of rows:100 - Select Operator [SEL_120] (rows=335408073 width=108) + Select Operator [SEL_119] (rows=335408073 width=108) Output:["_col0","_col1"] <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_119] - Group By Operator [GBY_117] (rows=335408073 width=108) + SHUFFLE [RS_118] + Group By Operator [GBY_116] (rows=335408073 width=108) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Union 5 [SIMPLE_EDGE] <-Reducer 10 [CONTAINS] - Reduce Output Operator [RS_116] + Reduce Output Operator [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=670816147 width=108) + Group By Operator [GBY_114] (rows=670816147 width=108) Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 Group By Operator [GBY_72] (rows=191657247 width=135) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 @@ -197,35 +197,35 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_70] (rows=383314495 width=135) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col1 - Merge Join Operator [MERGEJOIN_184] (rows=383314495 width=135) + Merge Join Operator [MERGEJOIN_183] (rows=383314495 width=135) Conds:RS_66._col0=RS_67._col4(Inner),Output:["_col1","_col8"] <-Reducer 23 [SIMPLE_EDGE] SHUFFLE [RS_67] PartitionCols:_col4 Select Operator [SEL_62] (rows=348467716 width=135) Output:["_col4","_col5"] - Merge Join Operator [MERGEJOIN_179] (rows=348467716 width=135) + Merge Join Operator [MERGEJOIN_178] (rows=348467716 width=135) Conds:RS_59._col1=RS_60._col0(Inner),Output:["_col2","_col3"] <-Map 26 [SIMPLE_EDGE] SHUFFLE [RS_60] PartitionCols:_col0 Select Operator [SEL_55] (rows=20000000 width=1014) Output:["_col0"] - Filter Operator [FIL_168] (rows=20000000 width=1014) + Filter Operator [FIL_167] (rows=20000000 width=1014) predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) TableScan [TS_16] (rows=40000000 width=1014) default@customer_address,customer_address,Tbl:COMPLETE,Col:NONE,Output:["ca_address_sk","ca_gmt_offset"] <-Reducer 22 [SIMPLE_EDGE] SHUFFLE [RS_59] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_178] (rows=316788826 width=135) + Merge Join Operator [MERGEJOIN_177] (rows=316788826 width=135) Conds:RS_56._col0=RS_57._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 21 [SIMPLE_EDGE] SHUFFLE [RS_57] PartitionCols:_col0 Select Operator [SEL_52] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_167] (rows=18262 width=1119) + Filter Operator [FIL_166] (rows=18262 width=1119) predicate:((d_year = 1999) and (d_moy = 3) and d_date_sk is not null) TableScan [TS_13] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_moy"] @@ -234,21 +234,21 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_49] (rows=287989836 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_166] (rows=287989836 width=135) + Filter Operator [FIL_165] (rows=287989836 width=135) predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_item_sk is not null) TableScan [TS_47] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] <-Reducer 8 [SIMPLE_EDGE] SHUFFLE [RS_66] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_177] (rows=508200 width=1436) + Merge Join Operator [MERGEJOIN_176] (rows=508200 width=1436) Conds:RS_63._col1=RS_64._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_63] PartitionCols:_col1 Select Operator [SEL_39] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_164] (rows=462000 width=1436) + Filter Operator [FIL_163] (rows=462000 width=1436) predicate:(i_manufact_id is not null and i_item_sk is not null) TableScan [TS_0] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_sk","i_manufact_id"] @@ -264,93 +264,93 @@ Stage-0 Output:["_col0"],keys:i_manufact_id Select Operator [SEL_42] (rows=231000 width=1436) Output:["i_manufact_id"] - Filter Operator [FIL_165] (rows=231000 width=1436) + Filter Operator [FIL_164] (rows=231000 width=1436) predicate:((i_category) IN ('Books') and i_manufact_id is not null) TableScan [TS_3] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_category","i_manufact_id"] <-Reducer 13 [CONTAINS] - Reduce Output Operator [RS_116] + Reduce Output Operator [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=670816147 width=108) + Group By Operator [GBY_114] (rows=670816147 width=108) Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_111] (rows=95833781 width=135) + Group By Operator [GBY_110] (rows=95833781 width=135) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_110] + SHUFFLE [RS_109] PartitionCols:_col0 - Group By Operator [GBY_109] (rows=191667562 width=135) + Group By Operator [GBY_108] (rows=191667562 width=135) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col1 - Merge Join Operator [MERGEJOIN_185] (rows=191667562 width=135) - Conds:RS_105._col0=RS_106._col3(Inner),Output:["_col1","_col8"] + Merge Join Operator [MERGEJOIN_184] (rows=191667562 width=135) + Conds:RS_104._col0=RS_105._col3(Inner),Output:["_col1","_col8"] <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_105] + SHUFFLE [RS_104] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_180] (rows=508200 width=1436) - Conds:RS_102._col1=RS_103._col0(Inner),Output:["_col0","_col1"] + Merge Join Operator [MERGEJOIN_179] (rows=508200 width=1436) + Conds:RS_101._col1=RS_102._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_102] + SHUFFLE [RS_101] PartitionCols:_col1 - Select Operator [SEL_78] (rows=462000 width=1436) + Select Operator [SEL_77] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_169] (rows=462000 width=1436) + Filter Operator [FIL_168] (rows=462000 width=1436) predicate:(i_manufact_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_0] <-Reducer 17 [SIMPLE_EDGE] - SHUFFLE [RS_103] + SHUFFLE [RS_102] PartitionCols:_col0 - Group By Operator [GBY_84] (rows=115500 width=1436) + Group By Operator [GBY_83] (rows=115500 width=1436) Output:["_col0"],keys:KEY._col0 <-Map 14 [SIMPLE_EDGE] - SHUFFLE [RS_83] + SHUFFLE [RS_82] PartitionCols:_col0 - Group By Operator [GBY_82] (rows=231000 width=1436) + Group By Operator [GBY_81] (rows=231000 width=1436) Output:["_col0"],keys:i_manufact_id - Select Operator [SEL_81] (rows=231000 width=1436) + Select Operator [SEL_80] (rows=231000 width=1436) Output:["i_manufact_id"] - Filter Operator [FIL_170] (rows=231000 width=1436) + Filter Operator [FIL_169] (rows=231000 width=1436) predicate:((i_category) IN ('Books') and i_manufact_id is not null) Please refer to the previous TableScan [TS_3] <-Reducer 25 [SIMPLE_EDGE] - SHUFFLE [RS_106] + SHUFFLE [RS_105] PartitionCols:_col3 - Select Operator [SEL_101] (rows=174243235 width=135) + Select Operator [SEL_100] (rows=174243235 width=135) Output:["_col3","_col5"] - Merge Join Operator [MERGEJOIN_182] (rows=174243235 width=135) - Conds:RS_98._col2=RS_99._col0(Inner),Output:["_col1","_col3"] + Merge Join Operator [MERGEJOIN_181] (rows=174243235 width=135) + Conds:RS_97._col2=RS_98._col0(Inner),Output:["_col1","_col3"] <-Map 26 [SIMPLE_EDGE] - SHUFFLE [RS_99] + SHUFFLE [RS_98] PartitionCols:_col0 - Select Operator [SEL_94] (rows=20000000 width=1014) + Select Operator [SEL_93] (rows=20000000 width=1014) Output:["_col0"] - Filter Operator [FIL_173] (rows=20000000 width=1014) + Filter Operator [FIL_172] (rows=20000000 width=1014) predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) Please refer to the previous TableScan [TS_16] <-Reducer 24 [SIMPLE_EDGE] - SHUFFLE [RS_98] + SHUFFLE [RS_97] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_181] (rows=158402938 width=135) - Conds:RS_95._col0=RS_96._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_180] (rows=158402938 width=135) + Conds:RS_94._col0=RS_95._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 21 [SIMPLE_EDGE] - SHUFFLE [RS_96] + SHUFFLE [RS_95] PartitionCols:_col0 - Select Operator [SEL_91] (rows=18262 width=1119) + Select Operator [SEL_90] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_172] (rows=18262 width=1119) + Filter Operator [FIL_171] (rows=18262 width=1119) predicate:((d_year = 1999) and (d_moy = 3) and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_95] + SHUFFLE [RS_94] PartitionCols:_col0 - Select Operator [SEL_88] (rows=144002668 width=135) + Select Operator [SEL_87] (rows=144002668 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_171] (rows=144002668 width=135) + Filter Operator [FIL_170] (rows=144002668 width=135) predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_item_sk is not null) - TableScan [TS_86] (rows=144002668 width=135) + TableScan [TS_85] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] <-Reducer 4 [CONTAINS] - Reduce Output Operator [RS_116] + Reduce Output Operator [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=670816147 width=108) + Group By Operator [GBY_114] (rows=670816147 width=108) Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 Group By Operator [GBY_35] (rows=383325119 width=88) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 @@ -359,19 +359,19 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_33] (rows=766650239 width=88) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col1 - Merge Join Operator [MERGEJOIN_183] (rows=766650239 width=88) + Merge Join Operator [MERGEJOIN_182] (rows=766650239 width=88) Conds:RS_29._col0=RS_30._col3(Inner),Output:["_col1","_col8"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_174] (rows=508200 width=1436) + Merge Join Operator [MERGEJOIN_173] (rows=508200 width=1436) Conds:RS_26._col1=RS_27._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col1 Select Operator [SEL_2] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_159] (rows=462000 width=1436) + Filter Operator [FIL_158] (rows=462000 width=1436) predicate:(i_manufact_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_0] <-Reducer 15 [SIMPLE_EDGE] @@ -386,7 +386,7 @@ Stage-0 Output:["_col0"],keys:i_manufact_id Select Operator [SEL_5] (rows=231000 width=1436) Output:["i_manufact_id"] - Filter Operator [FIL_160] (rows=231000 width=1436) + Filter Operator [FIL_159] (rows=231000 width=1436) predicate:((i_category) IN ('Books') and i_manufact_id is not null) Please refer to the previous TableScan [TS_3] <-Reducer 20 [SIMPLE_EDGE] @@ -394,27 +394,27 @@ Stage-0 PartitionCols:_col3 Select Operator [SEL_25] (rows=696954748 width=88) Output:["_col3","_col5"] - Merge Join Operator [MERGEJOIN_176] (rows=696954748 width=88) + Merge Join Operator [MERGEJOIN_175] (rows=696954748 width=88) Conds:RS_22._col2=RS_23._col0(Inner),Output:["_col1","_col3"] <-Map 26 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col0 Select Operator [SEL_18] (rows=20000000 width=1014) Output:["_col0"] - Filter Operator [FIL_163] (rows=20000000 width=1014) + Filter Operator [FIL_162] (rows=20000000 width=1014) predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) Please refer to the previous TableScan [TS_16] <-Reducer 19 [SIMPLE_EDGE] SHUFFLE [RS_22] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_175] (rows=633595212 width=88) + Merge Join Operator [MERGEJOIN_174] (rows=633595212 width=88) Conds:RS_19._col0=RS_20._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 21 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col0 Select Operator [SEL_15] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_162] (rows=18262 width=1119) + Filter Operator [FIL_161] (rows=18262 width=1119) predicate:((d_year = 1999) and (d_moy = 3) and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 18 [SIMPLE_EDGE] @@ -422,7 +422,7 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_12] (rows=575995635 width=88) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_161] (rows=575995635 width=88) + Filter Operator [FIL_160] (rows=575995635 width=88) predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_item_sk is not null) TableScan [TS_10] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] diff --git a/ql/src/test/results/clientpositive/perf/query4.q.out b/ql/src/test/results/clientpositive/perf/query4.q.out index 1b2048649a..5f41b4a68f 100644 --- a/ql/src/test/results/clientpositive/perf/query4.q.out +++ b/ql/src/test/results/clientpositive/perf/query4.q.out @@ -217,912 +217,324 @@ POSTHOOK: type: QUERY Plan optimized by CBO. Vertex dependency in root stage -Reducer 10 <- Reducer 9 (SIMPLE_EDGE), Union 11 (CONTAINS) -Reducer 12 <- Map 1 (SIMPLE_EDGE), Map 28 (SIMPLE_EDGE) -Reducer 13 <- Map 65 (SIMPLE_EDGE), Reducer 12 (SIMPLE_EDGE) -Reducer 14 <- Reducer 13 (SIMPLE_EDGE), Union 15 (CONTAINS) -Reducer 16 <- Map 1 (SIMPLE_EDGE), Map 28 (SIMPLE_EDGE) -Reducer 17 <- Map 65 (SIMPLE_EDGE), Reducer 16 (SIMPLE_EDGE) -Reducer 18 <- Reducer 17 (SIMPLE_EDGE), Union 19 (CONTAINS) -Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 28 (SIMPLE_EDGE) -Reducer 20 <- Map 1 (SIMPLE_EDGE), Map 28 (SIMPLE_EDGE) -Reducer 21 <- Map 65 (SIMPLE_EDGE), Reducer 20 (SIMPLE_EDGE) -Reducer 22 <- Reducer 21 (SIMPLE_EDGE), Union 23 (CONTAINS) -Reducer 24 <- Map 1 (SIMPLE_EDGE), Map 28 (SIMPLE_EDGE) -Reducer 25 <- Map 65 (SIMPLE_EDGE), Reducer 24 (SIMPLE_EDGE) -Reducer 26 <- Reducer 25 (SIMPLE_EDGE), Union 27 (CONTAINS) -Reducer 29 <- Map 28 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE) -Reducer 3 <- Map 65 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE) -Reducer 30 <- Map 65 (SIMPLE_EDGE), Reducer 29 (SIMPLE_EDGE) -Reducer 31 <- Reducer 30 (SIMPLE_EDGE), Union 5 (CONTAINS) -Reducer 32 <- Map 28 (SIMPLE_EDGE), Map 67 (SIMPLE_EDGE) -Reducer 33 <- Map 65 (SIMPLE_EDGE), Reducer 32 (SIMPLE_EDGE) -Reducer 34 <- Reducer 33 (SIMPLE_EDGE), Union 5 (CONTAINS) -Reducer 35 <- Map 28 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE) -Reducer 36 <- Map 65 (SIMPLE_EDGE), Reducer 35 (SIMPLE_EDGE) -Reducer 37 <- Reducer 36 (SIMPLE_EDGE), Union 11 (CONTAINS) -Reducer 38 <- Map 28 (SIMPLE_EDGE), Map 67 (SIMPLE_EDGE) -Reducer 39 <- Map 65 (SIMPLE_EDGE), Reducer 38 (SIMPLE_EDGE) -Reducer 4 <- Reducer 3 (SIMPLE_EDGE), Union 5 (CONTAINS) -Reducer 40 <- Reducer 39 (SIMPLE_EDGE), Union 11 (CONTAINS) -Reducer 41 <- Map 28 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE) -Reducer 42 <- Map 65 (SIMPLE_EDGE), Reducer 41 (SIMPLE_EDGE) -Reducer 43 <- Reducer 42 (SIMPLE_EDGE), Union 15 (CONTAINS) -Reducer 44 <- Map 28 (SIMPLE_EDGE), Map 67 (SIMPLE_EDGE) -Reducer 45 <- Map 65 (SIMPLE_EDGE), Reducer 44 (SIMPLE_EDGE) -Reducer 46 <- Reducer 45 (SIMPLE_EDGE), Union 15 (CONTAINS) -Reducer 47 <- Map 28 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE) -Reducer 48 <- Map 65 (SIMPLE_EDGE), Reducer 47 (SIMPLE_EDGE) -Reducer 49 <- Reducer 48 (SIMPLE_EDGE), Union 19 (CONTAINS) -Reducer 50 <- Map 28 (SIMPLE_EDGE), Map 67 (SIMPLE_EDGE) -Reducer 51 <- Map 65 (SIMPLE_EDGE), Reducer 50 (SIMPLE_EDGE) -Reducer 52 <- Reducer 51 (SIMPLE_EDGE), Union 19 (CONTAINS) -Reducer 53 <- Map 28 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE) -Reducer 54 <- Map 65 (SIMPLE_EDGE), Reducer 53 (SIMPLE_EDGE) -Reducer 55 <- Reducer 54 (SIMPLE_EDGE), Union 23 (CONTAINS) -Reducer 56 <- Map 28 (SIMPLE_EDGE), Map 67 (SIMPLE_EDGE) -Reducer 57 <- Map 65 (SIMPLE_EDGE), Reducer 56 (SIMPLE_EDGE) -Reducer 58 <- Reducer 57 (SIMPLE_EDGE), Union 23 (CONTAINS) -Reducer 59 <- Map 28 (SIMPLE_EDGE), Map 66 (SIMPLE_EDGE) -Reducer 6 <- Union 11 (SIMPLE_EDGE), Union 15 (SIMPLE_EDGE), Union 19 (SIMPLE_EDGE), Union 23 (SIMPLE_EDGE), Union 27 (SIMPLE_EDGE), Union 5 (SIMPLE_EDGE) -Reducer 60 <- Map 65 (SIMPLE_EDGE), Reducer 59 (SIMPLE_EDGE) -Reducer 61 <- Reducer 60 (SIMPLE_EDGE), Union 27 (CONTAINS) -Reducer 62 <- Map 28 (SIMPLE_EDGE), Map 67 (SIMPLE_EDGE) -Reducer 63 <- Map 65 (SIMPLE_EDGE), Reducer 62 (SIMPLE_EDGE) -Reducer 64 <- Reducer 63 (SIMPLE_EDGE), Union 27 (CONTAINS) -Reducer 7 <- Reducer 6 (SIMPLE_EDGE) -Reducer 8 <- Map 1 (SIMPLE_EDGE), Map 28 (SIMPLE_EDGE) -Reducer 9 <- Map 65 (SIMPLE_EDGE), Reducer 8 (SIMPLE_EDGE) +Reducer 11 <- Map 10 (SIMPLE_EDGE), Map 24 (SIMPLE_EDGE) +Reducer 12 <- Map 23 (SIMPLE_EDGE), Reducer 11 (SIMPLE_EDGE) +Reducer 13 <- Reducer 12 (SIMPLE_EDGE) +Reducer 14 <- Map 10 (SIMPLE_EDGE), Map 25 (SIMPLE_EDGE) +Reducer 15 <- Map 23 (SIMPLE_EDGE), Reducer 14 (SIMPLE_EDGE) +Reducer 16 <- Reducer 15 (SIMPLE_EDGE) +Reducer 17 <- Map 10 (SIMPLE_EDGE), Map 25 (SIMPLE_EDGE) +Reducer 18 <- Map 23 (SIMPLE_EDGE), Reducer 17 (SIMPLE_EDGE) +Reducer 19 <- Reducer 18 (SIMPLE_EDGE) +Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE) +Reducer 20 <- Map 10 (SIMPLE_EDGE), Map 24 (SIMPLE_EDGE) +Reducer 21 <- Map 23 (SIMPLE_EDGE), Reducer 20 (SIMPLE_EDGE) +Reducer 22 <- Reducer 21 (SIMPLE_EDGE) +Reducer 3 <- Map 23 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE) +Reducer 4 <- Reducer 3 (SIMPLE_EDGE) +Reducer 5 <- Reducer 13 (SIMPLE_EDGE), Reducer 16 (SIMPLE_EDGE), Reducer 19 (SIMPLE_EDGE), Reducer 22 (SIMPLE_EDGE), Reducer 4 (SIMPLE_EDGE), Reducer 9 (SIMPLE_EDGE) +Reducer 6 <- Reducer 5 (SIMPLE_EDGE) +Reducer 7 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE) +Reducer 8 <- Map 23 (SIMPLE_EDGE), Reducer 7 (SIMPLE_EDGE) +Reducer 9 <- Reducer 8 (SIMPLE_EDGE) Stage-0 Fetch Operator limit:100 Stage-1 - Reducer 7 - File Output Operator [FS_412] - Limit [LIM_411] (rows=100 width=88) + Reducer 6 + File Output Operator [FS_142] + Limit [LIM_141] (rows=100 width=88) Number of rows:100 - Select Operator [SEL_410] (rows=479156402 width=88) + Select Operator [SEL_140] (rows=479156399 width=88) Output:["_col0"] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_409] - Select Operator [SEL_408] (rows=479156402 width=88) + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_139] + Select Operator [SEL_138] (rows=479156399 width=88) Output:["_col0"] - Filter Operator [FIL_406] (rows=479156402 width=88) - predicate:(CASE WHEN ((_col1 > 0)) THEN (CASE WHEN ((_col3 > 0)) THEN (((_col9 / _col3) > (_col12 / _col1))) ELSE ((null > (_col12 / _col1))) END) ELSE (CASE WHEN ((_col3 > 0)) THEN (((_col9 / _col3) > null)) ELSE (null) END) END and CASE WHEN ((_col5 > 0)) THEN (CASE WHEN ((_col3 > 0)) THEN (((_col9 / _col3) > (_col7 / _col5))) ELSE ((null > (_col7 / _col5))) END) ELSE (CASE WHEN ((_col3 > 0)) THEN (((_col9 / _col3) > null)) ELSE (null) END) END) - Merge Join Operator [MERGEJOIN_866] (rows=1916625609 width=88) - Conds:Union 5._col0=Union 11._col0(Inner),Union 5._col0=Union 15._col0(Inner),Union 5._col0=Union 19._col0(Inner),Union 5._col0=Union 23._col0(Inner),Union 5._col0=Union 27._col0(Inner),Output:["_col1","_col3","_col5","_col7","_col9","_col11","_col12"] - <-Union 11 [SIMPLE_EDGE] - <-Reducer 10 [CONTAINS] - Reduce Output Operator [RS_400] - PartitionCols:_col0 - Select Operator [SEL_87] (rows=1 width=105) - Output:["_col0","_col1"] - Group By Operator [GBY_86] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_85] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_84] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_82] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_837] (rows=1 width=105) - Conds:RS_79._col1=RS_80._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_80] - PartitionCols:_col0 - Select Operator [SEL_75] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_784] (rows=1 width=860) - predicate:false - TableScan [TS_6] (rows=80000000 width=860) - default@customer,customer,Tbl:COMPLETE,Col:NONE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_79] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_836] (rows=1 width=96) - Conds:RS_76._col0=RS_77._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_77] - PartitionCols:_col0 - Select Operator [SEL_72] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_783] (rows=1 width=1119) - predicate:false - TableScan [TS_3] (rows=73049 width=1119) - default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year"] - <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_76] - PartitionCols:_col0 - Select Operator [SEL_69] (rows=1 width=88) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_782] (rows=1 width=88) - predicate:false - TableScan [TS_0] (rows=575995635 width=88) - default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] - <-Reducer 37 [CONTAINS] - Reduce Output Operator [RS_400] - PartitionCols:_col0 - Select Operator [SEL_109] (rows=58077952 width=135) - Output:["_col0","_col1"] - Filter Operator [FIL_108] (rows=58077952 width=135) - predicate:(_col7 > 0) - Select Operator [SEL_827] (rows=174233858 width=135) - Output:["_col0","_col7"] - Group By Operator [GBY_107] (rows=174233858 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 36 [SIMPLE_EDGE] - SHUFFLE [RS_106] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_105] (rows=348467716 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Select Operator [SEL_103] (rows=348467716 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_839] (rows=348467716 width=135) - Conds:RS_100._col1=RS_101._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_101] - PartitionCols:_col0 - Select Operator [SEL_96] (rows=80000000 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_787] (rows=80000000 width=860) - predicate:(c_customer_sk is not null and c_customer_id is not null) - Please refer to the previous TableScan [TS_6] - <-Reducer 35 [SIMPLE_EDGE] - SHUFFLE [RS_100] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_838] (rows=316788826 width=135) - Conds:RS_97._col0=RS_98._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_98] - PartitionCols:_col0 - Select Operator [SEL_93] (rows=36524 width=1119) - Output:["_col0"] - Filter Operator [FIL_786] (rows=36524 width=1119) - predicate:((d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 66 [SIMPLE_EDGE] - SHUFFLE [RS_97] - PartitionCols:_col0 - Select Operator [SEL_90] (rows=287989836 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_785] (rows=287989836 width=135) - predicate:(cs_bill_customer_sk is not null and cs_sold_date_sk is not null) - TableScan [TS_22] (rows=287989836 width=135) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] - <-Reducer 40 [CONTAINS] - Reduce Output Operator [RS_400] - PartitionCols:_col0 - Select Operator [SEL_132] (rows=1 width=162) - Output:["_col0","_col1"] - Group By Operator [GBY_131] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 39 [SIMPLE_EDGE] - SHUFFLE [RS_130] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_129] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_127] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_841] (rows=1 width=162) - Conds:RS_124._col1=RS_125._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_125] - PartitionCols:_col0 - Select Operator [SEL_120] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_790] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 38 [SIMPLE_EDGE] - SHUFFLE [RS_124] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_840] (rows=1 width=148) - Conds:RS_121._col0=RS_122._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_122] - PartitionCols:_col0 - Select Operator [SEL_117] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_789] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 67 [SIMPLE_EDGE] - SHUFFLE [RS_121] - PartitionCols:_col0 - Select Operator [SEL_114] (rows=1 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_788] (rows=1 width=135) - predicate:false - TableScan [TS_45] (rows=144002668 width=135) - default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] - <-Union 15 [SIMPLE_EDGE] - <-Reducer 14 [CONTAINS] - Reduce Output Operator [RS_401] - PartitionCols:_col0 - Select Operator [SEL_154] (rows=1 width=105) - Output:["_col0","_col1"] - Group By Operator [GBY_153] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_152] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_151] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_149] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_843] (rows=1 width=105) - Conds:RS_146._col1=RS_147._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_147] - PartitionCols:_col0 - Select Operator [SEL_142] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_793] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_146] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_842] (rows=1 width=96) - Conds:RS_143._col0=RS_144._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_144] - PartitionCols:_col0 - Select Operator [SEL_139] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_792] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_143] - PartitionCols:_col0 - Select Operator [SEL_136] (rows=1 width=88) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_791] (rows=1 width=88) - predicate:false - Please refer to the previous TableScan [TS_0] - <-Reducer 43 [CONTAINS] - Reduce Output Operator [RS_401] - PartitionCols:_col0 - Select Operator [SEL_175] (rows=1 width=162) - Output:["_col0","_col1"] - Group By Operator [GBY_174] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 42 [SIMPLE_EDGE] - SHUFFLE [RS_173] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_172] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_170] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_845] (rows=1 width=162) - Conds:RS_167._col1=RS_168._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_168] - PartitionCols:_col0 - Select Operator [SEL_163] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_796] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 41 [SIMPLE_EDGE] - SHUFFLE [RS_167] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_844] (rows=1 width=148) - Conds:RS_164._col0=RS_165._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_165] - PartitionCols:_col0 - Select Operator [SEL_160] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_795] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 66 [SIMPLE_EDGE] - SHUFFLE [RS_164] - PartitionCols:_col0 - Select Operator [SEL_157] (rows=1 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_794] (rows=1 width=135) - predicate:false - Please refer to the previous TableScan [TS_22] - <-Reducer 46 [CONTAINS] - Reduce Output Operator [RS_401] - PartitionCols:_col0 - Select Operator [SEL_199] (rows=29040539 width=135) - Output:["_col0","_col1"] - Filter Operator [FIL_198] (rows=29040539 width=135) - predicate:(_col7 > 0) - Select Operator [SEL_828] (rows=87121617 width=135) - Output:["_col0","_col7"] - Group By Operator [GBY_197] (rows=87121617 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 45 [SIMPLE_EDGE] - SHUFFLE [RS_196] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_195] (rows=174243235 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Select Operator [SEL_193] (rows=174243235 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_847] (rows=174243235 width=135) - Conds:RS_190._col1=RS_191._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_191] - PartitionCols:_col0 - Select Operator [SEL_186] (rows=80000000 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_799] (rows=80000000 width=860) - predicate:(c_customer_sk is not null and c_customer_id is not null) - Please refer to the previous TableScan [TS_6] - <-Reducer 44 [SIMPLE_EDGE] - SHUFFLE [RS_190] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_846] (rows=158402938 width=135) - Conds:RS_187._col0=RS_188._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_188] - PartitionCols:_col0 - Select Operator [SEL_183] (rows=36524 width=1119) - Output:["_col0"] - Filter Operator [FIL_798] (rows=36524 width=1119) - predicate:((d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 67 [SIMPLE_EDGE] - SHUFFLE [RS_187] - PartitionCols:_col0 - Select Operator [SEL_180] (rows=144002668 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_797] (rows=144002668 width=135) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) - Please refer to the previous TableScan [TS_45] - <-Union 19 [SIMPLE_EDGE] - <-Reducer 18 [CONTAINS] - Reduce Output Operator [RS_402] - PartitionCols:_col0 - Select Operator [SEL_221] (rows=1 width=105) - Output:["_col0","_col1"] - Group By Operator [GBY_220] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 17 [SIMPLE_EDGE] - SHUFFLE [RS_219] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_218] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_216] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_849] (rows=1 width=105) - Conds:RS_213._col1=RS_214._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_214] - PartitionCols:_col0 - Select Operator [SEL_209] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_802] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_213] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_848] (rows=1 width=96) - Conds:RS_210._col0=RS_211._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_211] - PartitionCols:_col0 - Select Operator [SEL_206] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_801] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_210] - PartitionCols:_col0 - Select Operator [SEL_203] (rows=1 width=88) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_800] (rows=1 width=88) - predicate:false - Please refer to the previous TableScan [TS_0] - <-Reducer 49 [CONTAINS] - Reduce Output Operator [RS_402] - PartitionCols:_col0 - Select Operator [SEL_242] (rows=1 width=162) - Output:["_col0","_col1"] - Group By Operator [GBY_241] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 48 [SIMPLE_EDGE] - SHUFFLE [RS_240] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_239] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_237] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_851] (rows=1 width=162) - Conds:RS_234._col1=RS_235._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_235] - PartitionCols:_col0 - Select Operator [SEL_230] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_805] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 47 [SIMPLE_EDGE] - SHUFFLE [RS_234] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_850] (rows=1 width=148) - Conds:RS_231._col0=RS_232._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_232] - PartitionCols:_col0 - Select Operator [SEL_227] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_804] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 66 [SIMPLE_EDGE] - SHUFFLE [RS_231] - PartitionCols:_col0 - Select Operator [SEL_224] (rows=1 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_803] (rows=1 width=135) - predicate:false - Please refer to the previous TableScan [TS_22] - <-Reducer 52 [CONTAINS] - Reduce Output Operator [RS_402] - PartitionCols:_col0 - Select Operator [SEL_265] (rows=87121617 width=135) - Output:["_col0","_col1"] - Group By Operator [GBY_264] (rows=87121617 width=135) + Filter Operator [FIL_136] (rows=479156399 width=88) + predicate:(CASE WHEN ((_col15 > 0)) THEN (CASE WHEN ((_col23 > 0)) THEN (((_col39 / _col23) > (_col47 / _col15))) ELSE ((null > (_col47 / _col15))) END) ELSE (CASE WHEN ((_col23 > 0)) THEN (((_col39 / _col23) > null)) ELSE (null) END) END and CASE WHEN ((_col31 > 0)) THEN (CASE WHEN ((_col23 > 0)) THEN (((_col39 / _col23) > (_col7 / _col31))) ELSE ((null > (_col7 / _col31))) END) ELSE (CASE WHEN ((_col23 > 0)) THEN (((_col39 / _col23) > null)) ELSE (null) END) END) + Merge Join Operator [MERGEJOIN_296] (rows=1916625598 width=88) + Conds:RS_129._col0=RS_130._col0(Inner),RS_130._col0=RS_131._col0(Inner),RS_130._col0=RS_132._col0(Inner),RS_130._col0=RS_133._col0(Inner),RS_130._col0=RS_134._col0(Inner),Output:["_col7","_col15","_col23","_col31","_col39","_col43","_col47"] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_130] + PartitionCols:_col0 + Filter Operator [FIL_41] (rows=116159124 width=88) + predicate:(_col7 > 0) + Select Operator [SEL_283] (rows=348477374 width=88) + Output:["_col0","_col7"] + Group By Operator [GBY_40] (rows=348477374 width=88) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 51 [SIMPLE_EDGE] - SHUFFLE [RS_263] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_39] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_262] (rows=174243235 width=135) + Group By Operator [GBY_38] (rows=696954748 width=88) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Select Operator [SEL_260] (rows=174243235 width=135) + Select Operator [SEL_36] (rows=696954748 width=88) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_853] (rows=174243235 width=135) - Conds:RS_257._col1=RS_258._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_258] + Merge Join Operator [MERGEJOIN_287] (rows=696954748 width=88) + Conds:RS_33._col1=RS_34._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] + <-Map 23 [SIMPLE_EDGE] + SHUFFLE [RS_34] PartitionCols:_col0 - Select Operator [SEL_253] (rows=80000000 width=860) + Select Operator [SEL_29] (rows=80000000 width=860) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_808] (rows=80000000 width=860) + Filter Operator [FIL_268] (rows=80000000 width=860) predicate:(c_customer_sk is not null and c_customer_id is not null) - Please refer to the previous TableScan [TS_6] - <-Reducer 50 [SIMPLE_EDGE] - SHUFFLE [RS_257] + TableScan [TS_6] (rows=80000000 width=860) + default@customer,customer,Tbl:COMPLETE,Col:NONE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_33] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_852] (rows=158402938 width=135) - Conds:RS_254._col0=RS_255._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_255] + Merge Join Operator [MERGEJOIN_286] (rows=633595212 width=88) + Conds:RS_30._col0=RS_31._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_31] PartitionCols:_col0 - Select Operator [SEL_250] (rows=36524 width=1119) + Select Operator [SEL_26] (rows=36524 width=1119) Output:["_col0"] - Filter Operator [FIL_807] (rows=36524 width=1119) - predicate:((d_year = 2002) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 67 [SIMPLE_EDGE] - SHUFFLE [RS_254] - PartitionCols:_col0 - Select Operator [SEL_247] (rows=144002668 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_806] (rows=144002668 width=135) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) - Please refer to the previous TableScan [TS_45] - <-Union 23 [SIMPLE_EDGE] - <-Reducer 22 [CONTAINS] - Reduce Output Operator [RS_403] - PartitionCols:_col0 - Select Operator [SEL_287] (rows=1 width=105) - Output:["_col0","_col1"] - Group By Operator [GBY_286] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_285] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_284] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_282] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_855] (rows=1 width=105) - Conds:RS_279._col1=RS_280._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_280] - PartitionCols:_col0 - Select Operator [SEL_275] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_811] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_279] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_854] (rows=1 width=96) - Conds:RS_276._col0=RS_277._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_277] - PartitionCols:_col0 - Select Operator [SEL_272] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_810] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_276] + Filter Operator [FIL_267] (rows=36524 width=1119) + predicate:((d_year = 2001) and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=1119) + default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year"] + <-Map 24 [SIMPLE_EDGE] + SHUFFLE [RS_30] PartitionCols:_col0 - Select Operator [SEL_269] (rows=1 width=88) + Select Operator [SEL_23] (rows=575995635 width=88) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_809] (rows=1 width=88) - predicate:false - Please refer to the previous TableScan [TS_0] - <-Reducer 55 [CONTAINS] - Reduce Output Operator [RS_403] - PartitionCols:_col0 - Select Operator [SEL_308] (rows=174233858 width=135) - Output:["_col0","_col1"] - Group By Operator [GBY_307] (rows=174233858 width=135) + Filter Operator [FIL_266] (rows=575995635 width=88) + predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) + TableScan [TS_21] (rows=575995635 width=88) + default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_131] + PartitionCols:_col0 + Filter Operator [FIL_63] (rows=58077952 width=135) + predicate:(_col7 > 0) + Select Operator [SEL_281] (rows=174233858 width=135) + Output:["_col0","_col7"] + Group By Operator [GBY_62] (rows=174233858 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 54 [SIMPLE_EDGE] - SHUFFLE [RS_306] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_61] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_305] (rows=348467716 width=135) + Group By Operator [GBY_60] (rows=348467716 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Select Operator [SEL_303] (rows=348467716 width=135) + Select Operator [SEL_58] (rows=348467716 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_857] (rows=348467716 width=135) - Conds:RS_300._col1=RS_301._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_301] + Merge Join Operator [MERGEJOIN_289] (rows=348467716 width=135) + Conds:RS_55._col1=RS_56._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] + <-Map 23 [SIMPLE_EDGE] + SHUFFLE [RS_56] PartitionCols:_col0 - Select Operator [SEL_296] (rows=80000000 width=860) + Select Operator [SEL_51] (rows=80000000 width=860) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_814] (rows=80000000 width=860) + Filter Operator [FIL_271] (rows=80000000 width=860) predicate:(c_customer_sk is not null and c_customer_id is not null) Please refer to the previous TableScan [TS_6] - <-Reducer 53 [SIMPLE_EDGE] - SHUFFLE [RS_300] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_55] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_856] (rows=316788826 width=135) - Conds:RS_297._col0=RS_298._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_298] + Merge Join Operator [MERGEJOIN_288] (rows=316788826 width=135) + Conds:RS_52._col0=RS_53._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_53] PartitionCols:_col0 - Select Operator [SEL_293] (rows=36524 width=1119) + Select Operator [SEL_48] (rows=36524 width=1119) Output:["_col0"] - Filter Operator [FIL_813] (rows=36524 width=1119) - predicate:((d_year = 2002) and d_date_sk is not null) + Filter Operator [FIL_270] (rows=36524 width=1119) + predicate:((d_year = 2001) and d_date_sk is not null) Please refer to the previous TableScan [TS_3] - <-Map 66 [SIMPLE_EDGE] - SHUFFLE [RS_297] + <-Map 25 [SIMPLE_EDGE] + SHUFFLE [RS_52] PartitionCols:_col0 - Select Operator [SEL_290] (rows=287989836 width=135) + Select Operator [SEL_45] (rows=287989836 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_812] (rows=287989836 width=135) + Filter Operator [FIL_269] (rows=287989836 width=135) predicate:(cs_bill_customer_sk is not null and cs_sold_date_sk is not null) - Please refer to the previous TableScan [TS_22] - <-Reducer 58 [CONTAINS] - Reduce Output Operator [RS_403] - PartitionCols:_col0 - Select Operator [SEL_331] (rows=1 width=162) - Output:["_col0","_col1"] - Group By Operator [GBY_330] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 57 [SIMPLE_EDGE] - SHUFFLE [RS_329] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_328] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_326] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_859] (rows=1 width=162) - Conds:RS_323._col1=RS_324._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_324] - PartitionCols:_col0 - Select Operator [SEL_319] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_817] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 56 [SIMPLE_EDGE] - SHUFFLE [RS_323] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_858] (rows=1 width=148) - Conds:RS_320._col0=RS_321._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_321] - PartitionCols:_col0 - Select Operator [SEL_316] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_816] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 67 [SIMPLE_EDGE] - SHUFFLE [RS_320] - PartitionCols:_col0 - Select Operator [SEL_313] (rows=1 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_815] (rows=1 width=135) - predicate:false - Please refer to the previous TableScan [TS_45] - <-Union 27 [SIMPLE_EDGE] - <-Reducer 26 [CONTAINS] - Reduce Output Operator [RS_404] - PartitionCols:_col0 - Select Operator [SEL_353] (rows=348477374 width=88) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_352] (rows=348477374 width=88) + TableScan [TS_43] (rows=287989836 width=135) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_133] + PartitionCols:_col0 + Select Operator [SEL_107] (rows=174233858 width=135) + Output:["_col0","_col7"] + Group By Operator [GBY_106] (rows=174233858 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_105] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_104] (rows=348467716 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Select Operator [SEL_102] (rows=348467716 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_293] (rows=348467716 width=135) + Conds:RS_99._col1=RS_100._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] + <-Map 23 [SIMPLE_EDGE] + SHUFFLE [RS_100] + PartitionCols:_col0 + Select Operator [SEL_95] (rows=80000000 width=860) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_277] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 17 [SIMPLE_EDGE] + SHUFFLE [RS_99] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_292] (rows=316788826 width=135) + Conds:RS_96._col0=RS_97._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_97] + PartitionCols:_col0 + Select Operator [SEL_92] (rows=36524 width=1119) + Output:["_col0"] + Filter Operator [FIL_276] (rows=36524 width=1119) + predicate:((d_year = 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 25 [SIMPLE_EDGE] + SHUFFLE [RS_96] + PartitionCols:_col0 + Select Operator [SEL_89] (rows=287989836 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_275] (rows=287989836 width=135) + predicate:(cs_bill_customer_sk is not null and cs_sold_date_sk is not null) + Please refer to the previous TableScan [TS_43] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_134] + PartitionCols:_col0 + Select Operator [SEL_128] (rows=348477374 width=88) + Output:["_col0","_col3","_col7"] + Group By Operator [GBY_127] (rows=348477374 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 21 [SIMPLE_EDGE] + SHUFFLE [RS_126] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_125] (rows=696954748 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Select Operator [SEL_123] (rows=696954748 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_295] (rows=696954748 width=88) + Conds:RS_120._col1=RS_121._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] + <-Map 23 [SIMPLE_EDGE] + SHUFFLE [RS_121] + PartitionCols:_col0 + Select Operator [SEL_116] (rows=80000000 width=860) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_280] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_120] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_294] (rows=633595212 width=88) + Conds:RS_117._col0=RS_118._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_118] + PartitionCols:_col0 + Select Operator [SEL_113] (rows=36524 width=1119) + Output:["_col0"] + Filter Operator [FIL_279] (rows=36524 width=1119) + predicate:((d_year = 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 24 [SIMPLE_EDGE] + SHUFFLE [RS_117] + PartitionCols:_col0 + Select Operator [SEL_110] (rows=575995635 width=88) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_278] (rows=575995635 width=88) + predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) + Please refer to the previous TableScan [TS_21] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_129] + PartitionCols:_col0 + Select Operator [SEL_20] (rows=87121617 width=135) + Output:["_col0","_col7"] + Group By Operator [GBY_19] (rows=87121617 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_17] (rows=174243235 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Select Operator [SEL_15] (rows=174243235 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_285] (rows=174243235 width=135) + Conds:RS_12._col1=RS_13._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] + <-Map 23 [SIMPLE_EDGE] + SHUFFLE [RS_13] + PartitionCols:_col0 + Select Operator [SEL_8] (rows=80000000 width=860) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_265] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_284] (rows=158402938 width=135) + Conds:RS_9._col0=RS_10._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_10] + PartitionCols:_col0 + Select Operator [SEL_5] (rows=36524 width=1119) + Output:["_col0"] + Filter Operator [FIL_264] (rows=36524 width=1119) + predicate:((d_year = 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 1 [SIMPLE_EDGE] + SHUFFLE [RS_9] + PartitionCols:_col0 + Select Operator [SEL_2] (rows=144002668 width=135) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_263] (rows=144002668 width=135) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) + TableScan [TS_0] (rows=144002668 width=135) + default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_132] + PartitionCols:_col0 + Filter Operator [FIL_85] (rows=29040539 width=135) + predicate:(_col7 > 0) + Select Operator [SEL_282] (rows=87121617 width=135) + Output:["_col0","_col7"] + Group By Operator [GBY_84] (rows=87121617 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 25 [SIMPLE_EDGE] - SHUFFLE [RS_351] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_83] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_350] (rows=696954748 width=88) + Group By Operator [GBY_82] (rows=174243235 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Select Operator [SEL_348] (rows=696954748 width=88) + Select Operator [SEL_80] (rows=174243235 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_861] (rows=696954748 width=88) - Conds:RS_345._col1=RS_346._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_346] + Merge Join Operator [MERGEJOIN_291] (rows=174243235 width=135) + Conds:RS_77._col1=RS_78._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] + <-Map 23 [SIMPLE_EDGE] + SHUFFLE [RS_78] PartitionCols:_col0 - Select Operator [SEL_341] (rows=80000000 width=860) + Select Operator [SEL_73] (rows=80000000 width=860) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_820] (rows=80000000 width=860) + Filter Operator [FIL_274] (rows=80000000 width=860) predicate:(c_customer_sk is not null and c_customer_id is not null) Please refer to the previous TableScan [TS_6] - <-Reducer 24 [SIMPLE_EDGE] - SHUFFLE [RS_345] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_77] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_860] (rows=633595212 width=88) - Conds:RS_342._col0=RS_343._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_343] + Merge Join Operator [MERGEJOIN_290] (rows=158402938 width=135) + Conds:RS_74._col0=RS_75._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_75] PartitionCols:_col0 - Select Operator [SEL_338] (rows=36524 width=1119) + Select Operator [SEL_70] (rows=36524 width=1119) Output:["_col0"] - Filter Operator [FIL_819] (rows=36524 width=1119) - predicate:((d_year = 2002) and d_date_sk is not null) + Filter Operator [FIL_273] (rows=36524 width=1119) + predicate:((d_year = 2001) and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_342] + SHUFFLE [RS_74] PartitionCols:_col0 - Select Operator [SEL_335] (rows=575995635 width=88) + Select Operator [SEL_67] (rows=144002668 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_818] (rows=575995635 width=88) - predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) + Filter Operator [FIL_272] (rows=144002668 width=135) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) Please refer to the previous TableScan [TS_0] - <-Reducer 61 [CONTAINS] - Reduce Output Operator [RS_404] - PartitionCols:_col0 - Select Operator [SEL_374] (rows=1 width=162) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_373] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 60 [SIMPLE_EDGE] - SHUFFLE [RS_372] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_371] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_369] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_863] (rows=1 width=162) - Conds:RS_366._col1=RS_367._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_367] - PartitionCols:_col0 - Select Operator [SEL_362] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_823] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 59 [SIMPLE_EDGE] - SHUFFLE [RS_366] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_862] (rows=1 width=148) - Conds:RS_363._col0=RS_364._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_364] - PartitionCols:_col0 - Select Operator [SEL_359] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_822] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 66 [SIMPLE_EDGE] - SHUFFLE [RS_363] - PartitionCols:_col0 - Select Operator [SEL_356] (rows=1 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_821] (rows=1 width=135) - predicate:false - Please refer to the previous TableScan [TS_22] - <-Reducer 64 [CONTAINS] - Reduce Output Operator [RS_404] - PartitionCols:_col0 - Select Operator [SEL_397] (rows=1 width=162) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_396] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 63 [SIMPLE_EDGE] - SHUFFLE [RS_395] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_394] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_392] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_865] (rows=1 width=162) - Conds:RS_389._col1=RS_390._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_390] - PartitionCols:_col0 - Select Operator [SEL_385] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_826] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 62 [SIMPLE_EDGE] - SHUFFLE [RS_389] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_864] (rows=1 width=148) - Conds:RS_386._col0=RS_387._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_387] - PartitionCols:_col0 - Select Operator [SEL_382] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_825] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 67 [SIMPLE_EDGE] - SHUFFLE [RS_386] - PartitionCols:_col0 - Select Operator [SEL_379] (rows=1 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_824] (rows=1 width=135) - predicate:false - Please refer to the previous TableScan [TS_45] - <-Union 5 [SIMPLE_EDGE] - <-Reducer 31 [CONTAINS] - Reduce Output Operator [RS_399] - PartitionCols:_col0 - Select Operator [SEL_42] (rows=1 width=162) - Output:["_col0","_col1"] - Group By Operator [GBY_41] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 30 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_39] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_37] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_833] (rows=1 width=162) - Conds:RS_34._col1=RS_35._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_35] - PartitionCols:_col0 - Select Operator [SEL_30] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_778] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 29 [SIMPLE_EDGE] - SHUFFLE [RS_34] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_832] (rows=1 width=148) - Conds:RS_31._col0=RS_32._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col0 - Select Operator [SEL_27] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_777] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 66 [SIMPLE_EDGE] - SHUFFLE [RS_31] - PartitionCols:_col0 - Select Operator [SEL_24] (rows=1 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_776] (rows=1 width=135) - predicate:false - Please refer to the previous TableScan [TS_22] - <-Reducer 34 [CONTAINS] - Reduce Output Operator [RS_399] - PartitionCols:_col0 - Select Operator [SEL_65] (rows=1 width=162) - Output:["_col0","_col1"] - Group By Operator [GBY_64] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 - <-Reducer 33 [SIMPLE_EDGE] - SHUFFLE [RS_63] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Group By Operator [GBY_62] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col8)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Operator [SEL_60] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_835] (rows=1 width=162) - Conds:RS_57._col1=RS_58._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_58] - PartitionCols:_col0 - Select Operator [SEL_53] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_781] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 32 [SIMPLE_EDGE] - SHUFFLE [RS_57] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_834] (rows=1 width=148) - Conds:RS_54._col0=RS_55._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col7"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_55] - PartitionCols:_col0 - Select Operator [SEL_50] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_780] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 67 [SIMPLE_EDGE] - SHUFFLE [RS_54] - PartitionCols:_col0 - Select Operator [SEL_47] (rows=1 width=135) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_779] (rows=1 width=135) - predicate:false - Please refer to the previous TableScan [TS_45] - <-Reducer 4 [CONTAINS] - Reduce Output Operator [RS_399] - PartitionCols:_col0 - Select Operator [SEL_21] (rows=116159124 width=88) - Output:["_col0","_col1"] - Filter Operator [FIL_20] (rows=116159124 width=88) - predicate:(_col7 > 0) - Select Operator [SEL_829] (rows=348477374 width=88) - Output:["_col0","_col7"] - Group By Operator [GBY_19] (rows=348477374 width=88) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_17] (rows=696954748 width=88) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col7)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Select Operator [SEL_15] (rows=696954748 width=88) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_831] (rows=696954748 width=88) - Conds:RS_12._col1=RS_13._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - <-Map 65 [SIMPLE_EDGE] - SHUFFLE [RS_13] - PartitionCols:_col0 - Select Operator [SEL_8] (rows=80000000 width=860) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_775] (rows=80000000 width=860) - predicate:(c_customer_sk is not null and c_customer_id is not null) - Please refer to the previous TableScan [TS_6] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_830] (rows=633595212 width=88) - Conds:RS_9._col0=RS_10._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] - <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_10] - PartitionCols:_col0 - Select Operator [SEL_5] (rows=36524 width=1119) - Output:["_col0"] - Filter Operator [FIL_774] (rows=36524 width=1119) - predicate:((d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_9] - PartitionCols:_col0 - Select Operator [SEL_2] (rows=575995635 width=88) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_773] (rows=575995635 width=88) - predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) - Please refer to the previous TableScan [TS_0] diff --git a/ql/src/test/results/clientpositive/perf/query5.q.out b/ql/src/test/results/clientpositive/perf/query5.q.out index a3f2d58fec..f3f122c0ca 100644 --- a/ql/src/test/results/clientpositive/perf/query5.q.out +++ b/ql/src/test/results/clientpositive/perf/query5.q.out @@ -278,22 +278,22 @@ Stage-0 limit:100 Stage-1 Reducer 8 - File Output Operator [FS_93] - Limit [LIM_92] (rows=100 width=110) + File Output Operator [FS_92] + Limit [LIM_91] (rows=100 width=110) Number of rows:100 - Select Operator [SEL_91] (rows=1136898901 width=110) + Select Operator [SEL_90] (rows=1136898901 width=110) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_90] - Select Operator [SEL_89] (rows=1136898901 width=110) + SHUFFLE [RS_89] + Select Operator [SEL_88] (rows=1136898901 width=110) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_88] (rows=1136898901 width=110) + Group By Operator [GBY_87] (rows=1136898901 width=110) Output:["_col0","_col1","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 6 [SIMPLE_EDGE] <-Reducer 13 [CONTAINS] - Reduce Output Operator [RS_87] + Reduce Output Operator [RS_86] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_86] (rows=2273797803 width=110) + Group By Operator [GBY_85] (rows=2273797803 width=110) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0 Select Operator [SEL_49] (rows=191657181 width=132) Output:["_col0","_col1","_col2","_col3","_col4"] @@ -304,28 +304,28 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_46] (rows=383314363 width=132) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col4)","sum(_col3)","sum(_col5)"],keys:_col9 - Merge Join Operator [MERGEJOIN_136] (rows=383314363 width=132) + Merge Join Operator [MERGEJOIN_135] (rows=383314363 width=132) Conds:RS_42._col0=RS_43._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9"] <-Map 21 [SIMPLE_EDGE] SHUFFLE [RS_43] PartitionCols:_col0 Select Operator [SEL_38] (rows=46000 width=460) Output:["_col0","_col1"] - Filter Operator [FIL_126] (rows=46000 width=460) + Filter Operator [FIL_125] (rows=46000 width=460) predicate:cp_catalog_page_sk is not null TableScan [TS_36] (rows=46000 width=460) default@catalog_page,catalog_page,Tbl:COMPLETE,Col:NONE,Output:["cp_catalog_page_sk","cp_catalog_page_id"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_42] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_135] (rows=348467596 width=132) + Merge Join Operator [MERGEJOIN_134] (rows=348467596 width=132) Conds:Union 19._col1=RS_40._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] SHUFFLE [RS_40] PartitionCols:_col0 Select Operator [SEL_35] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_125] (rows=8116 width=1119) + Filter Operator [FIL_124] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-08-18 00:00:00.0 and d_date_sk is not null) TableScan [TS_8] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_date"] @@ -335,7 +335,7 @@ Stage-0 PartitionCols:_col1 Select Operator [SEL_27] (rows=287989836 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_123] (rows=287989836 width=135) + Filter Operator [FIL_122] (rows=287989836 width=135) predicate:(cs_sold_date_sk is not null and cs_catalog_page_sk is not null) TableScan [TS_25] (rows=287989836 width=135) Output:["cs_sold_date_sk","cs_catalog_page_sk","cs_ext_sales_price","cs_net_profit"] @@ -344,87 +344,87 @@ Stage-0 PartitionCols:_col1 Select Operator [SEL_30] (rows=28798881 width=106) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_124] (rows=28798881 width=106) + Filter Operator [FIL_123] (rows=28798881 width=106) predicate:(cr_returned_date_sk is not null and cr_catalog_page_sk is not null) TableScan [TS_28] (rows=28798881 width=106) Output:["cr_returned_date_sk","cr_catalog_page_sk","cr_return_amount","cr_net_loss"] <-Reducer 16 [CONTAINS] - Reduce Output Operator [RS_87] + Reduce Output Operator [RS_86] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_86] (rows=2273797803 width=110) + Group By Operator [GBY_85] (rows=2273797803 width=110) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0 - Select Operator [SEL_83] (rows=182955399 width=135) + Select Operator [SEL_82] (rows=182955399 width=135) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_82] (rows=182955399 width=135) + Group By Operator [GBY_81] (rows=182955399 width=135) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_81] + SHUFFLE [RS_80] PartitionCols:_col0 - Group By Operator [GBY_80] (rows=365910798 width=135) + Group By Operator [GBY_79] (rows=365910798 width=135) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col4)","sum(_col3)","sum(_col5)"],keys:_col9 - Merge Join Operator [MERGEJOIN_138] (rows=365910798 width=135) - Conds:RS_76._col0=RS_77._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9"] + Merge Join Operator [MERGEJOIN_137] (rows=365910798 width=135) + Conds:RS_75._col0=RS_76._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9"] <-Map 27 [SIMPLE_EDGE] - SHUFFLE [RS_77] + SHUFFLE [RS_76] PartitionCols:_col0 - Select Operator [SEL_72] (rows=84 width=1850) + Select Operator [SEL_71] (rows=84 width=1850) Output:["_col0","_col1"] - Filter Operator [FIL_131] (rows=84 width=1850) + Filter Operator [FIL_130] (rows=84 width=1850) predicate:web_site_sk is not null - TableScan [TS_70] (rows=84 width=1850) + TableScan [TS_69] (rows=84 width=1850) default@web_site,web_site,Tbl:COMPLETE,Col:NONE,Output:["web_site_sk","web_site_id"] <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_76] + SHUFFLE [RS_75] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_137] (rows=332646173 width=135) - Conds:Union 23._col1=RS_74._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_136] (rows=332646173 width=135) + Conds:Union 23._col1=RS_73._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] - SHUFFLE [RS_74] + SHUFFLE [RS_73] PartitionCols:_col0 - Select Operator [SEL_69] (rows=8116 width=1119) + Select Operator [SEL_68] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_130] (rows=8116 width=1119) + Filter Operator [FIL_129] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-08-18 00:00:00.0 and d_date_sk is not null) Please refer to the previous TableScan [TS_8] <-Union 23 [SIMPLE_EDGE] <-Map 22 [CONTAINS] - Reduce Output Operator [RS_73] + Reduce Output Operator [RS_72] PartitionCols:_col1 - Select Operator [SEL_54] (rows=144002668 width=135) + Select Operator [SEL_53] (rows=144002668 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_127] (rows=144002668 width=135) + Filter Operator [FIL_126] (rows=144002668 width=135) predicate:(ws_sold_date_sk is not null and ws_web_site_sk is not null) - TableScan [TS_52] (rows=144002668 width=135) + TableScan [TS_51] (rows=144002668 width=135) Output:["ws_sold_date_sk","ws_web_site_sk","ws_ext_sales_price","ws_net_profit"] <-Reducer 25 [CONTAINS] - Reduce Output Operator [RS_73] + Reduce Output Operator [RS_72] PartitionCols:_col1 - Select Operator [SEL_64] (rows=158402938 width=135) + Select Operator [SEL_63] (rows=158402938 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_132] (rows=158402938 width=135) - Conds:RS_61._col0, _col2=RS_62._col1, _col2(Inner),Output:["_col1","_col3","_col6","_col7"] + Merge Join Operator [MERGEJOIN_131] (rows=158402938 width=135) + Conds:RS_60._col0, _col2=RS_61._col1, _col2(Inner),Output:["_col1","_col3","_col6","_col7"] <-Map 24 [SIMPLE_EDGE] - SHUFFLE [RS_61] + SHUFFLE [RS_60] PartitionCols:_col0, _col2 - Select Operator [SEL_57] (rows=144002668 width=135) + Select Operator [SEL_56] (rows=144002668 width=135) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_128] (rows=144002668 width=135) + Filter Operator [FIL_127] (rows=144002668 width=135) predicate:(ws_web_site_sk is not null and ws_order_number is not null and ws_item_sk is not null) - TableScan [TS_55] (rows=144002668 width=135) + TableScan [TS_54] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_item_sk","ws_web_site_sk","ws_order_number"] <-Map 26 [SIMPLE_EDGE] - SHUFFLE [RS_62] + SHUFFLE [RS_61] PartitionCols:_col1, _col2 - Select Operator [SEL_60] (rows=14398467 width=92) + Select Operator [SEL_59] (rows=14398467 width=92) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_129] (rows=14398467 width=92) + Filter Operator [FIL_128] (rows=14398467 width=92) predicate:(wr_returned_date_sk is not null and wr_item_sk is not null and wr_order_number is not null) - TableScan [TS_58] (rows=14398467 width=92) + TableScan [TS_57] (rows=14398467 width=92) default@web_returns,web_returns,Tbl:COMPLETE,Col:NONE,Output:["wr_returned_date_sk","wr_item_sk","wr_order_number","wr_return_amt","wr_net_loss"] <-Reducer 5 [CONTAINS] - Reduce Output Operator [RS_87] + Reduce Output Operator [RS_86] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_86] (rows=2273797803 width=110) + Group By Operator [GBY_85] (rows=2273797803 width=110) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0 Select Operator [SEL_24] (rows=383320021 width=87) Output:["_col0","_col1","_col2","_col3","_col4"] @@ -435,28 +435,28 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_21] (rows=766640042 width=87) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col4)","sum(_col3)","sum(_col5)"],keys:_col9 - Merge Join Operator [MERGEJOIN_134] (rows=766640042 width=87) + Merge Join Operator [MERGEJOIN_133] (rows=766640042 width=87) Conds:RS_17._col0=RS_18._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col9"] <-Map 17 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col0 Select Operator [SEL_13] (rows=1704 width=1910) Output:["_col0","_col1"] - Filter Operator [FIL_122] (rows=1704 width=1910) + Filter Operator [FIL_121] (rows=1704 width=1910) predicate:s_store_sk is not null TableScan [TS_11] (rows=1704 width=1910) default@store,store,Tbl:COMPLETE,Col:NONE,Output:["s_store_sk","s_store_id"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_133] (rows=696945478 width=87) + Merge Join Operator [MERGEJOIN_132] (rows=696945478 width=87) Conds:Union 2._col1=RS_15._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] SHUFFLE [RS_15] PartitionCols:_col0 Select Operator [SEL_10] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_121] (rows=8116 width=1119) + Filter Operator [FIL_120] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-08-18 00:00:00.0 and d_date_sk is not null) Please refer to the previous TableScan [TS_8] <-Union 2 [SIMPLE_EDGE] @@ -465,7 +465,7 @@ Stage-0 PartitionCols:_col1 Select Operator [SEL_2] (rows=575995635 width=88) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_119] (rows=575995635 width=88) + Filter Operator [FIL_118] (rows=575995635 width=88) predicate:(ss_sold_date_sk is not null and ss_store_sk is not null) TableScan [TS_0] (rows=575995635 width=88) Output:["ss_sold_date_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] @@ -474,7 +474,7 @@ Stage-0 PartitionCols:_col1 Select Operator [SEL_5] (rows=57591150 width=77) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_120] (rows=57591150 width=77) + Filter Operator [FIL_119] (rows=57591150 width=77) predicate:(sr_returned_date_sk is not null and sr_store_sk is not null) TableScan [TS_3] (rows=57591150 width=77) Output:["sr_returned_date_sk","sr_store_sk","sr_return_amt","sr_net_loss"] diff --git a/ql/src/test/results/clientpositive/perf/query56.q.out b/ql/src/test/results/clientpositive/perf/query56.q.out index 4ec7201fa7..4c11d01a92 100644 --- a/ql/src/test/results/clientpositive/perf/query56.q.out +++ b/ql/src/test/results/clientpositive/perf/query56.q.out @@ -161,20 +161,20 @@ Stage-0 limit:100 Stage-1 Reducer 7 - File Output Operator [FS_122] - Limit [LIM_121] (rows=100 width=108) + File Output Operator [FS_121] + Limit [LIM_120] (rows=100 width=108) Number of rows:100 - Select Operator [SEL_120] (rows=335408073 width=108) + Select Operator [SEL_119] (rows=335408073 width=108) Output:["_col0","_col1"] <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_119] - Group By Operator [GBY_117] (rows=335408073 width=108) + SHUFFLE [RS_118] + Group By Operator [GBY_116] (rows=335408073 width=108) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Union 5 [SIMPLE_EDGE] <-Reducer 10 [CONTAINS] - Reduce Output Operator [RS_116] + Reduce Output Operator [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=670816147 width=108) + Group By Operator [GBY_114] (rows=670816147 width=108) Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 Group By Operator [GBY_72] (rows=191657247 width=135) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 @@ -183,35 +183,35 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_70] (rows=383314495 width=135) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col1 - Merge Join Operator [MERGEJOIN_184] (rows=383314495 width=135) + Merge Join Operator [MERGEJOIN_183] (rows=383314495 width=135) Conds:RS_66._col0=RS_67._col4(Inner),Output:["_col1","_col8"] <-Reducer 23 [SIMPLE_EDGE] SHUFFLE [RS_67] PartitionCols:_col4 Select Operator [SEL_62] (rows=348467716 width=135) Output:["_col4","_col5"] - Merge Join Operator [MERGEJOIN_179] (rows=348467716 width=135) + Merge Join Operator [MERGEJOIN_178] (rows=348467716 width=135) Conds:RS_59._col1=RS_60._col0(Inner),Output:["_col2","_col3"] <-Map 26 [SIMPLE_EDGE] SHUFFLE [RS_60] PartitionCols:_col0 Select Operator [SEL_55] (rows=20000000 width=1014) Output:["_col0"] - Filter Operator [FIL_168] (rows=20000000 width=1014) + Filter Operator [FIL_167] (rows=20000000 width=1014) predicate:((ca_gmt_offset = -8) and ca_address_sk is not null) TableScan [TS_16] (rows=40000000 width=1014) default@customer_address,customer_address,Tbl:COMPLETE,Col:NONE,Output:["ca_address_sk","ca_gmt_offset"] <-Reducer 22 [SIMPLE_EDGE] SHUFFLE [RS_59] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_178] (rows=316788826 width=135) + Merge Join Operator [MERGEJOIN_177] (rows=316788826 width=135) Conds:RS_56._col0=RS_57._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 21 [SIMPLE_EDGE] SHUFFLE [RS_57] PartitionCols:_col0 Select Operator [SEL_52] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_167] (rows=18262 width=1119) + Filter Operator [FIL_166] (rows=18262 width=1119) predicate:((d_year = 2000) and (d_moy = 1) and d_date_sk is not null) TableScan [TS_13] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_moy"] @@ -220,21 +220,21 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_49] (rows=287989836 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_166] (rows=287989836 width=135) + Filter Operator [FIL_165] (rows=287989836 width=135) predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_item_sk is not null) TableScan [TS_47] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] <-Reducer 8 [SIMPLE_EDGE] SHUFFLE [RS_66] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_177] (rows=508200 width=1436) + Merge Join Operator [MERGEJOIN_176] (rows=508200 width=1436) Conds:RS_63._col1=RS_64._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_63] PartitionCols:_col1 Select Operator [SEL_39] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_164] (rows=462000 width=1436) + Filter Operator [FIL_163] (rows=462000 width=1436) predicate:(i_item_id is not null and i_item_sk is not null) TableScan [TS_0] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_sk","i_item_id"] @@ -250,93 +250,93 @@ Stage-0 Output:["_col0"],keys:i_item_id Select Operator [SEL_42] (rows=231000 width=1436) Output:["i_item_id"] - Filter Operator [FIL_165] (rows=231000 width=1436) + Filter Operator [FIL_164] (rows=231000 width=1436) predicate:((i_color) IN ('orchid', 'chiffon', 'lace') and i_item_id is not null) TableScan [TS_3] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_id","i_color"] <-Reducer 13 [CONTAINS] - Reduce Output Operator [RS_116] + Reduce Output Operator [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=670816147 width=108) + Group By Operator [GBY_114] (rows=670816147 width=108) Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_111] (rows=95833781 width=135) + Group By Operator [GBY_110] (rows=95833781 width=135) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_110] + SHUFFLE [RS_109] PartitionCols:_col0 - Group By Operator [GBY_109] (rows=191667562 width=135) + Group By Operator [GBY_108] (rows=191667562 width=135) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col1 - Merge Join Operator [MERGEJOIN_185] (rows=191667562 width=135) - Conds:RS_105._col0=RS_106._col3(Inner),Output:["_col1","_col8"] + Merge Join Operator [MERGEJOIN_184] (rows=191667562 width=135) + Conds:RS_104._col0=RS_105._col3(Inner),Output:["_col1","_col8"] <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_105] + SHUFFLE [RS_104] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_180] (rows=508200 width=1436) - Conds:RS_102._col1=RS_103._col0(Inner),Output:["_col0","_col1"] + Merge Join Operator [MERGEJOIN_179] (rows=508200 width=1436) + Conds:RS_101._col1=RS_102._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_102] + SHUFFLE [RS_101] PartitionCols:_col1 - Select Operator [SEL_78] (rows=462000 width=1436) + Select Operator [SEL_77] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_169] (rows=462000 width=1436) + Filter Operator [FIL_168] (rows=462000 width=1436) predicate:(i_item_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_0] <-Reducer 17 [SIMPLE_EDGE] - SHUFFLE [RS_103] + SHUFFLE [RS_102] PartitionCols:_col0 - Group By Operator [GBY_84] (rows=115500 width=1436) + Group By Operator [GBY_83] (rows=115500 width=1436) Output:["_col0"],keys:KEY._col0 <-Map 14 [SIMPLE_EDGE] - SHUFFLE [RS_83] + SHUFFLE [RS_82] PartitionCols:_col0 - Group By Operator [GBY_82] (rows=231000 width=1436) + Group By Operator [GBY_81] (rows=231000 width=1436) Output:["_col0"],keys:i_item_id - Select Operator [SEL_81] (rows=231000 width=1436) + Select Operator [SEL_80] (rows=231000 width=1436) Output:["i_item_id"] - Filter Operator [FIL_170] (rows=231000 width=1436) + Filter Operator [FIL_169] (rows=231000 width=1436) predicate:((i_color) IN ('orchid', 'chiffon', 'lace') and i_item_id is not null) Please refer to the previous TableScan [TS_3] <-Reducer 25 [SIMPLE_EDGE] - SHUFFLE [RS_106] + SHUFFLE [RS_105] PartitionCols:_col3 - Select Operator [SEL_101] (rows=174243235 width=135) + Select Operator [SEL_100] (rows=174243235 width=135) Output:["_col3","_col5"] - Merge Join Operator [MERGEJOIN_182] (rows=174243235 width=135) - Conds:RS_98._col2=RS_99._col0(Inner),Output:["_col1","_col3"] + Merge Join Operator [MERGEJOIN_181] (rows=174243235 width=135) + Conds:RS_97._col2=RS_98._col0(Inner),Output:["_col1","_col3"] <-Map 26 [SIMPLE_EDGE] - SHUFFLE [RS_99] + SHUFFLE [RS_98] PartitionCols:_col0 - Select Operator [SEL_94] (rows=20000000 width=1014) + Select Operator [SEL_93] (rows=20000000 width=1014) Output:["_col0"] - Filter Operator [FIL_173] (rows=20000000 width=1014) + Filter Operator [FIL_172] (rows=20000000 width=1014) predicate:((ca_gmt_offset = -8) and ca_address_sk is not null) Please refer to the previous TableScan [TS_16] <-Reducer 24 [SIMPLE_EDGE] - SHUFFLE [RS_98] + SHUFFLE [RS_97] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_181] (rows=158402938 width=135) - Conds:RS_95._col0=RS_96._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_180] (rows=158402938 width=135) + Conds:RS_94._col0=RS_95._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 21 [SIMPLE_EDGE] - SHUFFLE [RS_96] + SHUFFLE [RS_95] PartitionCols:_col0 - Select Operator [SEL_91] (rows=18262 width=1119) + Select Operator [SEL_90] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_172] (rows=18262 width=1119) + Filter Operator [FIL_171] (rows=18262 width=1119) predicate:((d_year = 2000) and (d_moy = 1) and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_95] + SHUFFLE [RS_94] PartitionCols:_col0 - Select Operator [SEL_88] (rows=144002668 width=135) + Select Operator [SEL_87] (rows=144002668 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_171] (rows=144002668 width=135) + Filter Operator [FIL_170] (rows=144002668 width=135) predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_item_sk is not null) - TableScan [TS_86] (rows=144002668 width=135) + TableScan [TS_85] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] <-Reducer 4 [CONTAINS] - Reduce Output Operator [RS_116] + Reduce Output Operator [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=670816147 width=108) + Group By Operator [GBY_114] (rows=670816147 width=108) Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 Group By Operator [GBY_35] (rows=383325119 width=88) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 @@ -345,19 +345,19 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_33] (rows=766650239 width=88) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col1 - Merge Join Operator [MERGEJOIN_183] (rows=766650239 width=88) + Merge Join Operator [MERGEJOIN_182] (rows=766650239 width=88) Conds:RS_29._col0=RS_30._col3(Inner),Output:["_col1","_col8"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_174] (rows=508200 width=1436) + Merge Join Operator [MERGEJOIN_173] (rows=508200 width=1436) Conds:RS_26._col1=RS_27._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col1 Select Operator [SEL_2] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_159] (rows=462000 width=1436) + Filter Operator [FIL_158] (rows=462000 width=1436) predicate:(i_item_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_0] <-Reducer 15 [SIMPLE_EDGE] @@ -372,7 +372,7 @@ Stage-0 Output:["_col0"],keys:i_item_id Select Operator [SEL_5] (rows=231000 width=1436) Output:["i_item_id"] - Filter Operator [FIL_160] (rows=231000 width=1436) + Filter Operator [FIL_159] (rows=231000 width=1436) predicate:((i_color) IN ('orchid', 'chiffon', 'lace') and i_item_id is not null) Please refer to the previous TableScan [TS_3] <-Reducer 20 [SIMPLE_EDGE] @@ -380,27 +380,27 @@ Stage-0 PartitionCols:_col3 Select Operator [SEL_25] (rows=696954748 width=88) Output:["_col3","_col5"] - Merge Join Operator [MERGEJOIN_176] (rows=696954748 width=88) + Merge Join Operator [MERGEJOIN_175] (rows=696954748 width=88) Conds:RS_22._col2=RS_23._col0(Inner),Output:["_col1","_col3"] <-Map 26 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col0 Select Operator [SEL_18] (rows=20000000 width=1014) Output:["_col0"] - Filter Operator [FIL_163] (rows=20000000 width=1014) + Filter Operator [FIL_162] (rows=20000000 width=1014) predicate:((ca_gmt_offset = -8) and ca_address_sk is not null) Please refer to the previous TableScan [TS_16] <-Reducer 19 [SIMPLE_EDGE] SHUFFLE [RS_22] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_175] (rows=633595212 width=88) + Merge Join Operator [MERGEJOIN_174] (rows=633595212 width=88) Conds:RS_19._col0=RS_20._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 21 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col0 Select Operator [SEL_15] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_162] (rows=18262 width=1119) + Filter Operator [FIL_161] (rows=18262 width=1119) predicate:((d_year = 2000) and (d_moy = 1) and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 18 [SIMPLE_EDGE] @@ -408,7 +408,7 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_12] (rows=575995635 width=88) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_161] (rows=575995635 width=88) + Filter Operator [FIL_160] (rows=575995635 width=88) predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_item_sk is not null) TableScan [TS_10] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] diff --git a/ql/src/test/results/clientpositive/perf/query60.q.out b/ql/src/test/results/clientpositive/perf/query60.q.out index 12d8cdd9b4..4b7f8b3266 100644 --- a/ql/src/test/results/clientpositive/perf/query60.q.out +++ b/ql/src/test/results/clientpositive/perf/query60.q.out @@ -181,20 +181,20 @@ Stage-0 limit:100 Stage-1 Reducer 7 - File Output Operator [FS_122] - Limit [LIM_121] (rows=100 width=108) + File Output Operator [FS_121] + Limit [LIM_120] (rows=100 width=108) Number of rows:100 - Select Operator [SEL_120] (rows=335408073 width=108) + Select Operator [SEL_119] (rows=335408073 width=108) Output:["_col0","_col1"] <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_119] - Group By Operator [GBY_117] (rows=335408073 width=108) + SHUFFLE [RS_118] + Group By Operator [GBY_116] (rows=335408073 width=108) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Union 5 [SIMPLE_EDGE] <-Reducer 10 [CONTAINS] - Reduce Output Operator [RS_116] + Reduce Output Operator [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=670816147 width=108) + Group By Operator [GBY_114] (rows=670816147 width=108) Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 Group By Operator [GBY_72] (rows=191657247 width=135) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 @@ -203,35 +203,35 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_70] (rows=383314495 width=135) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col1 - Merge Join Operator [MERGEJOIN_184] (rows=383314495 width=135) + Merge Join Operator [MERGEJOIN_183] (rows=383314495 width=135) Conds:RS_66._col0=RS_67._col4(Inner),Output:["_col1","_col8"] <-Reducer 23 [SIMPLE_EDGE] SHUFFLE [RS_67] PartitionCols:_col4 Select Operator [SEL_62] (rows=348467716 width=135) Output:["_col4","_col5"] - Merge Join Operator [MERGEJOIN_179] (rows=348467716 width=135) + Merge Join Operator [MERGEJOIN_178] (rows=348467716 width=135) Conds:RS_59._col1=RS_60._col0(Inner),Output:["_col2","_col3"] <-Map 26 [SIMPLE_EDGE] SHUFFLE [RS_60] PartitionCols:_col0 Select Operator [SEL_55] (rows=20000000 width=1014) Output:["_col0"] - Filter Operator [FIL_168] (rows=20000000 width=1014) + Filter Operator [FIL_167] (rows=20000000 width=1014) predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) TableScan [TS_16] (rows=40000000 width=1014) default@customer_address,customer_address,Tbl:COMPLETE,Col:NONE,Output:["ca_address_sk","ca_gmt_offset"] <-Reducer 22 [SIMPLE_EDGE] SHUFFLE [RS_59] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_178] (rows=316788826 width=135) + Merge Join Operator [MERGEJOIN_177] (rows=316788826 width=135) Conds:RS_56._col0=RS_57._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 21 [SIMPLE_EDGE] SHUFFLE [RS_57] PartitionCols:_col0 Select Operator [SEL_52] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_167] (rows=18262 width=1119) + Filter Operator [FIL_166] (rows=18262 width=1119) predicate:((d_year = 1999) and (d_moy = 9) and d_date_sk is not null) TableScan [TS_13] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_moy"] @@ -240,21 +240,21 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_49] (rows=287989836 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_166] (rows=287989836 width=135) + Filter Operator [FIL_165] (rows=287989836 width=135) predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_item_sk is not null) TableScan [TS_47] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] <-Reducer 8 [SIMPLE_EDGE] SHUFFLE [RS_66] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_177] (rows=508200 width=1436) + Merge Join Operator [MERGEJOIN_176] (rows=508200 width=1436) Conds:RS_63._col1=RS_64._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_63] PartitionCols:_col1 Select Operator [SEL_39] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_164] (rows=462000 width=1436) + Filter Operator [FIL_163] (rows=462000 width=1436) predicate:(i_item_id is not null and i_item_sk is not null) TableScan [TS_0] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_sk","i_item_id"] @@ -270,93 +270,93 @@ Stage-0 Output:["_col0"],keys:i_item_id Select Operator [SEL_42] (rows=231000 width=1436) Output:["i_item_id"] - Filter Operator [FIL_165] (rows=231000 width=1436) + Filter Operator [FIL_164] (rows=231000 width=1436) predicate:((i_category) IN ('Children') and i_item_id is not null) TableScan [TS_3] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_id","i_category"] <-Reducer 13 [CONTAINS] - Reduce Output Operator [RS_116] + Reduce Output Operator [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=670816147 width=108) + Group By Operator [GBY_114] (rows=670816147 width=108) Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_111] (rows=95833781 width=135) + Group By Operator [GBY_110] (rows=95833781 width=135) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_110] + SHUFFLE [RS_109] PartitionCols:_col0 - Group By Operator [GBY_109] (rows=191667562 width=135) + Group By Operator [GBY_108] (rows=191667562 width=135) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col1 - Merge Join Operator [MERGEJOIN_185] (rows=191667562 width=135) - Conds:RS_105._col0=RS_106._col3(Inner),Output:["_col1","_col8"] + Merge Join Operator [MERGEJOIN_184] (rows=191667562 width=135) + Conds:RS_104._col0=RS_105._col3(Inner),Output:["_col1","_col8"] <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_105] + SHUFFLE [RS_104] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_180] (rows=508200 width=1436) - Conds:RS_102._col1=RS_103._col0(Inner),Output:["_col0","_col1"] + Merge Join Operator [MERGEJOIN_179] (rows=508200 width=1436) + Conds:RS_101._col1=RS_102._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_102] + SHUFFLE [RS_101] PartitionCols:_col1 - Select Operator [SEL_78] (rows=462000 width=1436) + Select Operator [SEL_77] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_169] (rows=462000 width=1436) + Filter Operator [FIL_168] (rows=462000 width=1436) predicate:(i_item_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_0] <-Reducer 17 [SIMPLE_EDGE] - SHUFFLE [RS_103] + SHUFFLE [RS_102] PartitionCols:_col0 - Group By Operator [GBY_84] (rows=115500 width=1436) + Group By Operator [GBY_83] (rows=115500 width=1436) Output:["_col0"],keys:KEY._col0 <-Map 14 [SIMPLE_EDGE] - SHUFFLE [RS_83] + SHUFFLE [RS_82] PartitionCols:_col0 - Group By Operator [GBY_82] (rows=231000 width=1436) + Group By Operator [GBY_81] (rows=231000 width=1436) Output:["_col0"],keys:i_item_id - Select Operator [SEL_81] (rows=231000 width=1436) + Select Operator [SEL_80] (rows=231000 width=1436) Output:["i_item_id"] - Filter Operator [FIL_170] (rows=231000 width=1436) + Filter Operator [FIL_169] (rows=231000 width=1436) predicate:((i_category) IN ('Children') and i_item_id is not null) Please refer to the previous TableScan [TS_3] <-Reducer 25 [SIMPLE_EDGE] - SHUFFLE [RS_106] + SHUFFLE [RS_105] PartitionCols:_col3 - Select Operator [SEL_101] (rows=174243235 width=135) + Select Operator [SEL_100] (rows=174243235 width=135) Output:["_col3","_col5"] - Merge Join Operator [MERGEJOIN_182] (rows=174243235 width=135) - Conds:RS_98._col2=RS_99._col0(Inner),Output:["_col1","_col3"] + Merge Join Operator [MERGEJOIN_181] (rows=174243235 width=135) + Conds:RS_97._col2=RS_98._col0(Inner),Output:["_col1","_col3"] <-Map 26 [SIMPLE_EDGE] - SHUFFLE [RS_99] + SHUFFLE [RS_98] PartitionCols:_col0 - Select Operator [SEL_94] (rows=20000000 width=1014) + Select Operator [SEL_93] (rows=20000000 width=1014) Output:["_col0"] - Filter Operator [FIL_173] (rows=20000000 width=1014) + Filter Operator [FIL_172] (rows=20000000 width=1014) predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) Please refer to the previous TableScan [TS_16] <-Reducer 24 [SIMPLE_EDGE] - SHUFFLE [RS_98] + SHUFFLE [RS_97] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_181] (rows=158402938 width=135) - Conds:RS_95._col0=RS_96._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_180] (rows=158402938 width=135) + Conds:RS_94._col0=RS_95._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 21 [SIMPLE_EDGE] - SHUFFLE [RS_96] + SHUFFLE [RS_95] PartitionCols:_col0 - Select Operator [SEL_91] (rows=18262 width=1119) + Select Operator [SEL_90] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_172] (rows=18262 width=1119) + Filter Operator [FIL_171] (rows=18262 width=1119) predicate:((d_year = 1999) and (d_moy = 9) and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 28 [SIMPLE_EDGE] - SHUFFLE [RS_95] + SHUFFLE [RS_94] PartitionCols:_col0 - Select Operator [SEL_88] (rows=144002668 width=135) + Select Operator [SEL_87] (rows=144002668 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_171] (rows=144002668 width=135) + Filter Operator [FIL_170] (rows=144002668 width=135) predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_item_sk is not null) - TableScan [TS_86] (rows=144002668 width=135) + TableScan [TS_85] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] <-Reducer 4 [CONTAINS] - Reduce Output Operator [RS_116] + Reduce Output Operator [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=670816147 width=108) + Group By Operator [GBY_114] (rows=670816147 width=108) Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 Group By Operator [GBY_35] (rows=383325119 width=88) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 @@ -365,19 +365,19 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_33] (rows=766650239 width=88) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col1 - Merge Join Operator [MERGEJOIN_183] (rows=766650239 width=88) + Merge Join Operator [MERGEJOIN_182] (rows=766650239 width=88) Conds:RS_29._col0=RS_30._col3(Inner),Output:["_col1","_col8"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_174] (rows=508200 width=1436) + Merge Join Operator [MERGEJOIN_173] (rows=508200 width=1436) Conds:RS_26._col1=RS_27._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col1 Select Operator [SEL_2] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_159] (rows=462000 width=1436) + Filter Operator [FIL_158] (rows=462000 width=1436) predicate:(i_item_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_0] <-Reducer 15 [SIMPLE_EDGE] @@ -392,7 +392,7 @@ Stage-0 Output:["_col0"],keys:i_item_id Select Operator [SEL_5] (rows=231000 width=1436) Output:["i_item_id"] - Filter Operator [FIL_160] (rows=231000 width=1436) + Filter Operator [FIL_159] (rows=231000 width=1436) predicate:((i_category) IN ('Children') and i_item_id is not null) Please refer to the previous TableScan [TS_3] <-Reducer 20 [SIMPLE_EDGE] @@ -400,27 +400,27 @@ Stage-0 PartitionCols:_col3 Select Operator [SEL_25] (rows=696954748 width=88) Output:["_col3","_col5"] - Merge Join Operator [MERGEJOIN_176] (rows=696954748 width=88) + Merge Join Operator [MERGEJOIN_175] (rows=696954748 width=88) Conds:RS_22._col2=RS_23._col0(Inner),Output:["_col1","_col3"] <-Map 26 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col0 Select Operator [SEL_18] (rows=20000000 width=1014) Output:["_col0"] - Filter Operator [FIL_163] (rows=20000000 width=1014) + Filter Operator [FIL_162] (rows=20000000 width=1014) predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) Please refer to the previous TableScan [TS_16] <-Reducer 19 [SIMPLE_EDGE] SHUFFLE [RS_22] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_175] (rows=633595212 width=88) + Merge Join Operator [MERGEJOIN_174] (rows=633595212 width=88) Conds:RS_19._col0=RS_20._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 21 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col0 Select Operator [SEL_15] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_162] (rows=18262 width=1119) + Filter Operator [FIL_161] (rows=18262 width=1119) predicate:((d_year = 1999) and (d_moy = 9) and d_date_sk is not null) Please refer to the previous TableScan [TS_13] <-Map 18 [SIMPLE_EDGE] @@ -428,7 +428,7 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_12] (rows=575995635 width=88) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_161] (rows=575995635 width=88) + Filter Operator [FIL_160] (rows=575995635 width=88) predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_item_sk is not null) TableScan [TS_10] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] diff --git a/ql/src/test/results/clientpositive/perf/query71.q.out b/ql/src/test/results/clientpositive/perf/query71.q.out index 44658081b5..1dc8ba56d8 100644 --- a/ql/src/test/results/clientpositive/perf/query71.q.out +++ b/ql/src/test/results/clientpositive/perf/query71.q.out @@ -90,59 +90,59 @@ Stage-0 limit:-1 Stage-1 Reducer 7 - File Output Operator [FS_53] - Select Operator [SEL_52] (rows=670816149 width=108) + File Output Operator [FS_52] + Select Operator [SEL_51] (rows=670816149 width=108) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_51] - Select Operator [SEL_49] (rows=670816149 width=108) + SHUFFLE [RS_50] + Select Operator [SEL_48] (rows=670816149 width=108) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_48] (rows=670816149 width=108) + Group By Operator [GBY_47] (rows=670816149 width=108) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_47] + SHUFFLE [RS_46] PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_46] (rows=1341632299 width=108) + Group By Operator [GBY_45] (rows=1341632299 width=108) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col0)"],keys:_col4, _col8, _col9, _col5 - Merge Join Operator [MERGEJOIN_87] (rows=1341632299 width=108) - Conds:RS_42._col2=RS_43._col0(Inner),Output:["_col0","_col4","_col5","_col8","_col9"] + Merge Join Operator [MERGEJOIN_86] (rows=1341632299 width=108) + Conds:RS_41._col2=RS_42._col0(Inner),Output:["_col0","_col4","_col5","_col8","_col9"] <-Map 16 [SIMPLE_EDGE] - SHUFFLE [RS_43] + SHUFFLE [RS_42] PartitionCols:_col0 - Select Operator [SEL_38] (rows=86400 width=471) + Select Operator [SEL_37] (rows=86400 width=471) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_82] (rows=86400 width=471) + Filter Operator [FIL_81] (rows=86400 width=471) predicate:(((t_meal_time = 'breakfast') or (t_meal_time = 'dinner')) and t_time_sk is not null) - TableScan [TS_36] (rows=86400 width=471) + TableScan [TS_35] (rows=86400 width=471) default@time_dim,time_dim,Tbl:COMPLETE,Col:NONE,Output:["t_time_sk","t_hour","t_minute","t_meal_time"] <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_42] + SHUFFLE [RS_41] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_86] (rows=1219665700 width=108) - Conds:Union 3._col1=RS_40._col0(Inner),Output:["_col0","_col2","_col4","_col5"] + Merge Join Operator [MERGEJOIN_85] (rows=1219665700 width=108) + Conds:Union 3._col1=RS_39._col0(Inner),Output:["_col0","_col2","_col4","_col5"] <-Map 15 [SIMPLE_EDGE] - SHUFFLE [RS_40] + SHUFFLE [RS_39] PartitionCols:_col0 - Select Operator [SEL_35] (rows=231000 width=1436) + Select Operator [SEL_34] (rows=231000 width=1436) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_81] (rows=231000 width=1436) + Filter Operator [FIL_80] (rows=231000 width=1436) predicate:((i_manager_id = 1) and i_item_sk is not null) - TableScan [TS_33] (rows=462000 width=1436) + TableScan [TS_32] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_sk","i_brand_id","i_brand","i_manager_id"] <-Union 3 [SIMPLE_EDGE] <-Reducer 10 [CONTAINS] - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col1 Select Operator [SEL_19] (rows=316788826 width=135) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_84] (rows=316788826 width=135) + Merge Join Operator [MERGEJOIN_83] (rows=316788826 width=135) Conds:RS_16._col0=RS_17._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 11 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 Select Operator [SEL_15] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_78] (rows=18262 width=1119) + Filter Operator [FIL_77] (rows=18262 width=1119) predicate:((d_moy = 12) and (d_year = 2001) and d_date_sk is not null) TableScan [TS_13] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_moy"] @@ -151,48 +151,48 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_12] (rows=287989836 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_77] (rows=287989836 width=135) + Filter Operator [FIL_76] (rows=287989836 width=135) predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_time_sk is not null) TableScan [TS_10] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_sold_time_sk","cs_item_sk","cs_ext_sales_price"] <-Reducer 13 [CONTAINS] - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col1 - Select Operator [SEL_31] (rows=633595212 width=88) + Select Operator [SEL_30] (rows=633595212 width=88) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_85] (rows=633595212 width=88) - Conds:RS_28._col0=RS_29._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_84] (rows=633595212 width=88) + Conds:RS_27._col0=RS_28._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 12 [SIMPLE_EDGE] - SHUFFLE [RS_28] + SHUFFLE [RS_27] PartitionCols:_col0 - Select Operator [SEL_24] (rows=575995635 width=88) + Select Operator [SEL_23] (rows=575995635 width=88) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_79] (rows=575995635 width=88) + Filter Operator [FIL_78] (rows=575995635 width=88) predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_time_sk is not null) - TableScan [TS_22] (rows=575995635 width=88) + TableScan [TS_21] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_sold_time_sk","ss_item_sk","ss_ext_sales_price"] <-Map 14 [SIMPLE_EDGE] - SHUFFLE [RS_29] + SHUFFLE [RS_28] PartitionCols:_col0 - Select Operator [SEL_27] (rows=18262 width=1119) + Select Operator [SEL_26] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_80] (rows=18262 width=1119) + Filter Operator [FIL_79] (rows=18262 width=1119) predicate:((d_moy = 12) and (d_year = 2001) and d_date_sk is not null) - TableScan [TS_25] (rows=73049 width=1119) + TableScan [TS_24] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_moy"] <-Reducer 2 [CONTAINS] - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col1 Select Operator [SEL_9] (rows=158402938 width=135) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_83] (rows=158402938 width=135) + Merge Join Operator [MERGEJOIN_82] (rows=158402938 width=135) Conds:RS_6._col0=RS_7._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_6] PartitionCols:_col0 Select Operator [SEL_2] (rows=144002668 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_75] (rows=144002668 width=135) + Filter Operator [FIL_74] (rows=144002668 width=135) predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_time_sk is not null) TableScan [TS_0] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_sold_time_sk","ws_item_sk","ws_ext_sales_price"] @@ -201,7 +201,7 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_5] (rows=18262 width=1119) Output:["_col0"] - Filter Operator [FIL_76] (rows=18262 width=1119) + Filter Operator [FIL_75] (rows=18262 width=1119) predicate:((d_moy = 12) and (d_year = 2001) and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_moy"] diff --git a/ql/src/test/results/clientpositive/perf/query74.q.out b/ql/src/test/results/clientpositive/perf/query74.q.out index bb4a71e6ce..50d97e7056 100644 --- a/ql/src/test/results/clientpositive/perf/query74.q.out +++ b/ql/src/test/results/clientpositive/perf/query74.q.out @@ -121,409 +121,217 @@ POSTHOOK: type: QUERY Plan optimized by CBO. Vertex dependency in root stage -Reducer 10 <- Reducer 9 (SIMPLE_EDGE), Union 11 (CONTAINS) -Reducer 12 <- Map 1 (SIMPLE_EDGE), Map 20 (SIMPLE_EDGE) -Reducer 13 <- Map 33 (SIMPLE_EDGE), Reducer 12 (SIMPLE_EDGE) -Reducer 14 <- Reducer 13 (SIMPLE_EDGE), Union 15 (CONTAINS) -Reducer 16 <- Map 1 (SIMPLE_EDGE), Map 20 (SIMPLE_EDGE) -Reducer 17 <- Map 33 (SIMPLE_EDGE), Reducer 16 (SIMPLE_EDGE) -Reducer 18 <- Reducer 17 (SIMPLE_EDGE), Union 19 (CONTAINS) -Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 20 (SIMPLE_EDGE) -Reducer 21 <- Map 20 (SIMPLE_EDGE), Map 34 (SIMPLE_EDGE) -Reducer 22 <- Map 33 (SIMPLE_EDGE), Reducer 21 (SIMPLE_EDGE) -Reducer 23 <- Reducer 22 (SIMPLE_EDGE), Union 5 (CONTAINS) -Reducer 24 <- Map 20 (SIMPLE_EDGE), Map 34 (SIMPLE_EDGE) -Reducer 25 <- Map 33 (SIMPLE_EDGE), Reducer 24 (SIMPLE_EDGE) -Reducer 26 <- Reducer 25 (SIMPLE_EDGE), Union 11 (CONTAINS) -Reducer 27 <- Map 20 (SIMPLE_EDGE), Map 34 (SIMPLE_EDGE) -Reducer 28 <- Map 33 (SIMPLE_EDGE), Reducer 27 (SIMPLE_EDGE) -Reducer 29 <- Reducer 28 (SIMPLE_EDGE), Union 15 (CONTAINS) -Reducer 3 <- Map 33 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE) -Reducer 30 <- Map 20 (SIMPLE_EDGE), Map 34 (SIMPLE_EDGE) -Reducer 31 <- Map 33 (SIMPLE_EDGE), Reducer 30 (SIMPLE_EDGE) -Reducer 32 <- Reducer 31 (SIMPLE_EDGE), Union 19 (CONTAINS) -Reducer 4 <- Reducer 3 (SIMPLE_EDGE), Union 5 (CONTAINS) -Reducer 6 <- Union 11 (SIMPLE_EDGE), Union 15 (SIMPLE_EDGE), Union 19 (SIMPLE_EDGE), Union 5 (SIMPLE_EDGE) -Reducer 7 <- Reducer 6 (SIMPLE_EDGE) -Reducer 8 <- Map 1 (SIMPLE_EDGE), Map 20 (SIMPLE_EDGE) -Reducer 9 <- Map 33 (SIMPLE_EDGE), Reducer 8 (SIMPLE_EDGE) +Reducer 11 <- Map 10 (SIMPLE_EDGE), Map 18 (SIMPLE_EDGE) +Reducer 12 <- Map 17 (SIMPLE_EDGE), Reducer 11 (SIMPLE_EDGE) +Reducer 13 <- Reducer 12 (SIMPLE_EDGE) +Reducer 14 <- Map 10 (SIMPLE_EDGE), Map 18 (SIMPLE_EDGE) +Reducer 15 <- Map 17 (SIMPLE_EDGE), Reducer 14 (SIMPLE_EDGE) +Reducer 16 <- Reducer 15 (SIMPLE_EDGE) +Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE) +Reducer 3 <- Map 17 (SIMPLE_EDGE), Reducer 2 (SIMPLE_EDGE) +Reducer 4 <- Reducer 3 (SIMPLE_EDGE) +Reducer 5 <- Reducer 13 (SIMPLE_EDGE), Reducer 16 (SIMPLE_EDGE), Reducer 4 (SIMPLE_EDGE), Reducer 9 (SIMPLE_EDGE) +Reducer 6 <- Reducer 5 (SIMPLE_EDGE) +Reducer 7 <- Map 1 (SIMPLE_EDGE), Map 10 (SIMPLE_EDGE) +Reducer 8 <- Map 17 (SIMPLE_EDGE), Reducer 7 (SIMPLE_EDGE) +Reducer 9 <- Reducer 8 (SIMPLE_EDGE) Stage-0 Fetch Operator limit:100 Stage-1 - Reducer 7 - File Output Operator [FS_184] - Limit [LIM_183] (rows=100 width=88) + Reducer 6 + File Output Operator [FS_92] + Limit [LIM_91] (rows=100 width=88) Number of rows:100 - Select Operator [SEL_182] (rows=574987681 width=88) + Select Operator [SEL_90] (rows=574987679 width=88) Output:["_col0","_col1","_col2"] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_181] - Select Operator [SEL_180] (rows=574987681 width=88) + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_89] + Select Operator [SEL_88] (rows=574987679 width=88) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_179] (rows=574987681 width=88) - predicate:CASE WHEN ((_col1 > 0)) THEN (CASE WHEN ((_col3 > 0)) THEN (((_col5 / _col3) > (_col9 / _col1))) ELSE ((null > (_col9 / _col1))) END) ELSE (CASE WHEN ((_col3 > 0)) THEN (((_col5 / _col3) > null)) ELSE (null) END) END - Merge Join Operator [MERGEJOIN_339] (rows=1149975362 width=88) - Conds:Union 5._col0=Union 11._col0(Inner),Union 5._col0=Union 15._col0(Inner),Union 5._col0=Union 19._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8","_col9"] - <-Union 11 [SIMPLE_EDGE] - <-Reducer 10 [CONTAINS] - Reduce Output Operator [RS_175] - PartitionCols:_col0 - Select Operator [SEL_63] (rows=1 width=105) - Output:["_col0","_col1"] - Group By Operator [GBY_62] (rows=1 width=105) + Filter Operator [FIL_87] (rows=574987679 width=88) + predicate:CASE WHEN ((_col9 > 0)) THEN (CASE WHEN ((_col14 > 0)) THEN (((_col4 / _col14) > (_col19 / _col9))) ELSE ((null > (_col19 / _col9))) END) ELSE (CASE WHEN ((_col14 > 0)) THEN (((_col4 / _col14) > null)) ELSE (null) END) END + Merge Join Operator [MERGEJOIN_171] (rows=1149975359 width=88) + Conds:RS_82._col0=RS_83._col0(Inner),RS_83._col0=RS_84._col0(Inner),RS_83._col0=RS_85._col0(Inner),Output:["_col4","_col9","_col14","_col15","_col16","_col17","_col19"] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_83] + PartitionCols:_col0 + Filter Operator [FIL_39] (rows=116159124 width=88) + predicate:(_col4 > 0) + Select Operator [SEL_162] (rows=348477374 width=88) + Output:["_col0","_col4"] + Group By Operator [GBY_38] (rows=348477374 width=88) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_61] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_37] PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_60] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col4, _col7, _col8 - Merge Join Operator [MERGEJOIN_328] (rows=1 width=105) - Conds:RS_56._col1=RS_57._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] - <-Map 33 [SIMPLE_EDGE] - SHUFFLE [RS_57] + Group By Operator [GBY_36] (rows=696954748 width=88) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col7, _col8, _col4 + Merge Join Operator [MERGEJOIN_166] (rows=696954748 width=88) + Conds:RS_32._col1=RS_33._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] + <-Map 17 [SIMPLE_EDGE] + SHUFFLE [RS_33] PartitionCols:_col0 - Select Operator [SEL_52] (rows=1 width=860) + Select Operator [SEL_28] (rows=80000000 width=860) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_305] (rows=1 width=860) - predicate:false + Filter Operator [FIL_154] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) TableScan [TS_6] (rows=80000000 width=860) default@customer,customer,Tbl:COMPLETE,Col:NONE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name"] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_56] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_32] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_327] (rows=1 width=96) - Conds:RS_53._col0=RS_54._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 20 [SIMPLE_EDGE] - SHUFFLE [RS_54] + Merge Join Operator [MERGEJOIN_165] (rows=633595212 width=88) + Conds:RS_29._col0=RS_30._col0(Inner),Output:["_col1","_col2","_col4"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_30] PartitionCols:_col0 - Select Operator [SEL_49] (rows=1 width=1119) + Select Operator [SEL_25] (rows=18262 width=1119) Output:["_col0","_col1"] - Filter Operator [FIL_304] (rows=1 width=1119) - predicate:false + Filter Operator [FIL_153] (rows=18262 width=1119) + predicate:((d_year) IN (2001, 2002) and (d_year = 2001) and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year"] - <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_53] + <-Map 18 [SIMPLE_EDGE] + SHUFFLE [RS_29] PartitionCols:_col0 - Select Operator [SEL_46] (rows=1 width=88) + Select Operator [SEL_22] (rows=575995635 width=88) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_303] (rows=1 width=88) - predicate:false - TableScan [TS_0] (rows=575995635 width=88) + Filter Operator [FIL_152] (rows=575995635 width=88) + predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) + TableScan [TS_20] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_customer_sk","ss_net_paid"] - <-Reducer 26 [CONTAINS] - Reduce Output Operator [RS_175] - PartitionCols:_col0 - Select Operator [SEL_85] (rows=29040539 width=135) - Output:["_col0","_col1"] - Filter Operator [FIL_84] (rows=29040539 width=135) - predicate:(_col4 > 0) - Select Operator [SEL_321] (rows=87121617 width=135) - Output:["_col0","_col4"] - Group By Operator [GBY_83] (rows=87121617 width=135) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 25 [SIMPLE_EDGE] - SHUFFLE [RS_82] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_81] (rows=174243235 width=135) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col7, _col8, _col4 - Merge Join Operator [MERGEJOIN_330] (rows=174243235 width=135) - Conds:RS_77._col1=RS_78._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] - <-Map 33 [SIMPLE_EDGE] - SHUFFLE [RS_78] - PartitionCols:_col0 - Select Operator [SEL_73] (rows=80000000 width=860) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_308] (rows=80000000 width=860) - predicate:(c_customer_sk is not null and c_customer_id is not null) - Please refer to the previous TableScan [TS_6] - <-Reducer 24 [SIMPLE_EDGE] - SHUFFLE [RS_77] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_329] (rows=158402938 width=135) - Conds:RS_74._col0=RS_75._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 20 [SIMPLE_EDGE] - SHUFFLE [RS_75] - PartitionCols:_col0 - Select Operator [SEL_70] (rows=18262 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_307] (rows=18262 width=1119) - predicate:((d_year) IN (2001, 2002) and (d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 34 [SIMPLE_EDGE] - SHUFFLE [RS_74] - PartitionCols:_col0 - Select Operator [SEL_67] (rows=144002668 width=135) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_306] (rows=144002668 width=135) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) - TableScan [TS_21] (rows=144002668 width=135) - default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] - <-Union 15 [SIMPLE_EDGE] - <-Reducer 14 [CONTAINS] - Reduce Output Operator [RS_176] - PartitionCols:_col0 - Select Operator [SEL_107] (rows=1 width=105) - Output:["_col0","_col1"] - Group By Operator [GBY_106] (rows=1 width=105) + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_85] + PartitionCols:_col0 + Select Operator [SEL_81] (rows=348477374 width=88) + Output:["_col0","_col1","_col2","_col4"] + Group By Operator [GBY_80] (rows=348477374 width=88) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_79] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_78] (rows=696954748 width=88) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col7, _col8, _col4 + Merge Join Operator [MERGEJOIN_170] (rows=696954748 width=88) + Conds:RS_74._col1=RS_75._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] + <-Map 17 [SIMPLE_EDGE] + SHUFFLE [RS_75] + PartitionCols:_col0 + Select Operator [SEL_70] (rows=80000000 width=860) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_160] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_74] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_169] (rows=633595212 width=88) + Conds:RS_71._col0=RS_72._col0(Inner),Output:["_col1","_col2","_col4"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_72] + PartitionCols:_col0 + Select Operator [SEL_67] (rows=18262 width=1119) + Output:["_col0","_col1"] + Filter Operator [FIL_159] (rows=18262 width=1119) + predicate:((d_year) IN (2001, 2002) and (d_year = 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 18 [SIMPLE_EDGE] + SHUFFLE [RS_71] + PartitionCols:_col0 + Select Operator [SEL_64] (rows=575995635 width=88) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_158] (rows=575995635 width=88) + predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) + Please refer to the previous TableScan [TS_20] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_82] + PartitionCols:_col0 + Select Operator [SEL_19] (rows=87121617 width=135) + Output:["_col0","_col4"] + Group By Operator [GBY_18] (rows=87121617 width=135) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_16] (rows=174243235 width=135) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col7, _col8, _col4 + Merge Join Operator [MERGEJOIN_164] (rows=174243235 width=135) + Conds:RS_12._col1=RS_13._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] + <-Map 17 [SIMPLE_EDGE] + SHUFFLE [RS_13] + PartitionCols:_col0 + Select Operator [SEL_8] (rows=80000000 width=860) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_151] (rows=80000000 width=860) + predicate:(c_customer_sk is not null and c_customer_id is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_163] (rows=158402938 width=135) + Conds:RS_9._col0=RS_10._col0(Inner),Output:["_col1","_col2","_col4"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_10] + PartitionCols:_col0 + Select Operator [SEL_5] (rows=18262 width=1119) + Output:["_col0","_col1"] + Filter Operator [FIL_150] (rows=18262 width=1119) + predicate:((d_year) IN (2001, 2002) and (d_year = 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 1 [SIMPLE_EDGE] + SHUFFLE [RS_9] + PartitionCols:_col0 + Select Operator [SEL_2] (rows=144002668 width=135) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_149] (rows=144002668 width=135) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) + TableScan [TS_0] (rows=144002668 width=135) + default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_84] + PartitionCols:_col0 + Filter Operator [FIL_60] (rows=29040539 width=135) + predicate:(_col4 > 0) + Select Operator [SEL_161] (rows=87121617 width=135) + Output:["_col0","_col4"] + Group By Operator [GBY_59] (rows=87121617 width=135) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_105] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_58] PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_104] (rows=1 width=105) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col4, _col7, _col8 - Merge Join Operator [MERGEJOIN_332] (rows=1 width=105) - Conds:RS_100._col1=RS_101._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] - <-Map 33 [SIMPLE_EDGE] - SHUFFLE [RS_101] - PartitionCols:_col0 - Select Operator [SEL_96] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_311] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_100] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_331] (rows=1 width=96) - Conds:RS_97._col0=RS_98._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 20 [SIMPLE_EDGE] - SHUFFLE [RS_98] - PartitionCols:_col0 - Select Operator [SEL_93] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_310] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_97] - PartitionCols:_col0 - Select Operator [SEL_90] (rows=1 width=88) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_309] (rows=1 width=88) - predicate:false - Please refer to the previous TableScan [TS_0] - <-Reducer 29 [CONTAINS] - Reduce Output Operator [RS_176] - PartitionCols:_col0 - Select Operator [SEL_128] (rows=87121617 width=135) - Output:["_col0","_col1"] - Group By Operator [GBY_127] (rows=87121617 width=135) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 28 [SIMPLE_EDGE] - SHUFFLE [RS_126] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_125] (rows=174243235 width=135) + Group By Operator [GBY_57] (rows=174243235 width=135) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col7, _col8, _col4 - Merge Join Operator [MERGEJOIN_334] (rows=174243235 width=135) - Conds:RS_121._col1=RS_122._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] - <-Map 33 [SIMPLE_EDGE] - SHUFFLE [RS_122] + Merge Join Operator [MERGEJOIN_168] (rows=174243235 width=135) + Conds:RS_53._col1=RS_54._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] + <-Map 17 [SIMPLE_EDGE] + SHUFFLE [RS_54] PartitionCols:_col0 - Select Operator [SEL_117] (rows=80000000 width=860) + Select Operator [SEL_49] (rows=80000000 width=860) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_314] (rows=80000000 width=860) + Filter Operator [FIL_157] (rows=80000000 width=860) predicate:(c_customer_sk is not null and c_customer_id is not null) Please refer to the previous TableScan [TS_6] - <-Reducer 27 [SIMPLE_EDGE] - SHUFFLE [RS_121] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_53] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_333] (rows=158402938 width=135) - Conds:RS_118._col0=RS_119._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 20 [SIMPLE_EDGE] - SHUFFLE [RS_119] + Merge Join Operator [MERGEJOIN_167] (rows=158402938 width=135) + Conds:RS_50._col0=RS_51._col0(Inner),Output:["_col1","_col2","_col4"] + <-Map 10 [SIMPLE_EDGE] + SHUFFLE [RS_51] PartitionCols:_col0 - Select Operator [SEL_114] (rows=18262 width=1119) + Select Operator [SEL_46] (rows=18262 width=1119) Output:["_col0","_col1"] - Filter Operator [FIL_313] (rows=18262 width=1119) - predicate:((d_year) IN (2001, 2002) and (d_year = 2002) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 34 [SIMPLE_EDGE] - SHUFFLE [RS_118] - PartitionCols:_col0 - Select Operator [SEL_111] (rows=144002668 width=135) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_312] (rows=144002668 width=135) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) - Please refer to the previous TableScan [TS_21] - <-Union 19 [SIMPLE_EDGE] - <-Reducer 18 [CONTAINS] - Reduce Output Operator [RS_177] - PartitionCols:_col0 - Select Operator [SEL_150] (rows=348477374 width=88) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_149] (rows=348477374 width=88) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 17 [SIMPLE_EDGE] - SHUFFLE [RS_148] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_147] (rows=696954748 width=88) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col7, _col8, _col4 - Merge Join Operator [MERGEJOIN_336] (rows=696954748 width=88) - Conds:RS_143._col1=RS_144._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] - <-Map 33 [SIMPLE_EDGE] - SHUFFLE [RS_144] - PartitionCols:_col0 - Select Operator [SEL_139] (rows=80000000 width=860) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_317] (rows=80000000 width=860) - predicate:(c_customer_sk is not null and c_customer_id is not null) - Please refer to the previous TableScan [TS_6] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_143] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_335] (rows=633595212 width=88) - Conds:RS_140._col0=RS_141._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 20 [SIMPLE_EDGE] - SHUFFLE [RS_141] - PartitionCols:_col0 - Select Operator [SEL_136] (rows=18262 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_316] (rows=18262 width=1119) - predicate:((d_year) IN (2001, 2002) and (d_year = 2002) and d_date_sk is not null) + Filter Operator [FIL_156] (rows=18262 width=1119) + predicate:((d_year) IN (2001, 2002) and (d_year = 2001) and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_140] + SHUFFLE [RS_50] PartitionCols:_col0 - Select Operator [SEL_133] (rows=575995635 width=88) + Select Operator [SEL_43] (rows=144002668 width=135) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_315] (rows=575995635 width=88) - predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) + Filter Operator [FIL_155] (rows=144002668 width=135) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null) Please refer to the previous TableScan [TS_0] - <-Reducer 32 [CONTAINS] - Reduce Output Operator [RS_177] - PartitionCols:_col0 - Select Operator [SEL_170] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_169] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 31 [SIMPLE_EDGE] - SHUFFLE [RS_168] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_167] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col4, _col7, _col8 - Merge Join Operator [MERGEJOIN_338] (rows=1 width=162) - Conds:RS_163._col1=RS_164._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] - <-Map 33 [SIMPLE_EDGE] - SHUFFLE [RS_164] - PartitionCols:_col0 - Select Operator [SEL_159] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_320] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 30 [SIMPLE_EDGE] - SHUFFLE [RS_163] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_337] (rows=1 width=148) - Conds:RS_160._col0=RS_161._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 20 [SIMPLE_EDGE] - SHUFFLE [RS_161] - PartitionCols:_col0 - Select Operator [SEL_156] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_319] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 34 [SIMPLE_EDGE] - SHUFFLE [RS_160] - PartitionCols:_col0 - Select Operator [SEL_153] (rows=1 width=135) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_318] (rows=1 width=135) - predicate:false - Please refer to the previous TableScan [TS_21] - <-Union 5 [SIMPLE_EDGE] - <-Reducer 23 [CONTAINS] - Reduce Output Operator [RS_174] - PartitionCols:_col0 - Select Operator [SEL_40] (rows=1 width=162) - Output:["_col0","_col1"] - Group By Operator [GBY_39] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_38] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_37] (rows=1 width=162) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col4, _col7, _col8 - Merge Join Operator [MERGEJOIN_326] (rows=1 width=162) - Conds:RS_33._col1=RS_34._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] - <-Map 33 [SIMPLE_EDGE] - SHUFFLE [RS_34] - PartitionCols:_col0 - Select Operator [SEL_29] (rows=1 width=860) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_302] (rows=1 width=860) - predicate:false - Please refer to the previous TableScan [TS_6] - <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_33] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_325] (rows=1 width=148) - Conds:RS_30._col0=RS_31._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 20 [SIMPLE_EDGE] - SHUFFLE [RS_31] - PartitionCols:_col0 - Select Operator [SEL_26] (rows=1 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_301] (rows=1 width=1119) - predicate:false - Please refer to the previous TableScan [TS_3] - <-Map 34 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col0 - Select Operator [SEL_23] (rows=1 width=135) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_300] (rows=1 width=135) - predicate:false - Please refer to the previous TableScan [TS_21] - <-Reducer 4 [CONTAINS] - Reduce Output Operator [RS_174] - PartitionCols:_col0 - Select Operator [SEL_20] (rows=116159124 width=88) - Output:["_col0","_col1"] - Filter Operator [FIL_19] (rows=116159124 width=88) - predicate:(_col4 > 0) - Select Operator [SEL_322] (rows=348477374 width=88) - Output:["_col0","_col4"] - Group By Operator [GBY_18] (rows=348477374 width=88) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_16] (rows=696954748 width=88) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["max(_col2)"],keys:_col6, _col7, _col8, _col4 - Merge Join Operator [MERGEJOIN_324] (rows=696954748 width=88) - Conds:RS_12._col1=RS_13._col0(Inner),Output:["_col2","_col4","_col6","_col7","_col8"] - <-Map 33 [SIMPLE_EDGE] - SHUFFLE [RS_13] - PartitionCols:_col0 - Select Operator [SEL_8] (rows=80000000 width=860) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_299] (rows=80000000 width=860) - predicate:(c_customer_sk is not null and c_customer_id is not null) - Please refer to the previous TableScan [TS_6] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_323] (rows=633595212 width=88) - Conds:RS_9._col0=RS_10._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 20 [SIMPLE_EDGE] - SHUFFLE [RS_10] - PartitionCols:_col0 - Select Operator [SEL_5] (rows=18262 width=1119) - Output:["_col0","_col1"] - Filter Operator [FIL_298] (rows=18262 width=1119) - predicate:((d_year) IN (2001, 2002) and (d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_9] - PartitionCols:_col0 - Select Operator [SEL_2] (rows=575995635 width=88) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_297] (rows=575995635 width=88) - predicate:(ss_customer_sk is not null and ss_sold_date_sk is not null) - Please refer to the previous TableScan [TS_0] diff --git a/ql/src/test/results/clientpositive/perf/query76.q.out b/ql/src/test/results/clientpositive/perf/query76.q.out index dcd5004166..e7fa6df5b7 100644 --- a/ql/src/test/results/clientpositive/perf/query76.q.out +++ b/ql/src/test/results/clientpositive/perf/query76.q.out @@ -61,86 +61,86 @@ Stage-0 limit:100 Stage-1 Reducer 6 - File Output Operator [FS_59] - Limit [LIM_58] (rows=100 width=108) + File Output Operator [FS_58] + Limit [LIM_57] (rows=100 width=108) Number of rows:100 - Select Operator [SEL_57] (rows=304916424 width=108) + Select Operator [SEL_56] (rows=304916424 width=108) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_56] - Group By Operator [GBY_54] (rows=304916424 width=108) + SHUFFLE [RS_55] + Group By Operator [GBY_53] (rows=304916424 width=108) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 4 [SIMPLE_EDGE] <-Reducer 10 [CONTAINS] - Reduce Output Operator [RS_53] + Reduce Output Operator [RS_52] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_52] (rows=609832848 width=108) + Group By Operator [GBY_51] (rows=609832848 width=108) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count()","sum(_col5)"],keys:_col0, _col1, _col2, _col3, _col4 - Select Operator [SEL_49] (rows=174233858 width=135) + Select Operator [SEL_48] (rows=174233858 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_89] (rows=174233858 width=135) - Conds:RS_46._col0=RS_47._col0(Inner),Output:["_col3","_col5","_col7","_col8"] + Merge Join Operator [MERGEJOIN_88] (rows=174233858 width=135) + Conds:RS_45._col0=RS_46._col0(Inner),Output:["_col3","_col5","_col7","_col8"] <-Map 16 [SIMPLE_EDGE] - SHUFFLE [RS_47] + SHUFFLE [RS_46] PartitionCols:_col0 - Select Operator [SEL_42] (rows=73049 width=1119) + Select Operator [SEL_41] (rows=73049 width=1119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_83] (rows=73049 width=1119) + Filter Operator [FIL_82] (rows=73049 width=1119) predicate:d_date_sk is not null - TableScan [TS_40] (rows=73049 width=1119) + TableScan [TS_39] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_qoy"] <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_46] + SHUFFLE [RS_45] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_88] (rows=158394413 width=135) - Conds:RS_43._col2=RS_44._col0(Inner),Output:["_col0","_col3","_col5"] + Merge Join Operator [MERGEJOIN_87] (rows=158394413 width=135) + Conds:RS_42._col2=RS_43._col0(Inner),Output:["_col0","_col3","_col5"] <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_44] + SHUFFLE [RS_43] PartitionCols:_col0 - Select Operator [SEL_39] (rows=462000 width=1436) + Select Operator [SEL_38] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_82] (rows=462000 width=1436) + Filter Operator [FIL_81] (rows=462000 width=1436) predicate:i_item_sk is not null TableScan [TS_0] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_sk","i_category"] <-Map 15 [SIMPLE_EDGE] - SHUFFLE [RS_43] + SHUFFLE [RS_42] PartitionCols:_col2 - Select Operator [SEL_36] (rows=143994918 width=135) + Select Operator [SEL_35] (rows=143994918 width=135) Output:["_col0","_col2","_col3"] - Filter Operator [FIL_81] (rows=143994918 width=135) + Filter Operator [FIL_80] (rows=143994918 width=135) predicate:(cs_warehouse_sk is null and cs_item_sk is not null and cs_sold_date_sk is not null) - TableScan [TS_34] (rows=287989836 width=135) + TableScan [TS_33] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_warehouse_sk","cs_item_sk","cs_ext_sales_price"] <-Reducer 3 [CONTAINS] - Reduce Output Operator [RS_53] + Reduce Output Operator [RS_52] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_52] (rows=609832848 width=108) + Group By Operator [GBY_51] (rows=609832848 width=108) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count()","sum(_col5)"],keys:_col0, _col1, _col2, _col3, _col4 Select Operator [SEL_15] (rows=348477373 width=88) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_85] (rows=348477373 width=88) + Merge Join Operator [MERGEJOIN_84] (rows=348477373 width=88) Conds:RS_12._col2=RS_13._col0(Inner),Output:["_col1","_col5","_col7","_col8"] <-Map 12 [SIMPLE_EDGE] SHUFFLE [RS_13] PartitionCols:_col0 Select Operator [SEL_8] (rows=73049 width=1119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_77] (rows=73049 width=1119) + Filter Operator [FIL_76] (rows=73049 width=1119) predicate:d_date_sk is not null TableScan [TS_6] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_qoy"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_12] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_84] (rows=316797605 width=88) + Merge Join Operator [MERGEJOIN_83] (rows=316797605 width=88) Conds:RS_9._col0=RS_10._col1(Inner),Output:["_col1","_col2","_col5"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_9] PartitionCols:_col0 Select Operator [SEL_2] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_75] (rows=462000 width=1436) + Filter Operator [FIL_74] (rows=462000 width=1436) predicate:i_item_sk is not null Please refer to the previous TableScan [TS_0] <-Map 11 [SIMPLE_EDGE] @@ -148,39 +148,39 @@ Stage-0 PartitionCols:_col1 Select Operator [SEL_5] (rows=287997817 width=88) Output:["_col0","_col1","_col3"] - Filter Operator [FIL_76] (rows=287997817 width=88) + Filter Operator [FIL_75] (rows=287997817 width=88) predicate:(ss_addr_sk is null and ss_item_sk is not null and ss_sold_date_sk is not null) TableScan [TS_3] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] <-Reducer 8 [CONTAINS] - Reduce Output Operator [RS_53] + Reduce Output Operator [RS_52] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_52] (rows=609832848 width=108) + Group By Operator [GBY_51] (rows=609832848 width=108) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count()","sum(_col5)"],keys:_col0, _col1, _col2, _col3, _col4 Select Operator [SEL_31] (rows=87121617 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_87] (rows=87121617 width=135) + Merge Join Operator [MERGEJOIN_86] (rows=87121617 width=135) Conds:RS_28._col0=RS_29._col0(Inner),Output:["_col3","_col5","_col7","_col8"] <-Map 14 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0 Select Operator [SEL_24] (rows=73049 width=1119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_80] (rows=73049 width=1119) + Filter Operator [FIL_79] (rows=73049 width=1119) predicate:d_date_sk is not null TableScan [TS_22] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_year","d_qoy"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_28] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_86] (rows=79201469 width=135) + Merge Join Operator [MERGEJOIN_85] (rows=79201469 width=135) Conds:RS_25._col1=RS_26._col0(Inner),Output:["_col0","_col3","_col5"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col0 Select Operator [SEL_21] (rows=462000 width=1436) Output:["_col0","_col1"] - Filter Operator [FIL_79] (rows=462000 width=1436) + Filter Operator [FIL_78] (rows=462000 width=1436) predicate:i_item_sk is not null Please refer to the previous TableScan [TS_0] <-Map 13 [SIMPLE_EDGE] @@ -188,7 +188,7 @@ Stage-0 PartitionCols:_col1 Select Operator [SEL_18] (rows=72001334 width=135) Output:["_col0","_col1","_col3"] - Filter Operator [FIL_78] (rows=72001334 width=135) + Filter Operator [FIL_77] (rows=72001334 width=135) predicate:(ws_web_page_sk is null and ws_item_sk is not null and ws_sold_date_sk is not null) TableScan [TS_16] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_page_sk","ws_ext_sales_price"] diff --git a/ql/src/test/results/clientpositive/perf/query77.q.out b/ql/src/test/results/clientpositive/perf/query77.q.out index d46ba6b13c..04aa84bdf5 100644 --- a/ql/src/test/results/clientpositive/perf/query77.q.out +++ b/ql/src/test/results/clientpositive/perf/query77.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[189][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 15' is a cross product +Warning: Shuffle Join MERGEJOIN[188][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 15' is a cross product PREHOOK: query: explain with ss as (select s_store_sk, @@ -241,26 +241,26 @@ Stage-0 limit:100 Stage-1 Reducer 8 - File Output Operator [FS_131] - Limit [LIM_130] (rows=100 width=163) + File Output Operator [FS_130] + Limit [LIM_129] (rows=100 width=163) Number of rows:100 - Select Operator [SEL_129] (rows=956329968 width=163) + Select Operator [SEL_128] (rows=956329968 width=163) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_128] - Select Operator [SEL_127] (rows=956329968 width=163) + SHUFFLE [RS_127] + Select Operator [SEL_126] (rows=956329968 width=163) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_126] (rows=956329968 width=163) + Group By Operator [GBY_125] (rows=956329968 width=163) Output:["_col0","_col1","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 6 [SIMPLE_EDGE] <-Reducer 15 [CONTAINS] - Reduce Output Operator [RS_125] + Reduce Output Operator [RS_124] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_124] (rows=1912659936 width=163) + Group By Operator [GBY_123] (rows=1912659936 width=163) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0 Select Operator [SEL_75] (rows=158394413 width=360) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_189] (rows=158394413 width=360) + Merge Join Operator [MERGEJOIN_188] (rows=158394413 width=360) Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 14 [CUSTOM_SIMPLE_EDGE] PARTITION_ONLY_SHUFFLE [RS_72] @@ -271,14 +271,14 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_54] (rows=316788826 width=135) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col1 - Merge Join Operator [MERGEJOIN_182] (rows=316788826 width=135) + Merge Join Operator [MERGEJOIN_181] (rows=316788826 width=135) Conds:RS_50._col0=RS_51._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] SHUFFLE [RS_51] PartitionCols:_col0 Select Operator [SEL_49] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_169] (rows=8116 width=1119) + Filter Operator [FIL_168] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-09-03 00:00:00.0 and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_date"] @@ -287,7 +287,7 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_46] (rows=287989836 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_168] (rows=287989836 width=135) + Filter Operator [FIL_167] (rows=287989836 width=135) predicate:cs_sold_date_sk is not null TableScan [TS_44] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_call_center_sk","cs_ext_sales_price","cs_net_profit"] @@ -299,14 +299,14 @@ Stage-0 PARTITION_ONLY_SHUFFLE [RS_69] Group By Operator [GBY_68] (rows=1 width=224) Output:["_col0","_col1"],aggregations:["sum(_col1)","sum(_col2)"] - Merge Join Operator [MERGEJOIN_183] (rows=31678769 width=106) + Merge Join Operator [MERGEJOIN_182] (rows=31678769 width=106) Conds:RS_64._col0=RS_65._col0(Inner),Output:["_col1","_col2"] <-Map 9 [SIMPLE_EDGE] SHUFFLE [RS_65] PartitionCols:_col0 Select Operator [SEL_63] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_171] (rows=8116 width=1119) + Filter Operator [FIL_170] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-09-03 00:00:00.0 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 28 [SIMPLE_EDGE] @@ -314,112 +314,112 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_60] (rows=28798881 width=106) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_170] (rows=28798881 width=106) + Filter Operator [FIL_169] (rows=28798881 width=106) predicate:cr_returned_date_sk is not null TableScan [TS_58] (rows=28798881 width=106) default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:NONE,Output:["cr_returned_date_sk","cr_return_amount","cr_net_loss"] <-Reducer 21 [CONTAINS] - Reduce Output Operator [RS_125] + Reduce Output Operator [RS_124] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_124] (rows=1912659936 width=163) + Group By Operator [GBY_123] (rows=1912659936 width=163) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0 - Select Operator [SEL_121] (rows=95833780 width=135) + Select Operator [SEL_120] (rows=95833780 width=135) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_190] (rows=95833780 width=135) - Conds:RS_118._col0=RS_119._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] + Merge Join Operator [MERGEJOIN_189] (rows=95833780 width=135) + Conds:RS_117._col0=RS_118._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_118] + SHUFFLE [RS_117] PartitionCols:_col0 - Group By Operator [GBY_96] (rows=87121617 width=135) + Group By Operator [GBY_95] (rows=87121617 width=135) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_95] + SHUFFLE [RS_94] PartitionCols:_col0 - Group By Operator [GBY_94] (rows=174243235 width=135) + Group By Operator [GBY_93] (rows=174243235 width=135) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col6 - Merge Join Operator [MERGEJOIN_185] (rows=174243235 width=135) - Conds:RS_90._col1=RS_91._col0(Inner),Output:["_col2","_col3","_col6"] + Merge Join Operator [MERGEJOIN_184] (rows=174243235 width=135) + Conds:RS_89._col1=RS_90._col0(Inner),Output:["_col2","_col3","_col6"] <-Map 30 [SIMPLE_EDGE] - SHUFFLE [RS_91] + SHUFFLE [RS_90] PartitionCols:_col0 - Select Operator [SEL_86] (rows=4602 width=585) + Select Operator [SEL_85] (rows=4602 width=585) Output:["_col0"] - Filter Operator [FIL_174] (rows=4602 width=585) + Filter Operator [FIL_173] (rows=4602 width=585) predicate:wp_web_page_sk is not null - TableScan [TS_84] (rows=4602 width=585) + TableScan [TS_83] (rows=4602 width=585) default@web_page,web_page,Tbl:COMPLETE,Col:NONE,Output:["wp_web_page_sk"] <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_90] + SHUFFLE [RS_89] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_184] (rows=158402938 width=135) - Conds:RS_87._col0=RS_88._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_183] (rows=158402938 width=135) + Conds:RS_86._col0=RS_87._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] - SHUFFLE [RS_88] + SHUFFLE [RS_87] PartitionCols:_col0 - Select Operator [SEL_83] (rows=8116 width=1119) + Select Operator [SEL_82] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_173] (rows=8116 width=1119) + Filter Operator [FIL_172] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-09-03 00:00:00.0 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 29 [SIMPLE_EDGE] - SHUFFLE [RS_87] + SHUFFLE [RS_86] PartitionCols:_col0 - Select Operator [SEL_80] (rows=144002668 width=135) + Select Operator [SEL_79] (rows=144002668 width=135) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_172] (rows=144002668 width=135) + Filter Operator [FIL_171] (rows=144002668 width=135) predicate:(ws_sold_date_sk is not null and ws_web_page_sk is not null) - TableScan [TS_78] (rows=144002668 width=135) + TableScan [TS_77] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_web_page_sk","ws_ext_sales_price","ws_net_profit"] <-Reducer 24 [SIMPLE_EDGE] - SHUFFLE [RS_119] + SHUFFLE [RS_118] PartitionCols:_col0 - Group By Operator [GBY_116] (rows=8711072 width=92) + Group By Operator [GBY_115] (rows=8711072 width=92) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 23 [SIMPLE_EDGE] - SHUFFLE [RS_115] + SHUFFLE [RS_114] PartitionCols:_col0 - Group By Operator [GBY_114] (rows=17422145 width=92) + Group By Operator [GBY_113] (rows=17422145 width=92) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col6 - Merge Join Operator [MERGEJOIN_187] (rows=17422145 width=92) - Conds:RS_110._col1=RS_111._col0(Inner),Output:["_col2","_col3","_col6"] + Merge Join Operator [MERGEJOIN_186] (rows=17422145 width=92) + Conds:RS_109._col1=RS_110._col0(Inner),Output:["_col2","_col3","_col6"] <-Map 30 [SIMPLE_EDGE] - SHUFFLE [RS_111] + SHUFFLE [RS_110] PartitionCols:_col0 - Select Operator [SEL_106] (rows=4602 width=585) + Select Operator [SEL_105] (rows=4602 width=585) Output:["_col0"] - Filter Operator [FIL_177] (rows=4602 width=585) + Filter Operator [FIL_176] (rows=4602 width=585) predicate:wp_web_page_sk is not null - Please refer to the previous TableScan [TS_84] + Please refer to the previous TableScan [TS_83] <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_110] + SHUFFLE [RS_109] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_186] (rows=15838314 width=92) - Conds:RS_107._col0=RS_108._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_185] (rows=15838314 width=92) + Conds:RS_106._col0=RS_107._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] - SHUFFLE [RS_108] + SHUFFLE [RS_107] PartitionCols:_col0 - Select Operator [SEL_103] (rows=8116 width=1119) + Select Operator [SEL_102] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_176] (rows=8116 width=1119) + Filter Operator [FIL_175] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-09-03 00:00:00.0 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 31 [SIMPLE_EDGE] - SHUFFLE [RS_107] + SHUFFLE [RS_106] PartitionCols:_col0 - Select Operator [SEL_100] (rows=14398467 width=92) + Select Operator [SEL_99] (rows=14398467 width=92) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_175] (rows=14398467 width=92) + Filter Operator [FIL_174] (rows=14398467 width=92) predicate:(wr_returned_date_sk is not null and wr_web_page_sk is not null) - TableScan [TS_98] (rows=14398467 width=92) + TableScan [TS_97] (rows=14398467 width=92) default@web_returns,web_returns,Tbl:COMPLETE,Col:NONE,Output:["wr_returned_date_sk","wr_web_page_sk","wr_return_amt","wr_net_loss"] <-Reducer 5 [CONTAINS] - Reduce Output Operator [RS_125] + Reduce Output Operator [RS_124] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_124] (rows=1912659936 width=163) + Group By Operator [GBY_123] (rows=1912659936 width=163) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0 Select Operator [SEL_43] (rows=383325119 width=88) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_188] (rows=383325119 width=88) + Merge Join Operator [MERGEJOIN_187] (rows=383325119 width=88) Conds:RS_40._col0=RS_41._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_41] @@ -431,28 +431,28 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_36] (rows=69685294 width=77) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col6 - Merge Join Operator [MERGEJOIN_181] (rows=69685294 width=77) + Merge Join Operator [MERGEJOIN_180] (rows=69685294 width=77) Conds:RS_32._col1=RS_33._col0(Inner),Output:["_col2","_col3","_col6"] <-Map 25 [SIMPLE_EDGE] SHUFFLE [RS_33] PartitionCols:_col0 Select Operator [SEL_28] (rows=1704 width=1910) Output:["_col0"] - Filter Operator [FIL_167] (rows=1704 width=1910) + Filter Operator [FIL_166] (rows=1704 width=1910) predicate:s_store_sk is not null TableScan [TS_6] (rows=1704 width=1910) default@store,store,Tbl:COMPLETE,Col:NONE,Output:["s_store_sk"] <-Reducer 10 [SIMPLE_EDGE] SHUFFLE [RS_32] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_180] (rows=63350266 width=77) + Merge Join Operator [MERGEJOIN_179] (rows=63350266 width=77) Conds:RS_29._col0=RS_30._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col0 Select Operator [SEL_25] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_166] (rows=8116 width=1119) + Filter Operator [FIL_165] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-09-03 00:00:00.0 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 26 [SIMPLE_EDGE] @@ -460,7 +460,7 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_22] (rows=57591150 width=77) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_165] (rows=57591150 width=77) + Filter Operator [FIL_164] (rows=57591150 width=77) predicate:(sr_returned_date_sk is not null and sr_store_sk is not null) TableScan [TS_20] (rows=57591150 width=77) default@store_returns,store_returns,Tbl:COMPLETE,Col:NONE,Output:["sr_returned_date_sk","sr_store_sk","sr_return_amt","sr_net_loss"] @@ -474,27 +474,27 @@ Stage-0 PartitionCols:_col0 Group By Operator [GBY_16] (rows=696954748 width=88) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col6 - Merge Join Operator [MERGEJOIN_179] (rows=696954748 width=88) + Merge Join Operator [MERGEJOIN_178] (rows=696954748 width=88) Conds:RS_12._col1=RS_13._col0(Inner),Output:["_col2","_col3","_col6"] <-Map 25 [SIMPLE_EDGE] SHUFFLE [RS_13] PartitionCols:_col0 Select Operator [SEL_8] (rows=1704 width=1910) Output:["_col0"] - Filter Operator [FIL_164] (rows=1704 width=1910) + Filter Operator [FIL_163] (rows=1704 width=1910) predicate:s_store_sk is not null Please refer to the previous TableScan [TS_6] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_12] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_178] (rows=633595212 width=88) + Merge Join Operator [MERGEJOIN_177] (rows=633595212 width=88) Conds:RS_9._col0=RS_10._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] SHUFFLE [RS_10] PartitionCols:_col0 Select Operator [SEL_5] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_163] (rows=8116 width=1119) + Filter Operator [FIL_162] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-09-03 00:00:00.0 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] @@ -502,7 +502,7 @@ Stage-0 PartitionCols:_col0 Select Operator [SEL_2] (rows=575995635 width=88) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_162] (rows=575995635 width=88) + Filter Operator [FIL_161] (rows=575995635 width=88) predicate:(ss_sold_date_sk is not null and ss_store_sk is not null) TableScan [TS_0] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] diff --git a/ql/src/test/results/clientpositive/perf/query80.q.out b/ql/src/test/results/clientpositive/perf/query80.q.out index 3cf41f3fed..e37b50dc71 100644 --- a/ql/src/test/results/clientpositive/perf/query80.q.out +++ b/ql/src/test/results/clientpositive/perf/query80.q.out @@ -217,22 +217,22 @@ Stage-0 limit:100 Stage-1 Reducer 10 - File Output Operator [FS_128] - Limit [LIM_127] (rows=100 width=108) + File Output Operator [FS_127] + Limit [LIM_126] (rows=100 width=108) Number of rows:100 - Select Operator [SEL_126] (rows=1217531358 width=108) + Select Operator [SEL_125] (rows=1217531358 width=108) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_125] - Select Operator [SEL_124] (rows=1217531358 width=108) + SHUFFLE [RS_124] + Select Operator [SEL_123] (rows=1217531358 width=108) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_123] (rows=1217531358 width=108) + Group By Operator [GBY_122] (rows=1217531358 width=108) Output:["_col0","_col1","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 8 [SIMPLE_EDGE] <-Reducer 17 [CONTAINS] - Reduce Output Operator [RS_122] + Reduce Output Operator [RS_121] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_121] (rows=2435062716 width=108) + Group By Operator [GBY_120] (rows=2435062716 width=108) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0 Select Operator [SEL_77] (rows=231905279 width=135) Output:["_col0","_col1","_col2","_col3","_col4"] @@ -245,70 +245,70 @@ Stage-0 Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)"],keys:_col0 Select Operator [SEL_72] (rows=463810558 width=135) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_213] (rows=463810558 width=135) + Merge Join Operator [MERGEJOIN_212] (rows=463810558 width=135) Conds:RS_69._col1=RS_70._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col18"] <-Map 29 [SIMPLE_EDGE] SHUFFLE [RS_70] PartitionCols:_col0 Select Operator [SEL_56] (rows=46000 width=460) Output:["_col0","_col1"] - Filter Operator [FIL_197] (rows=46000 width=460) + Filter Operator [FIL_196] (rows=46000 width=460) predicate:cp_catalog_page_sk is not null TableScan [TS_54] (rows=46000 width=460) default@catalog_page,catalog_page,Tbl:COMPLETE,Col:NONE,Output:["cp_catalog_page_sk","cp_catalog_page_id"] <-Reducer 15 [SIMPLE_EDGE] SHUFFLE [RS_69] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_212] (rows=421645953 width=135) + Merge Join Operator [MERGEJOIN_211] (rows=421645953 width=135) Conds:RS_66._col3=RS_67._col0(Inner),Output:["_col1","_col5","_col6","_col9","_col10"] <-Map 24 [SIMPLE_EDGE] SHUFFLE [RS_67] PartitionCols:_col0 Select Operator [SEL_53] (rows=1150 width=1179) Output:["_col0"] - Filter Operator [FIL_196] (rows=1150 width=1179) + Filter Operator [FIL_195] (rows=1150 width=1179) predicate:((p_channel_tv = 'N') and p_promo_sk is not null) TableScan [TS_12] (rows=2300 width=1179) default@promotion,promotion,Tbl:COMPLETE,Col:NONE,Output:["p_promo_sk","p_channel_tv"] <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_66] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_211] (rows=383314495 width=135) + Merge Join Operator [MERGEJOIN_210] (rows=383314495 width=135) Conds:RS_63._col2=RS_64._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col9","_col10"] <-Map 23 [SIMPLE_EDGE] SHUFFLE [RS_64] PartitionCols:_col0 Select Operator [SEL_50] (rows=154000 width=1436) Output:["_col0"] - Filter Operator [FIL_195] (rows=154000 width=1436) + Filter Operator [FIL_194] (rows=154000 width=1436) predicate:((i_current_price > 50) and i_item_sk is not null) TableScan [TS_9] (rows=462000 width=1436) default@item,item,Tbl:COMPLETE,Col:NONE,Output:["i_item_sk","i_current_price"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_63] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_210] (rows=348467716 width=135) + Merge Join Operator [MERGEJOIN_209] (rows=348467716 width=135) Conds:RS_60._col0=RS_61._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 12 [SIMPLE_EDGE] SHUFFLE [RS_61] PartitionCols:_col0 Select Operator [SEL_47] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_194] (rows=8116 width=1119) + Filter Operator [FIL_193] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-09-03 00:00:00.0 and d_date_sk is not null) TableScan [TS_6] (rows=73049 width=1119) default@date_dim,date_dim,Tbl:COMPLETE,Col:NONE,Output:["d_date_sk","d_date"] <-Reducer 27 [SIMPLE_EDGE] SHUFFLE [RS_60] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_209] (rows=316788826 width=135) + Merge Join Operator [MERGEJOIN_208] (rows=316788826 width=135) Conds:RS_57._col2, _col4=RS_58._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 26 [SIMPLE_EDGE] SHUFFLE [RS_57] PartitionCols:_col2, _col4 Select Operator [SEL_41] (rows=287989836 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_192] (rows=287989836 width=135) + Filter Operator [FIL_191] (rows=287989836 width=135) predicate:(cs_sold_date_sk is not null and cs_catalog_page_sk is not null and cs_item_sk is not null and cs_promo_sk is not null) TableScan [TS_39] (rows=287989836 width=135) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:NONE,Output:["cs_sold_date_sk","cs_catalog_page_sk","cs_item_sk","cs_promo_sk","cs_order_number","cs_ext_sales_price","cs_net_profit"] @@ -317,103 +317,103 @@ Stage-0 PartitionCols:_col0, _col1 Select Operator [SEL_44] (rows=28798881 width=106) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_193] (rows=28798881 width=106) + Filter Operator [FIL_192] (rows=28798881 width=106) predicate:cr_item_sk is not null TableScan [TS_42] (rows=28798881 width=106) default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:NONE,Output:["cr_item_sk","cr_order_number","cr_return_amount","cr_net_loss"] <-Reducer 22 [CONTAINS] - Reduce Output Operator [RS_122] + Reduce Output Operator [RS_121] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_121] (rows=2435062716 width=108) + Group By Operator [GBY_120] (rows=2435062716 width=108) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0 - Select Operator [SEL_118] (rows=115958879 width=135) + Select Operator [SEL_117] (rows=115958879 width=135) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_117] (rows=115958879 width=135) + Group By Operator [GBY_116] (rows=115958879 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0 <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_116] + SHUFFLE [RS_115] PartitionCols:_col0 - Group By Operator [GBY_115] (rows=231917759 width=135) + Group By Operator [GBY_114] (rows=231917759 width=135) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)"],keys:_col0 - Select Operator [SEL_113] (rows=231917759 width=135) + Select Operator [SEL_112] (rows=231917759 width=135) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_218] (rows=231917759 width=135) - Conds:RS_110._col2=RS_111._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col18"] + Merge Join Operator [MERGEJOIN_217] (rows=231917759 width=135) + Conds:RS_109._col2=RS_110._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col18"] <-Map 33 [SIMPLE_EDGE] - SHUFFLE [RS_111] + SHUFFLE [RS_110] PartitionCols:_col0 - Select Operator [SEL_97] (rows=84 width=1850) + Select Operator [SEL_96] (rows=84 width=1850) Output:["_col0","_col1"] - Filter Operator [FIL_203] (rows=84 width=1850) + Filter Operator [FIL_202] (rows=84 width=1850) predicate:web_site_sk is not null - TableScan [TS_95] (rows=84 width=1850) + TableScan [TS_94] (rows=84 width=1850) default@web_site,web_site,Tbl:COMPLETE,Col:NONE,Output:["web_site_sk","web_site_id"] <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_110] + SHUFFLE [RS_109] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_217] (rows=210834322 width=135) - Conds:RS_107._col3=RS_108._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_216] (rows=210834322 width=135) + Conds:RS_106._col3=RS_107._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] <-Map 24 [SIMPLE_EDGE] - SHUFFLE [RS_108] + SHUFFLE [RS_107] PartitionCols:_col0 - Select Operator [SEL_94] (rows=1150 width=1179) + Select Operator [SEL_93] (rows=1150 width=1179) Output:["_col0"] - Filter Operator [FIL_202] (rows=1150 width=1179) + Filter Operator [FIL_201] (rows=1150 width=1179) predicate:((p_channel_tv = 'N') and p_promo_sk is not null) Please refer to the previous TableScan [TS_12] <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_107] + SHUFFLE [RS_106] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_216] (rows=191667562 width=135) - Conds:RS_104._col1=RS_105._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_215] (rows=191667562 width=135) + Conds:RS_103._col1=RS_104._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 23 [SIMPLE_EDGE] - SHUFFLE [RS_105] + SHUFFLE [RS_104] PartitionCols:_col0 - Select Operator [SEL_91] (rows=154000 width=1436) + Select Operator [SEL_90] (rows=154000 width=1436) Output:["_col0"] - Filter Operator [FIL_201] (rows=154000 width=1436) + Filter Operator [FIL_200] (rows=154000 width=1436) predicate:((i_current_price > 50) and i_item_sk is not null) Please refer to the previous TableScan [TS_9] <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_104] + SHUFFLE [RS_103] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_215] (rows=174243235 width=135) - Conds:RS_101._col0=RS_102._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_214] (rows=174243235 width=135) + Conds:RS_100._col0=RS_101._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 12 [SIMPLE_EDGE] - SHUFFLE [RS_102] + SHUFFLE [RS_101] PartitionCols:_col0 - Select Operator [SEL_88] (rows=8116 width=1119) + Select Operator [SEL_87] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_200] (rows=8116 width=1119) + Filter Operator [FIL_199] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-09-03 00:00:00.0 and d_date_sk is not null) Please refer to the previous TableScan [TS_6] <-Reducer 31 [SIMPLE_EDGE] - SHUFFLE [RS_101] + SHUFFLE [RS_100] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_214] (rows=158402938 width=135) - Conds:RS_98._col1, _col4=RS_99._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_213] (rows=158402938 width=135) + Conds:RS_97._col1, _col4=RS_98._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 30 [SIMPLE_EDGE] - SHUFFLE [RS_98] + SHUFFLE [RS_97] PartitionCols:_col1, _col4 - Select Operator [SEL_82] (rows=144002668 width=135) + Select Operator [SEL_81] (rows=144002668 width=135) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_198] (rows=144002668 width=135) + Filter Operator [FIL_197] (rows=144002668 width=135) predicate:(ws_sold_date_sk is not null and ws_web_site_sk is not null and ws_item_sk is not null and ws_promo_sk is not null) - TableScan [TS_80] (rows=144002668 width=135) + TableScan [TS_79] (rows=144002668 width=135) default@web_sales,web_sales,Tbl:COMPLETE,Col:NONE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_site_sk","ws_promo_sk","ws_order_number","ws_ext_sales_price","ws_net_profit"] <-Map 32 [SIMPLE_EDGE] - SHUFFLE [RS_99] + SHUFFLE [RS_98] PartitionCols:_col0, _col1 - Select Operator [SEL_85] (rows=14398467 width=92) + Select Operator [SEL_84] (rows=14398467 width=92) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_199] (rows=14398467 width=92) + Filter Operator [FIL_198] (rows=14398467 width=92) predicate:wr_item_sk is not null - TableScan [TS_83] (rows=14398467 width=92) + TableScan [TS_82] (rows=14398467 width=92) default@web_returns,web_returns,Tbl:COMPLETE,Col:NONE,Output:["wr_item_sk","wr_order_number","wr_return_amt","wr_net_loss"] <-Reducer 7 [CONTAINS] - Reduce Output Operator [RS_122] + Reduce Output Operator [RS_121] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_121] (rows=2435062716 width=108) + Group By Operator [GBY_120] (rows=2435062716 width=108) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0 Select Operator [SEL_38] (rows=463823414 width=88) Output:["_col0","_col1","_col2","_col3","_col4"] @@ -426,67 +426,67 @@ Stage-0 Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)"],keys:_col0 Select Operator [SEL_33] (rows=927646829 width=88) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_208] (rows=927646829 width=88) + Merge Join Operator [MERGEJOIN_207] (rows=927646829 width=88) Conds:RS_30._col2=RS_31._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col18"] <-Map 25 [SIMPLE_EDGE] SHUFFLE [RS_31] PartitionCols:_col0 Select Operator [SEL_17] (rows=1704 width=1910) Output:["_col0","_col1"] - Filter Operator [FIL_191] (rows=1704 width=1910) + Filter Operator [FIL_190] (rows=1704 width=1910) predicate:s_store_sk is not null TableScan [TS_15] (rows=1704 width=1910) default@store,store,Tbl:COMPLETE,Col:NONE,Output:["s_store_sk","s_store_id"] <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_207] (rows=843315281 width=88) + Merge Join Operator [MERGEJOIN_206] (rows=843315281 width=88) Conds:RS_27._col3=RS_28._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] <-Map 24 [SIMPLE_EDGE] SHUFFLE [RS_28] PartitionCols:_col0 Select Operator [SEL_14] (rows=1150 width=1179) Output:["_col0"] - Filter Operator [FIL_190] (rows=1150 width=1179) + Filter Operator [FIL_189] (rows=1150 width=1179) predicate:((p_channel_tv = 'N') and p_promo_sk is not null) Please refer to the previous TableScan [TS_12] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_27] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_206] (rows=766650239 width=88) + Merge Join Operator [MERGEJOIN_205] (rows=766650239 width=88) Conds:RS_24._col1=RS_25._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 23 [SIMPLE_EDGE] SHUFFLE [RS_25] PartitionCols:_col0 Select Operator [SEL_11] (rows=154000 width=1436) Output:["_col0"] - Filter Operator [FIL_189] (rows=154000 width=1436) + Filter Operator [FIL_188] (rows=154000 width=1436) predicate:((i_current_price > 50) and i_item_sk is not null) Please refer to the previous TableScan [TS_9] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_205] (rows=696954748 width=88) + Merge Join Operator [MERGEJOIN_204] (rows=696954748 width=88) Conds:RS_21._col0=RS_22._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 12 [SIMPLE_EDGE] SHUFFLE [RS_22] PartitionCols:_col0 Select Operator [SEL_8] (rows=8116 width=1119) Output:["_col0"] - Filter Operator [FIL_188] (rows=8116 width=1119) + Filter Operator [FIL_187] (rows=8116 width=1119) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN 1998-08-04 00:00:00.0 AND 1998-09-03 00:00:00.0 and d_date_sk is not null) Please refer to the previous TableScan [TS_6] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_204] (rows=633595212 width=88) + Merge Join Operator [MERGEJOIN_203] (rows=633595212 width=88) Conds:RS_18._col1, _col4=RS_19._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col1, _col4 Select Operator [SEL_2] (rows=575995635 width=88) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_186] (rows=575995635 width=88) + Filter Operator [FIL_185] (rows=575995635 width=88) predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_promo_sk is not null) TableScan [TS_0] (rows=575995635 width=88) default@store_sales,store_sales,Tbl:COMPLETE,Col:NONE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_promo_sk","ss_ticket_number","ss_ext_sales_price","ss_net_profit"] @@ -495,7 +495,7 @@ Stage-0 PartitionCols:_col0, _col1 Select Operator [SEL_5] (rows=57591150 width=77) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_187] (rows=57591150 width=77) + Filter Operator [FIL_186] (rows=57591150 width=77) predicate:sr_item_sk is not null TableScan [TS_3] (rows=57591150 width=77) default@store_returns,store_returns,Tbl:COMPLETE,Col:NONE,Output:["sr_item_sk","sr_ticket_number","sr_return_amt","sr_net_loss"] diff --git a/ql/src/test/results/clientpositive/spark/union30.q.out b/ql/src/test/results/clientpositive/spark/union30.q.out index 12eda1d3b6..9d827eb814 100644 --- a/ql/src/test/results/clientpositive/spark/union30.q.out +++ b/ql/src/test/results/clientpositive/spark/union30.q.out @@ -55,8 +55,8 @@ STAGE PLANS: Stage: Stage-1 Spark Edges: - Reducer 3 <- Map 2 (GROUP, 2) - Reducer 5 <- Map 2 (GROUP, 2) + Reducer 4 <- Map 3 (GROUP, 2) + Reducer 6 <- Map 3 (GROUP, 2) #### A masked pattern was here #### Vertices: Map 1 @@ -87,25 +87,6 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: key (type: string), value (type: string) - outputColumnNames: key, value - Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE - Group By Operator - keys: key (type: string), value (type: string) - mode: hash - outputColumnNames: _col0, _col1 - Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - sort order: ++ - Map-reduce partition columns: _col0 (type: string), _col1 (type: string) - Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE - Map 6 - Map Operator Tree: - TableScan - alias: src - Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: key (type: string), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -120,7 +101,26 @@ STAGE PLANS: output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe name: default.union_subq_union - Reducer 3 + Map 3 + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: key, value + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: key (type: string), value (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reducer 4 Reduce Operator Tree: Group By Operator keys: KEY._col0 (type: string), KEY._col1 (type: string) @@ -139,7 +139,7 @@ STAGE PLANS: output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe name: default.union_subq_union - Reducer 5 + Reducer 6 Reduce Operator Tree: Group By Operator keys: KEY._col0 (type: string), KEY._col1 (type: string) diff --git a/ql/src/test/results/clientpositive/tez/explainanalyze_2.q.out b/ql/src/test/results/clientpositive/tez/explainanalyze_2.q.out index f6844c4a38..ec87daa68a 100644 --- a/ql/src/test/results/clientpositive/tez/explainanalyze_2.q.out +++ b/ql/src/test/results/clientpositive/tez/explainanalyze_2.q.out @@ -1148,95 +1148,95 @@ Stage-5 Stage-3 Union 5 <-Reducer 12 [CONTAINS] - File Output Operator [FS_79] + File Output Operator [FS_75] table:{"name:":"default.a"} - Select Operator [SEL_45] (rows=5839/5421 width=178) + Select Operator [SEL_44] (rows=5839/5421 width=178) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_126] (rows=5839/5421 width=178) - Conds:RS_42._col1=RS_43._col0(Inner),Output:["_col1","_col4"] + Merge Join Operator [MERGEJOIN_122] (rows=5839/5421 width=178) + Conds:RS_41._col1=RS_42._col0(Inner),Output:["_col1","_col4"] <-Map 17 [SIMPLE_EDGE] - SHUFFLE [RS_43] + SHUFFLE [RS_42] PartitionCols:_col0 - Select Operator [SEL_38] (rows=500/500 width=178) + Select Operator [SEL_37] (rows=500/500 width=178) Output:["_col0","_col1"] - Filter Operator [FIL_116] (rows=500/500 width=178) + Filter Operator [FIL_112] (rows=500/500 width=178) predicate:key is not null - TableScan [TS_36] (rows=500/500 width=178) + TableScan [TS_35] (rows=500/500 width=178) default@src,y,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_42] + SHUFFLE [RS_41] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_125] (rows=2394/2097 width=87) - Conds:Union 14._col0=RS_40._col1(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_121] (rows=2394/2097 width=87) + Conds:Union 14._col0=RS_39._col1(Inner),Output:["_col1"] <-Map 10 [SIMPLE_EDGE] - SHUFFLE [RS_40] + SHUFFLE [RS_39] PartitionCols:_col1 - Select Operator [SEL_35] (rows=500/500 width=178) + Select Operator [SEL_34] (rows=500/500 width=178) Output:["_col0","_col1"] - Filter Operator [FIL_115] (rows=500/500 width=178) + Filter Operator [FIL_111] (rows=500/500 width=178) predicate:(key is not null and value is not null) TableScan [TS_11] (rows=500/500 width=178) default@src,y,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] <-Union 14 [SIMPLE_EDGE] <-Map 13 [CONTAINS] - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col0 Select Operator [SEL_23] (rows=25/25 width=89) Output:["_col0"] - Filter Operator [FIL_112] (rows=25/25 width=89) + Filter Operator [FIL_108] (rows=25/25 width=89) predicate:value is not null TableScan [TS_21] (rows=25/25 width=89) Output:["value"] <-Map 15 [CONTAINS] - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col0 Select Operator [SEL_26] (rows=500/500 width=91) Output:["_col0"] - Filter Operator [FIL_113] (rows=500/500 width=91) + Filter Operator [FIL_109] (rows=500/500 width=91) predicate:value is not null TableScan [TS_24] (rows=500/500 width=91) Output:["value"] <-Map 16 [CONTAINS] - Reduce Output Operator [RS_39] + Reduce Output Operator [RS_38] PartitionCols:_col0 - Select Operator [SEL_31] (rows=500/500 width=91) + Select Operator [SEL_30] (rows=500/500 width=91) Output:["_col0"] - Filter Operator [FIL_114] (rows=500/500 width=91) + Filter Operator [FIL_110] (rows=500/500 width=91) predicate:value is not null - TableScan [TS_29] (rows=500/500 width=91) + TableScan [TS_28] (rows=500/500 width=91) Output:["value"] - File Output Operator [FS_81] + File Output Operator [FS_77] table:{"name:":"default.b"} - Please refer to the previous Select Operator [SEL_45] - File Output Operator [FS_83] + Please refer to the previous Select Operator [SEL_44] + File Output Operator [FS_79] table:{"name:":"default.c"} - Please refer to the previous Select Operator [SEL_45] + Please refer to the previous Select Operator [SEL_44] <-Reducer 4 [CONTAINS] - File Output Operator [FS_79] + File Output Operator [FS_75] table:{"name:":"default.a"} Select Operator [SEL_20] (rows=148/170 width=177) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_124] (rows=148/170 width=177) + Merge Join Operator [MERGEJOIN_120] (rows=148/170 width=177) Conds:RS_17._col1=RS_18._col0(Inner),Output:["_col1","_col4"] <-Map 10 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col0 Select Operator [SEL_13] (rows=500/500 width=178) Output:["_col0","_col1"] - Filter Operator [FIL_111] (rows=500/500 width=178) + Filter Operator [FIL_107] (rows=500/500 width=178) predicate:key is not null Please refer to the previous TableScan [TS_11] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_123] (rows=61/108 width=86) + Merge Join Operator [MERGEJOIN_119] (rows=61/108 width=86) Conds:Union 2._col0=RS_15._col1(Inner),Output:["_col1"] <-Map 7 [SIMPLE_EDGE] SHUFFLE [RS_15] PartitionCols:_col1 Select Operator [SEL_10] (rows=25/25 width=175) Output:["_col0","_col1"] - Filter Operator [FIL_110] (rows=25/25 width=175) + Filter Operator [FIL_106] (rows=25/25 width=175) predicate:(key is not null and value is not null) TableScan [TS_8] (rows=25/25 width=175) default@src1,x,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] @@ -1246,7 +1246,7 @@ Stage-5 PartitionCols:_col0 Select Operator [SEL_2] (rows=25/25 width=89) Output:["_col0"] - Filter Operator [FIL_108] (rows=25/25 width=89) + Filter Operator [FIL_104] (rows=25/25 width=89) predicate:value is not null TableScan [TS_0] (rows=25/25 width=89) Output:["value"] @@ -1255,88 +1255,88 @@ Stage-5 PartitionCols:_col0 Select Operator [SEL_5] (rows=500/500 width=91) Output:["_col0"] - Filter Operator [FIL_109] (rows=500/500 width=91) + Filter Operator [FIL_105] (rows=500/500 width=91) predicate:value is not null TableScan [TS_3] (rows=500/500 width=91) Output:["value"] - File Output Operator [FS_81] + File Output Operator [FS_77] table:{"name:":"default.b"} Please refer to the previous Select Operator [SEL_20] - File Output Operator [FS_83] + File Output Operator [FS_79] table:{"name:":"default.c"} Please refer to the previous Select Operator [SEL_20] <-Reducer 9 [CONTAINS] - File Output Operator [FS_79] + File Output Operator [FS_75] table:{"name:":"default.a"} - Select Operator [SEL_76] (rows=313/820 width=175) + Select Operator [SEL_72] (rows=313/820 width=175) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_128] (rows=313/820 width=175) - Conds:RS_73._col1=Union 20._col0(Inner),Output:["_col0","_col3"] + Merge Join Operator [MERGEJOIN_124] (rows=313/820 width=175) + Conds:RS_69._col1=Union 20._col0(Inner),Output:["_col0","_col3"] <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_73] + SHUFFLE [RS_69] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_127] (rows=44/115 width=264) - Conds:RS_70._col0=RS_71._col0(Inner),Output:["_col0","_col1","_col3"] + Merge Join Operator [MERGEJOIN_123] (rows=44/115 width=264) + Conds:RS_66._col0=RS_67._col0(Inner),Output:["_col0","_col1","_col3"] <-Map 7 [SIMPLE_EDGE] - SHUFFLE [RS_70] + SHUFFLE [RS_66] PartitionCols:_col0 - Select Operator [SEL_50] (rows=25/25 width=175) + Select Operator [SEL_48] (rows=25/25 width=175) Output:["_col0","_col1"] - Filter Operator [FIL_117] (rows=25/25 width=175) + Filter Operator [FIL_113] (rows=25/25 width=175) predicate:(key is not null and value is not null) Please refer to the previous TableScan [TS_8] <-Map 18 [SIMPLE_EDGE] - SHUFFLE [RS_71] + SHUFFLE [RS_67] PartitionCols:_col0 - Select Operator [SEL_53] (rows=25/25 width=175) + Select Operator [SEL_51] (rows=25/25 width=175) Output:["_col0","_col1"] - Filter Operator [FIL_118] (rows=25/25 width=175) + Filter Operator [FIL_114] (rows=25/25 width=175) predicate:key is not null - TableScan [TS_51] (rows=25/25 width=175) + TableScan [TS_49] (rows=25/25 width=175) default@src1,y,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] <-Union 20 [SIMPLE_EDGE] <-Map 19 [CONTAINS] - Reduce Output Operator [RS_74] + Reduce Output Operator [RS_70] PartitionCols:_col0 - Select Operator [SEL_56] (rows=25/25 width=89) + Select Operator [SEL_54] (rows=25/25 width=89) Output:["_col0"] - Filter Operator [FIL_119] (rows=25/25 width=89) + Filter Operator [FIL_115] (rows=25/25 width=89) predicate:value is not null - TableScan [TS_54] (rows=25/25 width=89) + TableScan [TS_52] (rows=25/25 width=89) Output:["value"] <-Map 21 [CONTAINS] - Reduce Output Operator [RS_74] + Reduce Output Operator [RS_70] PartitionCols:_col0 - Select Operator [SEL_59] (rows=500/500 width=91) + Select Operator [SEL_57] (rows=500/500 width=91) Output:["_col0"] - Filter Operator [FIL_120] (rows=500/500 width=91) + Filter Operator [FIL_116] (rows=500/500 width=91) predicate:value is not null - TableScan [TS_57] (rows=500/500 width=91) + TableScan [TS_55] (rows=500/500 width=91) Output:["value"] <-Map 22 [CONTAINS] - Reduce Output Operator [RS_74] + Reduce Output Operator [RS_70] PartitionCols:_col0 - Select Operator [SEL_64] (rows=500/500 width=91) + Select Operator [SEL_61] (rows=500/500 width=91) Output:["_col0"] - Filter Operator [FIL_121] (rows=500/500 width=91) + Filter Operator [FIL_117] (rows=500/500 width=91) predicate:value is not null - TableScan [TS_62] (rows=500/500 width=91) + TableScan [TS_59] (rows=500/500 width=91) Output:["value"] <-Map 23 [CONTAINS] - Reduce Output Operator [RS_74] + Reduce Output Operator [RS_70] PartitionCols:_col0 - Select Operator [SEL_68] (rows=500/500 width=91) + Select Operator [SEL_64] (rows=500/500 width=91) Output:["_col0"] - Filter Operator [FIL_122] (rows=500/500 width=91) + Filter Operator [FIL_118] (rows=500/500 width=91) predicate:value is not null - TableScan [TS_66] (rows=500/500 width=91) + TableScan [TS_62] (rows=500/500 width=91) Output:["value"] - File Output Operator [FS_81] + File Output Operator [FS_77] table:{"name:":"default.b"} - Please refer to the previous Select Operator [SEL_76] - File Output Operator [FS_83] + Please refer to the previous Select Operator [SEL_72] + File Output Operator [FS_79] table:{"name:":"default.c"} - Please refer to the previous Select Operator [SEL_76] + Please refer to the previous Select Operator [SEL_72] Stage-6 Stats-Aggr Operator Stage-1 @@ -2002,35 +2002,35 @@ Stage-4 Dependency Collection{} Stage-2 Reducer 4 - File Output Operator [FS_18] + File Output Operator [FS_17] table:{"name:":"default.dest1"} - Select Operator [SEL_16] (rows=205/310 width=272) + Select Operator [SEL_15] (rows=205/310 width=272) Output:["_col0","_col1"] - Group By Operator [GBY_15] (rows=205/310 width=96) + Group By Operator [GBY_14] (rows=205/310 width=96) Output:["_col0","_col1"],aggregations:["count(DISTINCT KEY._col1:0._col0)"],keys:KEY._col0 <-Union 3 [SIMPLE_EDGE] <-Map 6 [CONTAINS] - Reduce Output Operator [RS_14] + Reduce Output Operator [RS_13] PartitionCols:_col0 Select Operator [SEL_7] (rows=500/500 width=178) Output:["_col0","_col1"] TableScan [TS_6] (rows=500/500 width=178) Output:["key","value"] - Reduce Output Operator [RS_20] + Reduce Output Operator [RS_19] PartitionCols:_col0, _col1 Please refer to the previous Select Operator [SEL_7] <-Map 7 [CONTAINS] - Reduce Output Operator [RS_14] + Reduce Output Operator [RS_13] PartitionCols:_col0 - Select Operator [SEL_11] (rows=500/500 width=178) + Select Operator [SEL_10] (rows=500/500 width=178) Output:["_col0","_col1"] - TableScan [TS_10] (rows=500/500 width=178) + TableScan [TS_9] (rows=500/500 width=178) Output:["key","value"] - Reduce Output Operator [RS_20] + Reduce Output Operator [RS_19] PartitionCols:_col0, _col1 - Please refer to the previous Select Operator [SEL_11] + Please refer to the previous Select Operator [SEL_10] <-Reducer 2 [CONTAINS] - Reduce Output Operator [RS_14] + Reduce Output Operator [RS_13] PartitionCols:_col0 Select Operator [SEL_5] (rows=1/1 width=272) Output:["_col0","_col1"] @@ -2041,15 +2041,15 @@ Stage-4 Select Operator [SEL_1] (rows=500/500 width=10) TableScan [TS_0] (rows=500/500 width=10) default@src,s1,Tbl:COMPLETE,Col:COMPLETE - Reduce Output Operator [RS_20] + Reduce Output Operator [RS_19] PartitionCols:_col0, _col1 Please refer to the previous Select Operator [SEL_5] Reducer 5 - File Output Operator [FS_24] + File Output Operator [FS_23] table:{"name:":"default.dest2"} - Select Operator [SEL_22] (rows=1001/310 width=456) + Select Operator [SEL_21] (rows=1001/310 width=456) Output:["_col0","_col1","_col2"] - Group By Operator [GBY_21] (rows=1001/310 width=280) + Group By Operator [GBY_20] (rows=1001/310 width=280) Output:["_col0","_col1","_col2"],aggregations:["count(DISTINCT KEY._col2:0._col0)"],keys:KEY._col0, KEY._col1 <- Please refer to the previous Union 3 [SIMPLE_EDGE] Stage-5 diff --git a/ql/src/test/results/clientpositive/union24.q.out b/ql/src/test/results/clientpositive/union24.q.out index d6b1a79b20..ae4d2a7ef8 100644 --- a/ql/src/test/results/clientpositive/union24.q.out +++ b/ql/src/test/results/clientpositive/union24.q.out @@ -154,7 +154,7 @@ STAGE PLANS: name: default.src5 name: default.src5 Truncated Path -> Alias: - /src5 [null-subquery2:$hdt$_0-subquery2:$hdt$_0:src5] + /src5 [null-subquery2:$hdt$_2-subquery2:$hdt$_2:src5] Needs Tagging: false Reduce Operator Tree: Group By Operator @@ -483,9 +483,9 @@ STAGE PLANS: name: default.src4 name: default.src4 Truncated Path -> Alias: - /src2 [null-subquery1:$hdt$_0-subquery1-subquery1:$hdt$_0-subquery1-subquery1:$hdt$_0-subquery1:src2] - /src3 [null-subquery1:$hdt$_0-subquery1-subquery1:$hdt$_0-subquery1-subquery2:$hdt$_0-subquery2:src3] - /src4 [null-subquery1:$hdt$_0-subquery1-subquery2:$hdt$_0-subquery2:src4] + /src2 [null-subquery1-subquery1-subquery1:$hdt$_2-subquery1-subquery1-subquery1:src2] + /src3 [null-subquery1-subquery1-subquery2:$hdt$_2-subquery1-subquery1-subquery2:src3] + /src4 [null-subquery1-subquery2:$hdt$_2-subquery1-subquery2:src4] #### A masked pattern was here #### Stage: Stage-0 @@ -712,8 +712,8 @@ STAGE PLANS: name: default.src5 name: default.src5 Truncated Path -> Alias: - /src4 [null-subquery2:$hdt$_0-subquery2:$hdt$_0:a] - /src5 [null-subquery2:$hdt$_0-subquery2:$hdt$_1:b] + /src4 [null-subquery2:$hdt$_1-subquery2:$hdt$_1:a] + /src5 [null-subquery2:$hdt$_1-subquery2:$hdt$_2:b] Needs Tagging: true Reduce Operator Tree: Join Operator @@ -966,8 +966,8 @@ STAGE PLANS: name: default.src3 name: default.src3 Truncated Path -> Alias: - /src2 [null-subquery1:$hdt$_0-subquery1-subquery1:$hdt$_0-subquery1:src2] - /src3 [null-subquery1:$hdt$_0-subquery1-subquery2:$hdt$_0-subquery2:src3] + /src2 [null-subquery1-subquery1:$hdt$_1-subquery1-subquery1:src2] + /src3 [null-subquery1-subquery2:$hdt$_1-subquery1-subquery2:src3] #### A masked pattern was here #### Stage: Stage-0 @@ -1184,8 +1184,8 @@ STAGE PLANS: name: default.src5 name: default.src5 Truncated Path -> Alias: - /src4 [null-subquery2:$hdt$_0-subquery2:$hdt$_0:$hdt$_0:a] - /src5 [null-subquery2:$hdt$_0-subquery2:$hdt$_0:$hdt$_1:b] + /src4 [null-subquery2:$hdt$_1-subquery2:$hdt$_1:$hdt$_1:a] + /src5 [null-subquery2:$hdt$_1-subquery2:$hdt$_1:$hdt$_2:b] Needs Tagging: true Reduce Operator Tree: Join Operator @@ -1508,8 +1508,8 @@ STAGE PLANS: name: default.src3 name: default.src3 Truncated Path -> Alias: - /src2 [null-subquery1:$hdt$_0-subquery1-subquery1:$hdt$_0-subquery1:src2] - /src3 [null-subquery1:$hdt$_0-subquery1-subquery2:$hdt$_0-subquery2:src3] + /src2 [null-subquery1-subquery1:$hdt$_1-subquery1-subquery1:src2] + /src3 [null-subquery1-subquery2:$hdt$_1-subquery1-subquery2:src3] #### A masked pattern was here #### Stage: Stage-0 diff --git a/ql/src/test/results/clientpositive/union30.q.out b/ql/src/test/results/clientpositive/union30.q.out index 26a27c8e15..862ebc11d3 100644 --- a/ql/src/test/results/clientpositive/union30.q.out +++ b/ql/src/test/results/clientpositive/union30.q.out @@ -47,8 +47,8 @@ select key, value from src ) aa POSTHOOK: type: QUERY STAGE DEPENDENCIES: - Stage-9 is a root stage - Stage-2 depends on stages: Stage-9, Stage-10 + Stage-10 is a root stage + Stage-2 depends on stages: Stage-10, Stage-11 Stage-8 depends on stages: Stage-2 , consists of Stage-5, Stage-4, Stage-6 Stage-5 Stage-0 depends on stages: Stage-5, Stage-4, Stage-7 @@ -56,10 +56,10 @@ STAGE DEPENDENCIES: Stage-4 Stage-6 Stage-7 depends on stages: Stage-6 - Stage-10 is a root stage + Stage-11 is a root stage STAGE PLANS: - Stage: Stage-9 + Stage: Stage-10 Map Reduce Map Operator Tree: TableScan @@ -117,6 +117,27 @@ STAGE PLANS: serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe name: default.union_subq_union TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Union + Statistics: Num rows: 1500 Data size: 15936 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: UDFToInteger(_col0) (type: int), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1500 Data size: 15936 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 1500 Data size: 15936 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 + name: default.union_subq_union + TableScan Union Statistics: Num rows: 1500 Data size: 15936 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -146,27 +167,6 @@ STAGE PLANS: output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe name: default.union_subq_union - TableScan - alias: src - Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE - Union - Statistics: Num rows: 1500 Data size: 15936 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 1500 Data size: 15936 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 1500 Data size: 15936 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 - name: default.union_subq_union Stage: Stage-8 Conditional Operator @@ -220,7 +220,7 @@ STAGE PLANS: hdfs directory: true #### A masked pattern was here #### - Stage: Stage-10 + Stage: Stage-11 Map Reduce Map Operator Tree: TableScan diff --git a/ql/src/test/results/clientpositive/union34.q.out b/ql/src/test/results/clientpositive/union34.q.out index 9d593315af..527b85a517 100644 --- a/ql/src/test/results/clientpositive/union34.q.out +++ b/ql/src/test/results/clientpositive/union34.q.out @@ -83,11 +83,11 @@ STAGE PLANS: Stage: Stage-7 Map Reduce Local Work Alias -> Map Local Tables: - null-subquery1:$hdt$_0-subquery1:$hdt$_0:src10_1 + null-subquery1-subquery1:$hdt$_1-subquery1-subquery1:$hdt$_0:src10_1 Fetch Operator limit: -1 Alias -> Map Local Operator Tree: - null-subquery1:$hdt$_0-subquery1:$hdt$_0:src10_1 + null-subquery1-subquery1:$hdt$_1-subquery1-subquery1:$hdt$_0:src10_1 TableScan alias: src10_1 Statistics: Num rows: 10 Data size: 104 Basic stats: COMPLETE Column stats: NONE diff --git a/ql/src/test/results/clientpositive/unionall_unbalancedppd.q.out b/ql/src/test/results/clientpositive/unionall_unbalancedppd.q.out index b3e128a3d6..625063a512 100644 --- a/ql/src/test/results/clientpositive/unionall_unbalancedppd.q.out +++ b/ql/src/test/results/clientpositive/unionall_unbalancedppd.q.out @@ -88,34 +88,13 @@ STAGE PLANS: expressions: f1 (type: int) outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Union - Statistics: Num rows: 2 Data size: 0 Basic stats: PARTIAL Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 2 Data size: 0 Basic stats: PARTIAL Column stats: NONE - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - TableScan - alias: union_all_bug_test_2 - Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Filter Operator - predicate: false (type: boolean) - Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Select Operator - expressions: f1 (type: int) - outputColumnNames: _col0 - Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Union - Statistics: Num rows: 2 Data size: 0 Basic stats: PARTIAL Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 2 Data size: 0 Basic stats: PARTIAL Column stats: NONE - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe Stage: Stage-0 Fetch Operator