diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/CalciteSemanticException.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/CalciteSemanticException.java index 336745b..f6b4124 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/CalciteSemanticException.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/CalciteSemanticException.java @@ -31,7 +31,7 @@ public enum UnsupportedFeature { Distinct_without_an_aggreggation, Duplicates_in_RR, Filter_expression_with_non_boolean_return_type, - Having_clause_without_any_groupby, Hint, Invalid_column_reference, Invalid_decimal, + Having_clause_without_any_groupby, Hint, Invalid_column_reference, Invalid_decimal, Invalid_interval, Less_than_equal_greater_than, Multi_insert, Others, Same_name_in_multiple_expressions, Schema_less_table, Select_alias_in_having_clause, Select_transform, Subquery, Table_sample_clauses, UDTF, Union_type, Unique_join diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRexExecutorImpl.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRexExecutorImpl.java new file mode 100644 index 0000000..f7958c6 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRexExecutorImpl.java @@ -0,0 +1,80 @@ +/** + * 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; + +import java.util.HashSet; +import java.util.List; + +import org.apache.calcite.plan.RelOptCluster; +import org.apache.calcite.plan.RelOptPlanner; +import org.apache.calcite.rex.RexBuilder; +import org.apache.calcite.rex.RexNode; +import org.apache.hadoop.hive.ql.optimizer.ConstantPropagateProcFactory; +import org.apache.hadoop.hive.ql.optimizer.calcite.translator.ExprNodeConverter; +import org.apache.hadoop.hive.ql.optimizer.calcite.translator.RexNodeConverter; +import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + + +public class HiveRexExecutorImpl implements RelOptPlanner.Executor { + + private final RelOptCluster cluster; + + protected final Logger LOG; + + public HiveRexExecutorImpl(RelOptCluster cluster) { + this.cluster = cluster; + LOG = LoggerFactory.getLogger(this.getClass().getName()); + } + + @Override + public void reduce(RexBuilder rexBuilder, List constExps, List reducedValues) { + RexNodeConverter rexNodeConverter = new RexNodeConverter(cluster); + for (RexNode rexNode : constExps) { + // initialize the converter + ExprNodeConverter converter = new ExprNodeConverter("", null, null, null, + new HashSet(), cluster.getTypeFactory()); + // convert RexNode to ExprNodeGenericFuncDesc + ExprNodeDesc expr = rexNode.accept(converter); + if (expr instanceof ExprNodeGenericFuncDesc) { + // folding the constant + ExprNodeDesc constant = ConstantPropagateProcFactory + .foldExpr((ExprNodeGenericFuncDesc) expr); + if (constant != null) { + try { + // convert constant back to RexNode + reducedValues.add(rexNodeConverter.convert((ExprNodeConstantDesc) constant)); + } catch (Exception e) { + LOG.warn(e.getMessage()); + reducedValues.add(rexNode); + } + } else { + reducedValues.add(rexNode); + } + } else { + reducedValues.add(rexNode); + } + } + } + +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveReduceExpressionsRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveReduceExpressionsRule.java new file mode 100644 index 0000000..bdc5d64 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveReduceExpressionsRule.java @@ -0,0 +1,986 @@ +/* + * 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 org.apache.calcite.plan.RelOptPlanner; +import org.apache.calcite.plan.RelOptPredicateList; +import org.apache.calcite.plan.RelOptRule; +import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.rel.RelNode; +import org.apache.calcite.rel.core.Calc; +import org.apache.calcite.rel.core.Filter; +import org.apache.calcite.rel.core.JoinInfo; +import org.apache.calcite.rel.core.Project; +import org.apache.calcite.rel.logical.LogicalCalc; +import org.apache.calcite.rel.metadata.RelMetadataQuery; +import org.apache.calcite.rel.type.RelDataType; +import org.apache.calcite.rel.type.RelDataTypeFactory; +import org.apache.calcite.rex.RexBuilder; +import org.apache.calcite.rex.RexCall; +import org.apache.calcite.rex.RexCorrelVariable; +import org.apache.calcite.rex.RexDynamicParam; +import org.apache.calcite.rex.RexFieldAccess; +import org.apache.calcite.rex.RexInputRef; +import org.apache.calcite.rex.RexLiteral; +import org.apache.calcite.rex.RexLocalRef; +import org.apache.calcite.rex.RexNode; +import org.apache.calcite.rex.RexOver; +import org.apache.calcite.rex.RexProgram; +import org.apache.calcite.rex.RexProgramBuilder; +import org.apache.calcite.rex.RexRangeRef; +import org.apache.calcite.rex.RexShuttle; +import org.apache.calcite.rex.RexUtil; +import org.apache.calcite.rex.RexVisitorImpl; +import org.apache.calcite.sql.SqlKind; +import org.apache.calcite.sql.SqlOperator; +import org.apache.calcite.sql.fun.SqlRowOperator; +import org.apache.calcite.sql.fun.SqlStdOperatorTable; +import org.apache.calcite.sql.type.SqlTypeName; +import org.apache.calcite.tools.RelBuilderFactory; +import org.apache.calcite.util.Pair; +import org.apache.calcite.util.Stacks; +import org.apache.calcite.util.Util; +import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; +import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveFilter; +import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveProject; +import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveJoin; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Lists; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.regex.Pattern; + +/** + * Collection of planner rules that apply various simplifying transformations on + * RexNode trees. Currently, there are two transformations: + * + *
    + *
  • Constant reduction, which evaluates constant subtrees, replacing them + * with a corresponding RexLiteral + *
  • Removal of redundant casts, which occurs when the argument into the cast + * is the same as the type of the resulting cast expression + *
+ */ +public abstract class HiveReduceExpressionsRule extends RelOptRule { + //~ Static fields/initializers --------------------------------------------- + + /** + * Regular expression that matches the description of all instances of this + * rule and {@link ValuesReduceRule} also. Use + * it to prevent the planner from invoking these rules. + */ + public static final Pattern EXCLUSION_PATTERN = + Pattern.compile("Reduce(Expressions|Values)Rule.*"); + + /** + * Singleton rule that reduces constants inside a + * {@link org.apache.calcite.rel.logical.HiveFilter}. + */ + public static final HiveReduceExpressionsRule FILTER_INSTANCE = + new FilterReduceExpressionsRule(HiveFilter.class, HiveRelFactories.HIVE_BUILDER); + + /** + * Singleton rule that reduces constants inside a + * {@link org.apache.calcite.rel.logical.HiveProject}. + */ + public static final HiveReduceExpressionsRule PROJECT_INSTANCE = + new ProjectReduceExpressionsRule(HiveProject.class, HiveRelFactories.HIVE_BUILDER); + + /** + * Singleton rule that reduces constants inside a + * {@link org.apache.calcite.rel.core.HiveJoin}. + */ + public static final HiveReduceExpressionsRule JOIN_INSTANCE = + new JoinReduceExpressionsRule(HiveJoin.class, HiveRelFactories.HIVE_BUILDER); + + /** + * Singleton rule that reduces constants inside a + * {@link org.apache.calcite.rel.logical.LogicalCalc}. + */ + public static final HiveReduceExpressionsRule CALC_INSTANCE = + new CalcReduceExpressionsRule(LogicalCalc.class, HiveRelFactories.HIVE_BUILDER); + + /** + * Rule that reduces constants inside a {@link org.apache.calcite.rel.core.Filter}. + * If the condition is a constant, the filter is removed (if TRUE) or replaced with + * an empty {@link org.apache.calcite.rel.core.Values} (if FALSE or NULL). + */ + public static class FilterReduceExpressionsRule extends HiveReduceExpressionsRule { + + public FilterReduceExpressionsRule(Class filterClass, + RelBuilderFactory relBuilderFactory) { + super(filterClass, relBuilderFactory, "HiveReduceExpressionsRule(Filter)"); + } + + @Override public void onMatch(RelOptRuleCall call) { + final Filter filter = call.rel(0); + final List expList = + Lists.newArrayList(filter.getCondition()); + RexNode newConditionExp; + boolean reduced; + final RelOptPredicateList predicates = + RelMetadataQuery.getPulledUpPredicates(filter.getInput()); + if (reduceExpressions(filter, expList, predicates)) { + assert expList.size() == 1; + newConditionExp = expList.get(0); + reduced = true; + } else { + // No reduction, but let's still test the original + // predicate to see if it was already a constant, + // in which case we don't need any runtime decision + // about filtering. + newConditionExp = filter.getCondition(); + reduced = false; + } + if (newConditionExp.isAlwaysTrue()) { + call.transformTo( + filter.getInput()); + } + // TODO: support LogicalValues + else if (newConditionExp instanceof RexLiteral + || RexUtil.isNullLiteral(newConditionExp, true)) { + // call.transformTo(call.builder().values(filter.getRowType()).build()); + return; + } + else if (reduced) { + call.transformTo(call.builder(). + push(filter.getInput()).filter(expList.get(0)).build()); + } else { + if (newConditionExp instanceof RexCall) { + RexCall rexCall = (RexCall) newConditionExp; + boolean reverse = + rexCall.getOperator() + == SqlStdOperatorTable.NOT; + if (reverse) { + rexCall = (RexCall) rexCall.getOperands().get(0); + } + reduceNotNullableFilter(call, filter, rexCall, reverse); + } + return; + } + + // New plan is absolutely better than old plan. + call.getPlanner().setImportance(filter, 0.0); + } + + private void reduceNotNullableFilter( + RelOptRuleCall call, + Filter filter, + RexCall rexCall, + boolean reverse) { + // If the expression is a IS [NOT] NULL on a non-nullable + // column, then we can either remove the filter or replace + // it with an Empty. + boolean alwaysTrue; + switch (rexCall.getKind()) { + case IS_NULL: + case IS_UNKNOWN: + alwaysTrue = false; + break; + case IS_NOT_NULL: + alwaysTrue = true; + break; + default: + return; + } + if (reverse) { + alwaysTrue = !alwaysTrue; + } + RexNode operand = rexCall.getOperands().get(0); + if (operand instanceof RexInputRef) { + RexInputRef inputRef = (RexInputRef) operand; + if (!inputRef.getType().isNullable()) { + if (alwaysTrue) { + call.transformTo(filter.getInput()); + } else { + // TODO: support LogicalValues + // call.transformTo(call.builder().values(filter.getRowType()).build()); + return; + } + } + } + } + } + + /** + * Rule that reduces constants inside a {@link org.apache.calcite.rel.core.Project}. + */ + public static class ProjectReduceExpressionsRule extends HiveReduceExpressionsRule { + + public ProjectReduceExpressionsRule(Class projectClass, + RelBuilderFactory relBuilderFactory) { + super(projectClass, relBuilderFactory, "HiveReduceExpressionsRule(Project)"); + } + + public boolean matches(RelOptRuleCall call) { + Project project = call.rel(0); + HiveRulesRegistry registry = call.getPlanner().getContext().unwrap(HiveRulesRegistry.class); + + // If this operator has been visited already by the rule, + // we do not need to apply the optimization + if (registry != null && registry.getVisited(this).contains(project)) { + return false; + } + + return true; + } + + @Override public void onMatch(RelOptRuleCall call) { + Project project = call.rel(0); + // Register that we have visited this operator in this rule + HiveRulesRegistry registry = call.getPlanner().getContext().unwrap(HiveRulesRegistry.class); + if (registry != null) { + registry.registerVisited(this, project); + } + final RelOptPredicateList predicates = + RelMetadataQuery.getPulledUpPredicates(project.getInput()); + final List expList = + Lists.newArrayList(project.getProjects()); + if (reduceExpressions(project, expList, predicates)) { + RelNode newProject = call.builder().push(project.getInput()) + .project(expList, project.getRowType().getFieldNames()).build(); + if (registry != null) { + registry.registerVisited(this, newProject); + } + call.transformTo(newProject); + + // New plan is absolutely better than old plan. + call.getPlanner().setImportance(project, 0.0); + } + } + } + + /** + * Rule that reduces constants inside a {@link org.apache.calcite.rel.core.HiveJoin}. + */ + public static class JoinReduceExpressionsRule extends HiveReduceExpressionsRule { + + public JoinReduceExpressionsRule(Class joinClass, + RelBuilderFactory relBuilderFactory) { + super(joinClass, relBuilderFactory, "HiveReduceExpressionsRule(HiveJoin)"); + } + + @Override public void onMatch(RelOptRuleCall call) { + final HiveJoin join = call.rel(0); + final List expList = Lists.newArrayList(join.getCondition()); + final int fieldCount = join.getLeft().getRowType().getFieldCount(); + final RelOptPredicateList leftPredicates = + RelMetadataQuery.getPulledUpPredicates(join.getLeft()); + final RelOptPredicateList rightPredicates = + RelMetadataQuery.getPulledUpPredicates(join.getRight()); + final RelOptPredicateList predicates = + leftPredicates.union(rightPredicates.shift(fieldCount)); + if (!reduceExpressions(join, expList, predicates)) { + return; + } + final JoinInfo joinInfo = JoinInfo.of(join.getLeft(), join.getRight(), expList.get(0)); + if (!joinInfo.isEqui()) { + // This kind of join must be an equi-join, and the condition is + // no longer an equi-join. SemiJoin is an example of this. + return; + } + call.transformTo( + join.copy( + join.getTraitSet(), + expList.get(0), + join.getLeft(), + join.getRight(), + join.getJoinType(), + join.isSemiJoinDone())); + + // New plan is absolutely better than old plan. + call.getPlanner().setImportance(join, 0.0); + } + } + + /** + * Rule that reduces constants inside a {@link org.apache.calcite.rel.core.Calc}. + */ + public static class CalcReduceExpressionsRule extends HiveReduceExpressionsRule { + + public CalcReduceExpressionsRule(Class calcClass, + RelBuilderFactory relBuilderFactory) { + super(calcClass, relBuilderFactory, "HiveReduceExpressionsRule(Calc)"); + } + + @Override public void onMatch(RelOptRuleCall call) { + Calc calc = call.rel(0); + RexProgram program = calc.getProgram(); + final List exprList = program.getExprList(); + + // Form a list of expressions with sub-expressions fully expanded. + final List expandedExprList = Lists.newArrayList(); + final RexShuttle shuttle = + new RexShuttle() { + public RexNode visitLocalRef(RexLocalRef localRef) { + return expandedExprList.get(localRef.getIndex()); + } + }; + for (RexNode expr : exprList) { + expandedExprList.add(expr.accept(shuttle)); + } + final RelOptPredicateList predicates = RelOptPredicateList.EMPTY; + if (reduceExpressions(calc, expandedExprList, predicates)) { + final RexProgramBuilder builder = + new RexProgramBuilder( + calc.getInput().getRowType(), + calc.getCluster().getRexBuilder()); + final List list = Lists.newArrayList(); + for (RexNode expr : expandedExprList) { + list.add(builder.registerInput(expr)); + } + if (program.getCondition() != null) { + final int conditionIndex = + program.getCondition().getIndex(); + final RexNode newConditionExp = + expandedExprList.get(conditionIndex); + if (newConditionExp.isAlwaysTrue()) { + // condition is always TRUE - drop it + } else if (newConditionExp instanceof RexLiteral + || RexUtil.isNullLiteral(newConditionExp, true)) { + // condition is always NULL or FALSE - replace calc + // with empty + call.transformTo(call.builder().values(calc.getRowType()).build()); + return; + } else { + builder.addCondition(list.get(conditionIndex)); + } + } + int k = 0; + for (RexLocalRef projectExpr : program.getProjectList()) { + final int index = projectExpr.getIndex(); + builder.addProject( + list.get(index).getIndex(), + program.getOutputRowType().getFieldNames().get(k++)); + } + call.transformTo( + calc.copy(calc.getTraitSet(), calc.getInput(), builder.getProgram())); + + // New plan is absolutely better than old plan. + call.getPlanner().setImportance(calc, 0.0); + } + } + } + + //~ Constructors ----------------------------------------------------------- + + /** + * Creates a HiveReduceExpressionsRule. + * + * @param clazz class of rels to which this rule should apply + */ + protected HiveReduceExpressionsRule(Class clazz, + RelBuilderFactory relBuilderFactory, String desc) { + super(operand(clazz, any()), relBuilderFactory, desc); + } + + //~ Methods ---------------------------------------------------------------- + + /** + * Reduces a list of expressions. + * + * @param rel Relational expression + * @param expList List of expressions, modified in place + * @param predicates Constraints known to hold on input expressions + * @return whether reduction found something to change, and succeeded + */ + protected static boolean reduceExpressions(RelNode rel, List expList, + RelOptPredicateList predicates) { + RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); + + // Replace predicates on CASE to CASE on predicates. + new CaseShuttle().mutate(expList); + + // Find reducible expressions. + final List constExps = Lists.newArrayList(); + List addCasts = Lists.newArrayList(); + final List removableCasts = Lists.newArrayList(); + final ImmutableMap constants = + predicateConstants(predicates); + findReducibleExps(rel.getCluster().getTypeFactory(), expList, constants, + constExps, addCasts, removableCasts); + if (constExps.isEmpty() && removableCasts.isEmpty()) { + return false; + } + + // Remove redundant casts before reducing constant expressions. + // If the argument to the redundant cast is a reducible constant, + // reducing that argument to a constant first will result in not being + // able to locate the original cast expression. + if (!removableCasts.isEmpty()) { + final List reducedExprs = Lists.newArrayList(); + for (RexNode exp : removableCasts) { + RexCall call = (RexCall) exp; + reducedExprs.add(call.getOperands().get(0)); + } + RexReplacer replacer = + new RexReplacer( + rexBuilder, + removableCasts, + reducedExprs, + Collections.nCopies(removableCasts.size(), false)); + replacer.mutate(expList); + } + + if (constExps.isEmpty()) { + return true; + } + + final List constExps2 = Lists.newArrayList(constExps); + if (!constants.isEmpty()) { + //noinspection unchecked + final List> pairs = + (List>) (List) + Lists.newArrayList(constants.entrySet()); + RexReplacer replacer = + new RexReplacer( + rexBuilder, + Pair.left(pairs), + Pair.right(pairs), + Collections.nCopies(pairs.size(), false)); + replacer.mutate(constExps2); + } + + // Compute the values they reduce to. + RelOptPlanner.Executor executor = + rel.getCluster().getPlanner().getExecutor(); + if (executor == null) { + // Cannot reduce expressions: caller has not set an executor in their + // environment. Caller should execute something like the following before + // invoking the planner: + // + // final RexExecutorImpl executor = + // new RexExecutorImpl(Schemas.createDataContext(null)); + // rootRel.getCluster().getPlanner().setExecutor(executor); + return false; + } + + final List reducedValues = Lists.newArrayList(); + executor.reduce(rexBuilder, constExps2, reducedValues); + + // For Project, we have to be sure to preserve the result + // types, so always cast regardless of the expression type. + // For other RelNodes like Filter, in general, this isn't necessary, + // and the presence of casts could hinder other rules such as sarg + // analysis, which require bare literals. But there are special cases, + // like when the expression is a UDR argument, that need to be + // handled as special cases. + if (rel instanceof Project) { + addCasts = Collections.nCopies(reducedValues.size(), true); + } + + RexReplacer replacer = + new RexReplacer( + rexBuilder, + constExps, + reducedValues, + addCasts); + replacer.mutate(expList); + return true; + } + + /** + * Locates expressions that can be reduced to literals or converted to + * expressions with redundant casts removed. + * + * @param typeFactory Type factory + * @param exps list of candidate expressions to be examined for + * reduction + * @param constants List of expressions known to be constant + * @param constExps returns the list of expressions that can be constant + * reduced + * @param addCasts indicator for each expression that can be constant + * reduced, whether a cast of the resulting reduced + * expression is potentially necessary + * @param removableCasts returns the list of cast expressions where the cast + */ + protected static void findReducibleExps(RelDataTypeFactory typeFactory, + List exps, ImmutableMap constants, + List constExps, List addCasts, + List removableCasts) { + ReducibleExprLocator gardener = + new ReducibleExprLocator(typeFactory, constants, constExps, + addCasts, removableCasts); + for (RexNode exp : exps) { + gardener.analyze(exp); + } + assert constExps.size() == addCasts.size(); + } + + protected static ImmutableMap predicateConstants( + RelOptPredicateList predicates) { + // We cannot use an ImmutableMap.Builder here. If there are multiple entries + // with the same key (e.g. "WHERE deptno = 1 AND deptno = 2"), it doesn't + // matter which we take, so the latter will replace the former. + // The basic idea is to find all the pairs of RexNode = RexLiteral + // (1) If 'predicates' contain a non-EQUALS, we bail out. + // (2) It is OK if a RexNode is equal to the same RexLiteral several times, + // (e.g. "WHERE deptno = 1 AND deptno = 1") + // (3) It will return false if there are inconsistent constraints (e.g. + // "WHERE deptno = 1 AND deptno = 2") + final Map map = new HashMap<>(); + final Set excludeSet = new HashSet<>(); + for (RexNode predicate : predicates.pulledUpPredicates) { + gatherConstraints(map, predicate, excludeSet); + } + final ImmutableMap.Builder builder = + ImmutableMap.builder(); + for (Map.Entry entry : map.entrySet()) { + RexNode rexNode = entry.getKey(); + if (!overlap(rexNode, excludeSet)) { + builder.put(rexNode, entry.getValue()); + } + } + return builder.build(); + } + + private static boolean overlap(RexNode rexNode, Set set) { + if (rexNode instanceof RexCall) { + for (RexNode r : ((RexCall) rexNode).getOperands()) { + if (overlap(r, set)) { + return true; + } + } + return false; + } else { + return set.contains(rexNode); + } + } + + /** Tries to decompose the RexNode which is a RexCall into non-literal + * RexNodes. */ + private static void decompose(Set set, RexNode rexNode) { + if (rexNode instanceof RexCall) { + for (RexNode r : ((RexCall) rexNode).getOperands()) { + decompose(set, r); + } + } else if (!(rexNode instanceof RexLiteral)) { + set.add(rexNode); + } + } + + private static void gatherConstraints(Map map, + RexNode predicate, Set excludeSet) { + if (predicate.getKind() != SqlKind.EQUALS) { + decompose(excludeSet, predicate); + return; + } + final List operands = ((RexCall) predicate).getOperands(); + if (operands.size() != 2) { + decompose(excludeSet, predicate); + return; + } + // if it reaches here, we have rexNode equals rexNode + final RexNode left = operands.get(0); + final RexNode right = operands.get(1); + // note that literals are immutable too and they can only be compared through + // values. + if (right instanceof RexLiteral && !excludeSet.contains(left)) { + RexLiteral existedValue = map.get(left); + if (existedValue == null) { + map.put(left, (RexLiteral) right); + } else { + if (!existedValue.getValue().equals(((RexLiteral) right).getValue())) { + // we found conflict values. + map.remove(left); + excludeSet.add(left); + } + } + } else if (left instanceof RexLiteral && !excludeSet.contains(right)) { + RexLiteral existedValue = map.get(right); + if (existedValue == null) { + map.put(right, (RexLiteral) left); + } else { + if (!existedValue.getValue().equals(((RexLiteral) left).getValue())) { + map.remove(right); + excludeSet.add(right); + } + } + } + } + + /** Pushes predicates into a CASE. + * + *

We have a loose definition of 'predicate': any boolean expression will + * do, except CASE. For example '(CASE ...) = 5' or '(CASE ...) IS NULL'. + */ + protected static RexCall pushPredicateIntoCase(RexCall call) { + if (call.getType().getSqlTypeName() != SqlTypeName.BOOLEAN) { + return call; + } + switch (call.getKind()) { + case CASE: + case AND: + case OR: + return call; // don't push CASE into CASE! + } + int caseOrdinal = -1; + final List operands = call.getOperands(); + for (int i = 0; i < operands.size(); i++) { + RexNode operand = operands.get(i); + switch (operand.getKind()) { + case CASE: + caseOrdinal = i; + } + } + if (caseOrdinal < 0) { + return call; + } + // Convert + // f(CASE WHEN p1 THEN v1 ... END, arg) + // to + // CASE WHEN p1 THEN f(v1, arg) ... END + final RexCall case_ = (RexCall) operands.get(caseOrdinal); + final List nodes = new ArrayList<>(); + for (int i = 0; i < case_.getOperands().size(); i++) { + RexNode node = case_.getOperands().get(i); + if (!RexUtil.isCasePredicate(case_, i)) { + node = substitute(call, caseOrdinal, node); + } + nodes.add(node); + } + return case_.clone(call.getType(), nodes); + } + + /** Converts op(arg0, ..., argOrdinal, ..., argN) to op(arg0,..., node, ..., argN). */ + protected static RexNode substitute(RexCall call, int ordinal, RexNode node) { + final List newOperands = Lists.newArrayList(call.getOperands()); + newOperands.set(ordinal, node); + return call.clone(call.getType(), newOperands); + } + + //~ Inner Classes ---------------------------------------------------------- + + /** + * Replaces expressions with their reductions. Note that we only have to + * look for RexCall, since nothing else is reducible in the first place. + */ + protected static class RexReplacer extends RexShuttle { + private final RexBuilder rexBuilder; + private final List reducibleExps; + private final List reducedValues; + private final List addCasts; + + RexReplacer( + RexBuilder rexBuilder, + List reducibleExps, + List reducedValues, + List addCasts) { + this.rexBuilder = rexBuilder; + this.reducibleExps = reducibleExps; + this.reducedValues = reducedValues; + this.addCasts = addCasts; + } + + @Override public RexNode visitInputRef(RexInputRef inputRef) { + RexNode node = visit(inputRef); + if (node == null) { + return super.visitInputRef(inputRef); + } + return node; + } + + @Override public RexNode visitCall(RexCall call) { + RexNode node = visit(call); + if (node != null) { + return node; + } + node = super.visitCall(call); + if (node != call) { + node = RexUtil.simplify(rexBuilder, node); + } + return node; + } + + private RexNode visit(final RexNode call) { + int i = reducibleExps.indexOf(call); + if (i == -1) { + return null; + } + RexNode replacement = reducedValues.get(i); + if (addCasts.get(i) + && (replacement.getType() != call.getType())) { + // Handle change from nullable to NOT NULL by claiming + // that the result is still nullable, even though + // we know it isn't. + // + // Also, we cannot reduce CAST('abc' AS VARCHAR(4)) to 'abc'. + // If we make 'abc' of type VARCHAR(4), we may later encounter + // the same expression in a Project's digest where it has + // type VARCHAR(3), and that's wrong. + replacement = rexBuilder.makeAbstractCast(call.getType(), replacement); + } + return replacement; + } + } + + /** + * Helper class used to locate expressions that either can be reduced to + * literals or contain redundant casts. + */ + protected static class ReducibleExprLocator extends RexVisitorImpl { + /** Whether an expression is constant, and if so, whether it can be + * reduced to a simpler constant. */ + enum Constancy { + NON_CONSTANT, REDUCIBLE_CONSTANT, IRREDUCIBLE_CONSTANT + } + + private final RelDataTypeFactory typeFactory; + + private final List stack; + + private final ImmutableMap constants; + + private final List constExprs; + + private final List addCasts; + + private final List removableCasts; + + private final List parentCallTypeStack; + + ReducibleExprLocator(RelDataTypeFactory typeFactory, + ImmutableMap constants, List constExprs, + List addCasts, List removableCasts) { + // go deep + super(true); + this.typeFactory = typeFactory; + this.constants = constants; + this.constExprs = constExprs; + this.addCasts = addCasts; + this.removableCasts = removableCasts; + this.stack = Lists.newArrayList(); + this.parentCallTypeStack = Lists.newArrayList(); + } + + public void analyze(RexNode exp) { + assert stack.isEmpty(); + + exp.accept(this); + + // Deal with top of stack + assert stack.size() == 1; + assert parentCallTypeStack.isEmpty(); + Constancy rootConstancy = stack.get(0); + if (rootConstancy == Constancy.REDUCIBLE_CONSTANT) { + // The entire subtree was constant, so add it to the result. + addResult(exp); + } + stack.clear(); + } + + private Void pushVariable() { + stack.add(Constancy.NON_CONSTANT); + return null; + } + + private void addResult(RexNode exp) { + // Cast of literal can't be reduced, so skip those (otherwise we'd + // go into an infinite loop as we add them back). + if (exp.getKind() == SqlKind.CAST) { + RexCall cast = (RexCall) exp; + RexNode operand = cast.getOperands().get(0); + if (operand instanceof RexLiteral) { + return; + } + } + constExprs.add(exp); + + // In the case where the expression corresponds to a UDR argument, + // we need to preserve casts. Note that this only applies to + // the topmost argument, not expressions nested within the UDR + // call. + // + // REVIEW zfong 6/13/08 - Are there other expressions where we + // also need to preserve casts? + if (parentCallTypeStack.isEmpty()) { + addCasts.add(false); + } else { + addCasts.add(isUdf(Stacks.peek(parentCallTypeStack))); + } + } + + private Boolean isUdf(SqlOperator operator) { + // return operator instanceof UserDefinedRoutine + return false; + } + + public Void visitInputRef(RexInputRef inputRef) { + if (constants.containsKey(inputRef)) { + stack.add(Constancy.REDUCIBLE_CONSTANT); + return null; + } + return pushVariable(); + } + + public Void visitLiteral(RexLiteral literal) { + stack.add(Constancy.IRREDUCIBLE_CONSTANT); + return null; + } + + public Void visitOver(RexOver over) { + // assume non-constant (running SUM(1) looks constant but isn't) + analyzeCall(over, Constancy.NON_CONSTANT); + return null; + } + + public Void visitCorrelVariable(RexCorrelVariable correlVariable) { + return pushVariable(); + } + + public Void visitCall(RexCall call) { + // assume REDUCIBLE_CONSTANT until proven otherwise + analyzeCall(call, Constancy.REDUCIBLE_CONSTANT); + return null; + } + + private void analyzeCall(RexCall call, Constancy callConstancy) { + Stacks.push(parentCallTypeStack, call.getOperator()); + + // visit operands, pushing their states onto stack + super.visitCall(call); + + // look for NON_CONSTANT operands + int operandCount = call.getOperands().size(); + List operandStack = Util.last(stack, operandCount); + for (Constancy operandConstancy : operandStack) { + if (operandConstancy == Constancy.NON_CONSTANT) { + callConstancy = Constancy.NON_CONSTANT; + } + } + + // Even if all operands are constant, the call itself may + // be non-deterministic. + if (!call.getOperator().isDeterministic()) { + callConstancy = Constancy.NON_CONSTANT; + } else if (call.getOperator().isDynamicFunction()) { + // We can reduce the call to a constant, but we can't + // cache the plan if the function is dynamic. + // For now, treat it same as non-deterministic. + callConstancy = Constancy.NON_CONSTANT; + } + + // Row operator itself can't be reduced to a literal, but if + // the operands are constants, we still want to reduce those + if ((callConstancy == Constancy.REDUCIBLE_CONSTANT) + && (call.getOperator() instanceof SqlRowOperator)) { + callConstancy = Constancy.NON_CONSTANT; + } + + if (callConstancy == Constancy.NON_CONSTANT) { + // any REDUCIBLE_CONSTANT children are now known to be maximal + // reducible subtrees, so they can be added to the result + // list + for (int iOperand = 0; iOperand < operandCount; ++iOperand) { + Constancy constancy = operandStack.get(iOperand); + if (constancy == Constancy.REDUCIBLE_CONSTANT) { + addResult(call.getOperands().get(iOperand)); + } + } + + // if this cast expression can't be reduced to a literal, + // then see if we can remove the cast + if (call.getOperator() == SqlStdOperatorTable.CAST) { + reduceCasts(call); + } + } + + // pop operands off of the stack + operandStack.clear(); + + // pop this parent call operator off the stack + Stacks.pop(parentCallTypeStack, call.getOperator()); + + // push constancy result for this call onto stack + stack.add(callConstancy); + } + + private void reduceCasts(RexCall outerCast) { + List operands = outerCast.getOperands(); + if (operands.size() != 1) { + return; + } + RelDataType outerCastType = outerCast.getType(); + RelDataType operandType = operands.get(0).getType(); + if (operandType.equals(outerCastType)) { + removableCasts.add(outerCast); + return; + } + + // See if the reduction + // CAST((CAST x AS type) AS type NOT NULL) + // -> CAST(x AS type NOT NULL) + // applies. TODO jvs 15-Dec-2008: consider + // similar cases for precision changes. + if (!(operands.get(0) instanceof RexCall)) { + return; + } + RexCall innerCast = (RexCall) operands.get(0); + if (innerCast.getOperator() != SqlStdOperatorTable.CAST) { + return; + } + if (innerCast.getOperands().size() != 1) { + return; + } + RelDataType outerTypeNullable = + typeFactory.createTypeWithNullability(outerCastType, true); + RelDataType innerTypeNullable = + typeFactory.createTypeWithNullability(operandType, true); + if (outerTypeNullable != innerTypeNullable) { + return; + } + if (operandType.isNullable()) { + removableCasts.add(innerCast); + } + } + + public Void visitDynamicParam(RexDynamicParam dynamicParam) { + return pushVariable(); + } + + public Void visitRangeRef(RexRangeRef rangeRef) { + return pushVariable(); + } + + public Void visitFieldAccess(RexFieldAccess fieldAccess) { + return pushVariable(); + } + } + + /** Shuttle that pushes predicates into a CASE. */ + protected static class CaseShuttle extends RexShuttle { + @Override public RexNode visitCall(RexCall call) { + for (;;) { + call = (RexCall) super.visitCall(call); + final RexCall old = call; + call = pushPredicateIntoCase(call); + if (call == old) { + return call; + } + } + } + } +} + +// End HiveReduceExpressionsRule.java diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/ASTBuilder.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/ASTBuilder.java index 425514d..d39744b 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/ASTBuilder.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/ASTBuilder.java @@ -150,11 +150,33 @@ static ASTNode literal(RexLiteral literal, boolean useTypeQualInLiteral) { switch (sqlType) { case BINARY: - ByteString bs = (ByteString) literal.getValue(); - val = bs.byteAt(0); - type = HiveParser.BigintLiteral; + case DATE: + case TIME: + case TIMESTAMP: + case INTERVAL_YEAR_MONTH: + case INTERVAL_DAY_TIME: + if (literal.getValue() == null) { + return ASTBuilder.construct(HiveParser.TOK_NULL, "TOK_NULL").node(); + } break; case TINYINT: + case SMALLINT: + case INTEGER: + case BIGINT: + case DOUBLE: + case DECIMAL: + case FLOAT: + case REAL: + case VARCHAR: + case CHAR: + case BOOLEAN: + if (literal.getValue3() == null) { + return ASTBuilder.construct(HiveParser.TOK_NULL, "TOK_NULL").node(); + } + } + + switch (sqlType) { + case TINYINT: if (useTypeQualInLiteral) { val = literal.getValue3() + "Y"; } else { @@ -244,6 +266,8 @@ static ASTNode literal(RexLiteral literal, boolean useTypeQualInLiteral) { type = HiveParser.TOK_NULL; break; + //binary type should not be seen. + case BINARY: default: throw new RuntimeException("Unsupported Type: " + sqlType); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/RexNodeConverter.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/RexNodeConverter.java index 631a4ca..969132e 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/RexNodeConverter.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/RexNodeConverter.java @@ -29,6 +29,7 @@ import java.util.List; import java.util.Map; +import org.apache.calcite.avatica.util.ByteString; import org.apache.calcite.avatica.util.TimeUnit; import org.apache.calcite.plan.RelOptCluster; import org.apache.calcite.rel.RelNode; @@ -71,10 +72,12 @@ import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBaseCompare; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBaseNumeric; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBridge; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFTimestamp; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToBinary; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToChar; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToDate; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToDecimal; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToIntervalDayTime; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToVarchar; import org.apache.hadoop.hive.serde2.objectinspector.ConstantObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorUtils; @@ -112,6 +115,11 @@ private InputCtx(RelDataType calciteInpDataType, ImmutableMap h private final ImmutableList inputCtxs; private final boolean flattenExpr; + //Constructor used by HiveRexExecutorImpl + public RexNodeConverter(RelOptCluster cluster) { + this(cluster, new ArrayList(), false); + } + public RexNodeConverter(RelOptCluster cluster, RelDataType inpDataType, ImmutableMap nameToPosMap, int offset, boolean flattenExpr) { this.cluster = cluster; @@ -259,6 +267,9 @@ private RexNode handleExplicitCast(ExprNodeGenericFuncDesc func, List c GenericUDF udf = func.getGenericUDF(); if ((udf instanceof GenericUDFToChar) || (udf instanceof GenericUDFToVarchar) || (udf instanceof GenericUDFToDecimal) || (udf instanceof GenericUDFToDate) + // Calcite can not specify the scale for timestamp. As a result, all + // the millisecond part will be lost + || (udf instanceof GenericUDFTimestamp) || (udf instanceof GenericUDFToBinary) || castExprUsingUDFBridge(udf)) { castExpr = cluster.getRexBuilder().makeAbstractCast( TypeConverter.convert(func.getTypeInfo(), cluster.getTypeFactory()), @@ -321,6 +332,10 @@ protected RexNode convert(ExprNodeConstantDesc literal) throws CalciteSemanticEx coi); RexNode calciteLiteral = null; + // If value is null, the type should also be VOID. + if (value == null) { + hiveTypeCategory = PrimitiveCategory.VOID; + } // TODO: Verify if we need to use ConstantObjectInspector to unwrap data switch (hiveTypeCategory) { case BOOLEAN: @@ -378,6 +393,10 @@ protected RexNode convert(ExprNodeConstantDesc literal) throws CalciteSemanticEx calciteLiteral = rexBuilder.makeApproxLiteral(new BigDecimal((Float) value), calciteDataType); break; case DOUBLE: + // TODO: The best solution is to support NaN in expression reduction. + if (Double.isNaN((Double) value)) { + throw new CalciteSemanticException("NaN", UnsupportedFeature.Invalid_decimal); + } calciteLiteral = rexBuilder.makeApproxLiteral(new BigDecimal((Double) value), calciteDataType); break; case CHAR: @@ -417,14 +436,22 @@ protected RexNode convert(ExprNodeConstantDesc literal) throws CalciteSemanticEx new SqlIntervalQualifier(TimeUnit.YEAR, TimeUnit.MONTH, new SqlParserPos(1,1))); break; case INTERVAL_DAY_TIME: + // Calcite RexBuilder L525 divides value by the multiplier. + // Need to get CAlCITE-1020 in. + throw new CalciteSemanticException("INTERVAL_DAY_TIME is not well supported", + UnsupportedFeature.Invalid_interval); // Calcite day-time interval is millis value as BigDecimal // Seconds converted to millis - BigDecimal secsValueBd = BigDecimal.valueOf(((HiveIntervalDayTime) value).getTotalSeconds() * 1000); - // Nanos converted to millis - BigDecimal nanosValueBd = BigDecimal.valueOf(((HiveIntervalDayTime) value).getNanos(), 6); - calciteLiteral = rexBuilder.makeIntervalLiteral(secsValueBd.add(nanosValueBd), - new SqlIntervalQualifier(TimeUnit.DAY, TimeUnit.SECOND, new SqlParserPos(1,1))); - break; + // BigDecimal secsValueBd = BigDecimal + // .valueOf(((HiveIntervalDayTime) value).getTotalSeconds() * 1000); + // // Nanos converted to millis + // BigDecimal nanosValueBd = BigDecimal.valueOf(((HiveIntervalDayTime) + // value).getNanos(), 6); + // calciteLiteral = + // rexBuilder.makeIntervalLiteral(secsValueBd.add(nanosValueBd), + // new SqlIntervalQualifier(TimeUnit.MILLISECOND, null, new + // SqlParserPos(1, 1))); + // break; case VOID: calciteLiteral = cluster.getRexBuilder().makeLiteral(null, cluster.getTypeFactory().createSqlType(SqlTypeName.NULL), true); @@ -438,11 +465,6 @@ protected RexNode convert(ExprNodeConstantDesc literal) throws CalciteSemanticEx return calciteLiteral; } - private RexNode createNullLiteral(ExprNodeDesc expr) throws CalciteSemanticException { - return cluster.getRexBuilder().makeNullLiteral( - TypeConverter.convert(expr.getTypeInfo(), cluster.getTypeFactory()).getSqlTypeName()); - } - public static RexNode convert(RelOptCluster cluster, ExprNodeDesc joinCondnExprNode, List inputRels, LinkedHashMap relToHiveRR, Map> relToHiveColNameCalcitePosMap, boolean flattenExpr) 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 87b18b7..21423c1 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 @@ -40,6 +40,7 @@ import org.antlr.runtime.tree.TreeVisitorAction; import org.apache.calcite.plan.RelOptCluster; import org.apache.calcite.plan.RelOptPlanner; +import org.apache.calcite.plan.RelOptPlanner.Executor; import org.apache.calcite.plan.RelOptQuery; import org.apache.calcite.plan.RelOptRule; import org.apache.calcite.plan.RelOptSchema; @@ -119,6 +120,7 @@ import org.apache.hadoop.hive.ql.optimizer.calcite.HiveDefaultRelMetadataProvider; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveHepPlannerContext; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; +import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRexExecutorImpl; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveTypeSystemImpl; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveVolcanoPlannerContext; import org.apache.hadoop.hive.ql.optimizer.calcite.RelOptHiveTable; @@ -154,6 +156,7 @@ import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HivePreFilteringRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveProjectMergeRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveProjectSortTransposeRule; +import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveReduceExpressionsRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveRelFieldTrimmer; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveRulesRegistry; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveSortJoinReduceRule; @@ -881,9 +884,12 @@ public RelNode apply(RelOptCluster cluster, RelOptSchema relOptSchema, SchemaPlu // Create MD provider HiveDefaultRelMetadataProvider mdProvider = new HiveDefaultRelMetadataProvider(conf); + // Create executor + Executor executorProvider = new HiveRexExecutorImpl(cluster); + // 2. Apply pre-join order optimizations calcitePreCboPlan = applyPreJoinOrderingTransforms(calciteGenPlan, - mdProvider.getMetadataProvider()); + mdProvider.getMetadataProvider(), executorProvider); // 3. Apply join order optimizations: reordering MST algorithm // If join optimizations failed because of missing stats, we continue with @@ -935,7 +941,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(), + calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, false, mdProvider.getMetadataProvider(), null, HepMatchOrder.BOTTOM_UP, ProjectRemoveRule.INSTANCE, UnionMergeRule.INSTANCE, new ProjectMergeRule(false, HiveRelFactories.HIVE_PROJECT_FACTORY), @@ -979,7 +985,7 @@ public RelNode apply(RelOptCluster cluster, RelOptSchema relOptSchema, SchemaPlu // aggregation columns (HIVE-10627) if (profilesCBO.contains(ExtendedCBOProfile.WINDOWING_POSTPROCESSING)) { perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, false, mdProvider.getMetadataProvider(), + calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, false, mdProvider.getMetadataProvider(), null, HepMatchOrder.BOTTOM_UP, HiveWindowingFixRule.INSTANCE); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Window fixing rule"); } @@ -988,7 +994,7 @@ public RelNode apply(RelOptCluster cluster, RelOptSchema relOptSchema, SchemaPlu if (HiveConf.getBoolVar(conf, ConfVars.HIVE_CBO_RETPATH_HIVEOP)) { perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); // 8.1. Merge join into multijoin operators (if possible) - calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, true, mdProvider.getMetadataProvider(), + calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, true, mdProvider.getMetadataProvider(), null, HepMatchOrder.BOTTOM_UP, HiveJoinProjectTransposeRule.BOTH_PROJECT_INCLUDE_OUTER, HiveJoinProjectTransposeRule.LEFT_PROJECT_INCLUDE_OUTER, HiveJoinProjectTransposeRule.RIGHT_PROJECT_INCLUDE_OUTER, @@ -998,15 +1004,15 @@ public RelNode apply(RelOptCluster cluster, RelOptSchema relOptSchema, SchemaPlu HiveRelFieldTrimmer fieldTrimmer = new HiveRelFieldTrimmer(null, HiveRelFactories.HIVE_BUILDER.create(cluster, null)); calciteOptimizedPlan = fieldTrimmer.trim(calciteOptimizedPlan); - calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, false, mdProvider.getMetadataProvider(), + calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, false, mdProvider.getMetadataProvider(), null, HepMatchOrder.BOTTOM_UP, ProjectRemoveRule.INSTANCE, new ProjectMergeRule(false, HiveRelFactories.HIVE_PROJECT_FACTORY)); - calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, true, mdProvider.getMetadataProvider(), + calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, true, mdProvider.getMetadataProvider(), null, new HiveFilterProjectTSTransposeRule(Filter.class, HiveRelFactories.HIVE_FILTER_FACTORY, HiveProject.class, HiveRelFactories.HIVE_PROJECT_FACTORY, HiveTableScan.class)); // 8.2. Introduce exchange operators below join/multijoin operators - calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, false, mdProvider.getMetadataProvider(), + calciteOptimizedPlan = hepPlan(calciteOptimizedPlan, false, mdProvider.getMetadataProvider(), null, HepMatchOrder.BOTTOM_UP, HiveInsertExchange4JoinRule.EXCHANGE_BELOW_JOIN, HiveInsertExchange4JoinRule.EXCHANGE_BELOW_MULTIJOIN); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Translation from Calcite tree to Hive tree"); @@ -1031,9 +1037,11 @@ public RelNode apply(RelOptCluster cluster, RelOptSchema relOptSchema, SchemaPlu * original plan * @param mdProvider * meta data provider + * @param executorProvider + * executor * @return */ - private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProvider mdProvider) { + private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProvider mdProvider, Executor executorProvider) { // TODO: Decorelation of subquery should be done before attempting // Partition Pruning; otherwise Expression evaluation may try to execute // corelated sub query. @@ -1048,7 +1056,7 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv // Its not clear, if this rewrite is always performant on MR, since extra map phase // introduced for 2nd MR job may offset gains of this multi-stage aggregation. // We need a cost model for MR to enable this on MR. - basePlan = hepPlan(basePlan, true, mdProvider, HiveExpandDistinctAggregatesRule.INSTANCE); + basePlan = hepPlan(basePlan, true, mdProvider, null, HiveExpandDistinctAggregatesRule.INSTANCE); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Prejoin ordering transformation, Distinct aggregate rewrite"); } @@ -1059,7 +1067,7 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv // Ex: select * from R1 join R2 where ((R1.x=R2.x) and R1.y<10) or // ((R1.x=R2.x) and R1.z=10)) and rand(1) < 0.1 perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - basePlan = hepPlan(basePlan, false, mdProvider, HepMatchOrder.ARBITRARY, + basePlan = hepPlan(basePlan, false, mdProvider, null, HepMatchOrder.ARBITRARY, HivePreFilteringRule.INSTANCE); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Prejoin ordering transformation, factor out common filter elements and separating deterministic vs non-deterministic UDF"); @@ -1070,7 +1078,7 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv // TODO: Add in ReduceExpressionrules (Constant folding) to below once // HIVE-11927 is fixed. perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - basePlan = hepPlan(basePlan, true, mdProvider, HiveFilterProjectTransposeRule.INSTANCE_DETERMINISTIC, + basePlan = hepPlan(basePlan, true, mdProvider, null, HiveFilterProjectTransposeRule.INSTANCE_DETERMINISTIC, HiveFilterSetOpTransposeRule.INSTANCE, HiveFilterSortTransposeRule.INSTANCE, HiveFilterJoinRule.JOIN, HiveFilterJoinRule.FILTER_ON_JOIN, new HiveFilterAggregateTransposeRule(Filter.class, HiveRelFactories.HIVE_FILTER_FACTORY, Aggregate.class), new FilterMergeRule( @@ -1078,6 +1086,7 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Prejoin ordering transformation, PPD for old join syntax"); + // TODO: Transitive inference, constant prop & Predicate push down has to // do multiple passes till no more inference is left // Currently doing so would result in a spin. Just checking for if inferred @@ -1085,7 +1094,7 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv // could have been mutated by constant folding/prop // 4. Transitive inference for join on clauses perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - basePlan = hepPlan(basePlan, true, mdProvider, new HiveJoinPushTransitivePredicatesRule( + basePlan = hepPlan(basePlan, true, mdProvider, null, new HiveJoinPushTransitivePredicatesRule( Join.class, HiveRelFactories.HIVE_FILTER_FACTORY)); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Prejoin ordering transformation, Transitive inference for join on clauses"); @@ -1102,10 +1111,10 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv HiveConf.ConfVars.HIVE_OPTIMIZE_LIMIT_TRANSPOSE_REDUCTION_PERCENTAGE); final long reductionTuples = HiveConf.getLongVar(conf, HiveConf.ConfVars.HIVE_OPTIMIZE_LIMIT_TRANSPOSE_REDUCTION_TUPLES); - basePlan = hepPlan(basePlan, true, mdProvider, HiveSortMergeRule.INSTANCE, + basePlan = hepPlan(basePlan, true, mdProvider, null, HiveSortMergeRule.INSTANCE, HiveSortProjectTransposeRule.INSTANCE, HiveSortJoinReduceRule.INSTANCE, HiveSortUnionReduceRule.INSTANCE); - basePlan = hepPlan(basePlan, true, mdProvider, HepMatchOrder.BOTTOM_UP, + basePlan = hepPlan(basePlan, true, mdProvider, null, HepMatchOrder.BOTTOM_UP, new HiveSortRemoveRule(reductionProportion, reductionTuples), HiveProjectSortTransposeRule.INSTANCE); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, @@ -1114,7 +1123,7 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv // 6. Add not null filters perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - basePlan = hepPlan(basePlan, true, mdProvider, HiveJoinAddNotNullRule.INSTANCE); + basePlan = hepPlan(basePlan, true, mdProvider, null, HiveJoinAddNotNullRule.INSTANCE); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Prejoin ordering transformation, Add not null filters"); @@ -1122,7 +1131,7 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv // TODO: Add in ReduceExpressionrules (Constant folding) to below once // HIVE-11927 is fixed. perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - basePlan = hepPlan(basePlan, true, mdProvider, HiveFilterProjectTransposeRule.INSTANCE_DETERMINISTIC, + basePlan = hepPlan(basePlan, true, mdProvider, null, HiveFilterProjectTransposeRule.INSTANCE_DETERMINISTIC, HiveFilterSetOpTransposeRule.INSTANCE, HiveFilterSortTransposeRule.INSTANCE, HiveFilterJoinRule.JOIN, HiveFilterJoinRule.FILTER_ON_JOIN, new HiveFilterAggregateTransposeRule(Filter.class, HiveRelFactories.HIVE_FILTER_FACTORY, Aggregate.class), new FilterMergeRule( @@ -1132,18 +1141,26 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv // 8. Push Down Semi Joins perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - basePlan = hepPlan(basePlan, true, mdProvider, SemiJoinJoinTransposeRule.INSTANCE, + basePlan = hepPlan(basePlan, true, mdProvider, null, SemiJoinJoinTransposeRule.INSTANCE, SemiJoinFilterTransposeRule.INSTANCE, SemiJoinProjectTransposeRule.INSTANCE); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Prejoin ordering transformation, Push Down Semi Joins"); - // 9. Apply Partition Pruning + // 9. Constant folding + perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); + basePlan = hepPlan(basePlan, true, mdProvider, executorProvider, + HiveReduceExpressionsRule.PROJECT_INSTANCE, HiveReduceExpressionsRule.FILTER_INSTANCE, + HiveReduceExpressionsRule.JOIN_INSTANCE); + perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, + "Calcite: Prejoin ordering transformation, Constant folding"); + + // 10. Apply Partition Pruning perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - basePlan = hepPlan(basePlan, false, mdProvider, new HivePartitionPruneRule(conf)); + basePlan = hepPlan(basePlan, false, mdProvider, null, new HivePartitionPruneRule(conf)); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Prejoin ordering transformation, Partition Pruning"); - // 10. Projection Pruning (this introduces select above TS & hence needs to be run last due to PP) + // 11. Projection Pruning (this introduces select above TS & hence needs to be run last due to PP) perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); HiveRelFieldTrimmer fieldTrimmer = new HiveRelFieldTrimmer(null, HiveRelFactories.HIVE_BUILDER.create(cluster, null)); @@ -1151,19 +1168,19 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Prejoin ordering transformation, Projection Pruning"); - // 11. Merge Project-Project if possible + // 12. Merge Project-Project if possible perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - basePlan = hepPlan(basePlan, false, mdProvider, new ProjectMergeRule(true, + basePlan = hepPlan(basePlan, false, mdProvider, null, new ProjectMergeRule(true, HiveRelFactories.HIVE_PROJECT_FACTORY)); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, "Calcite: Prejoin ordering transformation, Merge Project-Project"); - // 12. Rerun PPD through Project as column pruning would have introduced + // 13. Rerun PPD through Project as column pruning would have introduced // DT above scans; By pushing filter just above TS, Hive can push it into // storage (incase there are filters on non partition cols). This only // matches FIL-PROJ-TS perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); - basePlan = hepPlan(basePlan, true, mdProvider, new HiveFilterProjectTSTransposeRule( + basePlan = hepPlan(basePlan, true, mdProvider, null, new HiveFilterProjectTSTransposeRule( Filter.class, HiveRelFactories.HIVE_FILTER_FACTORY, HiveProject.class, HiveRelFactories.HIVE_PROJECT_FACTORY, HiveTableScan.class)); perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER, @@ -1178,12 +1195,13 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv * @param basePlan * @param followPlanChanges * @param mdProvider + * @param executorProvider * @param rules * @return optimized RelNode */ private RelNode hepPlan(RelNode basePlan, boolean followPlanChanges, - RelMetadataProvider mdProvider, RelOptRule... rules) { - return hepPlan(basePlan, followPlanChanges, mdProvider, + RelMetadataProvider mdProvider, Executor executorProvider, RelOptRule... rules) { + return hepPlan(basePlan, followPlanChanges, mdProvider, executorProvider, HepMatchOrder.TOP_DOWN, rules); } @@ -1193,12 +1211,14 @@ private RelNode hepPlan(RelNode basePlan, boolean followPlanChanges, * @param basePlan * @param followPlanChanges * @param mdProvider + * @param executorProvider * @param order * @param rules * @return optimized RelNode */ - private RelNode hepPlan(RelNode basePlan, boolean followPlanChanges, RelMetadataProvider mdProvider, - HepMatchOrder order, RelOptRule... rules) { + private RelNode hepPlan(RelNode basePlan, boolean followPlanChanges, + RelMetadataProvider mdProvider, Executor executorProvider, HepMatchOrder order, + RelOptRule... rules) { RelNode optimizedRelNode = basePlan; HepProgramBuilder programBuilder = new HepProgramBuilder(); @@ -1214,6 +1234,7 @@ private RelNode hepPlan(RelNode basePlan, boolean followPlanChanges, RelMetadata HiveRulesRegistry registry = new HiveRulesRegistry(); HiveHepPlannerContext context = new HiveHepPlannerContext(registry); HepPlanner planner = new HepPlanner(programBuilder.build(), context); + List list = Lists.newArrayList(); list.add(mdProvider); planner.registerMetadataProviders(list); @@ -1221,10 +1242,9 @@ private RelNode hepPlan(RelNode basePlan, boolean followPlanChanges, RelMetadata basePlan.getCluster().setMetadataProvider( new CachingRelMetadataProvider(chainedProvider, planner)); - // Executor is required for constant-reduction rules; see [CALCITE-566] - final RexExecutorImpl executor = - new RexExecutorImpl(Schemas.createDataContext(null)); - basePlan.getCluster().getPlanner().setExecutor(executor); + if (executorProvider != null) { + basePlan.getCluster().getPlanner().setExecutor(executorProvider); + } planner.setRoot(basePlan); optimizedRelNode = planner.findBestExp(); diff --git a/ql/src/test/queries/clientpositive/cbo_const.q b/ql/src/test/queries/clientpositive/cbo_const.q new file mode 100644 index 0000000..e38e2da --- /dev/null +++ b/ql/src/test/queries/clientpositive/cbo_const.q @@ -0,0 +1,52 @@ +set hive.mapred.mode=nonstrict; +set hive.cbo.enable=true; + +select + interval_day_time('2 1:2:3'), + interval_day_time(cast('2 1:2:3' as string)), + interval_day_time(cast('2 1:2:3' as varchar(10))), + interval_day_time(cast('2 1:2:3' as char(10))), + interval_day_time('2 1:2:3') = interval '2 1:2:3' day to second +from src limit 1; + +select count(*) from srcpart join (select ds as ds, ds as `date` from srcpart group by ds) s on (srcpart.ds = s.ds) where s.`date` = '2008-04-08'; + +drop view t1; + +create table t1_new (key string, value string) partitioned by (ds string); + +insert overwrite table t1_new partition (ds = '2011-10-15') +select 'key1', 'value1' from src tablesample (1 rows); + +insert overwrite table t1_new partition (ds = '2011-10-16') +select 'key2', 'value2' from src tablesample (1 rows); + +create view t1 partitioned on (ds) as +select * from +( +select key, value, ds from t1_new +union all +select key, value, ds from t1_new +)subq; + +select * from t1 where ds = '2011-10-15'; + + +explain select array(1,2,3) from src; + +EXPLAIN +select key from (SELECT key from src where key = 1+3)s; + +select * from (select key from src where key = '1')subq; + +select '1'; + +select * from (select '1')subq; + +select * from (select key from src where false)subq; + +EXPLAIN +SELECT x.key, z.value, y.value +FROM src1 x JOIN src y ON (x.key = y.key and y.key = 1+2) +JOIN srcpart z ON (x.value = z.value and z.ds='2008-04-08' and z.hr=11+3); + diff --git a/ql/src/test/queries/clientpositive/constantfolding.q b/ql/src/test/queries/clientpositive/constantfolding.q new file mode 100644 index 0000000..4ddb710 --- /dev/null +++ b/ql/src/test/queries/clientpositive/constantfolding.q @@ -0,0 +1,88 @@ +set hive.mapred.mode=nonstrict; +set hive.optimize.ppd=true; + +-- SORT_QUERY_RESULTS + +select * from (select 'k2' as key, '1 ' as value from src limit 2)b +union all +select * from (select 'k3' as key, '' as value from src limit 2)b +union all +select * from (select 'k4' as key, ' ' as value from src limit 2)c; + + +drop table if exists union_all_bug_test_1; +drop table if exists union_all_bug_test_2; +create table if not exists union_all_bug_test_1 +( +f1 int, +f2 int +); + +create table if not exists union_all_bug_test_2 +( +f1 int +); + +insert into table union_all_bug_test_1 values (1,1); +insert into table union_all_bug_test_2 values (1); +insert into table union_all_bug_test_1 values (0,0); +insert into table union_all_bug_test_2 values (0); + + + +SELECT f1 +FROM ( + +SELECT +f1 +, if('helloworld' like '%hello%' ,f1,f2) as filter +FROM union_all_bug_test_1 + +union all + +select +f1 +, 0 as filter +from union_all_bug_test_2 +) A +WHERE (filter = 1 and f1 = 1); + + +select percentile(cast(key as bigint), array()) from src where false; + +select unbase64("0xe23") from src limit 1; + +SELECT key,randum123, h4 +FROM (SELECT *, cast(rand() as double) AS randum123, hex(4) AS h4 FROM src WHERE key = 100) a +WHERE a.h4 <= 3 limit 1; + +select null from src limit 1; + +-- numRows: 2 rawDataSize: 80 +explain select cast("1970-12-31 15:59:58.174" as TIMESTAMP) from src; + +-- numRows: 2 rawDataSize: 112 +explain select cast("1970-12-31 15:59:58.174" as DATE) from src; + +CREATE TABLE dest1(c1 STRING) STORED AS TEXTFILE; + +FROM src INSERT OVERWRITE TABLE dest1 SELECT ' abc ' WHERE src.key = 86; + +EXPLAIN +SELECT ROUND(LN(3.0),12), LN(0.0), LN(-1), ROUND(LOG(3.0),12), LOG(0.0), + LOG(-1), ROUND(LOG2(3.0),12), LOG2(0.0), LOG2(-1), + ROUND(LOG10(3.0),12), LOG10(0.0), LOG10(-1), ROUND(LOG(2, 3.0),12), + LOG(2, 0.0), LOG(2, -1), LOG(0.5, 2), LOG(2, 0.5), ROUND(EXP(2.0),12), + POW(2,3), POWER(2,3), POWER(2,-3), POWER(0.5, -3), POWER(4, 0.5), + POWER(-1, 0.5), POWER(-1, 2), POWER(CAST (1 AS DECIMAL), CAST (0 AS INT)), + POWER(CAST (2 AS DECIMAL), CAST (3 AS INT)), + POW(CAST (2 AS DECIMAL), CAST(3 AS INT)) FROM dest1; + +SELECT ROUND(LN(3.0),12), LN(0.0), LN(-1), ROUND(LOG(3.0),12), LOG(0.0), + LOG(-1), ROUND(LOG2(3.0),12), LOG2(0.0), LOG2(-1), + ROUND(LOG10(3.0),12), LOG10(0.0), LOG10(-1), ROUND(LOG(2, 3.0),12), + LOG(2, 0.0), LOG(2, -1), LOG(0.5, 2), LOG(2, 0.5), ROUND(EXP(2.0),12), + POW(2,3), POWER(2,3), POWER(2,-3), POWER(0.5, -3), POWER(4, 0.5), + POWER(-1, 0.5), POWER(-1, 2), POWER(CAST (1 AS DECIMAL), CAST (0 AS INT)), + POWER(CAST (2 AS DECIMAL), CAST (3 AS INT)), + POW(CAST (2 AS DECIMAL), CAST(3 AS INT)) FROM dest1; diff --git a/ql/src/test/results/clientpositive/annotate_stats_select.q.out b/ql/src/test/results/clientpositive/annotate_stats_select.q.out index c4d59c8..b158d85 100644 --- a/ql/src/test/results/clientpositive/annotate_stats_select.q.out +++ b/ql/src/test/results/clientpositive/annotate_stats_select.q.out @@ -925,24 +925,46 @@ POSTHOOK: query: -- inner select - numRows: 2 rawDataSize: 24 explain select x from (select i1,11.0 as x from alltypes_orc limit 10) temp POSTHOOK: type: QUERY STAGE DEPENDENCIES: - Stage-0 is a root stage + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 STAGE PLANS: - Stage: Stage-0 - Fetch Operator - limit: 10 - Processor Tree: - TableScan - alias: alltypes_orc - Statistics: Num rows: 2 Data size: 1686 Basic stats: COMPLETE Column stats: COMPLETE + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: alltypes_orc + Statistics: Num rows: 2 Data size: 1686 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE + Limit + Number of rows: 10 + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + sort order: + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Reduce Operator Tree: + Limit + Number of rows: 10 + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE Select Operator expressions: 11.0 (type: double) outputColumnNames: _col0 Statistics: Num rows: 2 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE - Limit - Number of rows: 10 + File Output Operator + compressed: false Statistics: Num rows: 2 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE - ListSink + 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 + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink PREHOOK: query: -- inner select - numRows: 2 rawDataSize: 104 -- outer select - numRows: 2 rawDataSize: 186 @@ -1024,21 +1046,21 @@ STAGE PLANS: alias: alltypes_orc Statistics: Num rows: 2 Data size: 1686 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - Statistics: Num rows: 2 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 10 - Statistics: Num rows: 2 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE Reduce Output Operator sort order: - Statistics: Num rows: 2 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE TopN Hash Memory Usage: 0.1 Reduce Operator Tree: Limit Number of rows: 10 - Statistics: Num rows: 2 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 10 - Statistics: Num rows: 2 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false table: @@ -1052,12 +1074,12 @@ STAGE PLANS: TableScan Reduce Output Operator sort order: - Statistics: Num rows: 2 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE TopN Hash Memory Usage: 0.1 Reduce Operator Tree: Limit Number of rows: 10 - Statistics: Num rows: 2 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE Select Operator expressions: 'hello' (type: string), 11.0 (type: double) outputColumnNames: _col0, _col1 diff --git a/ql/src/test/results/clientpositive/bucketizedhiveinputformat.q.out b/ql/src/test/results/clientpositive/bucketizedhiveinputformat.q.out index 277b0f7..cfb95be 100644 --- a/ql/src/test/results/clientpositive/bucketizedhiveinputformat.q.out +++ b/ql/src/test/results/clientpositive/bucketizedhiveinputformat.q.out @@ -22,6 +22,8 @@ POSTHOOK: query: CREATE TABLE T2(name STRING) STORED AS SEQUENCEFILE POSTHOOK: type: CREATETABLE POSTHOOK: Output: database:default POSTHOOK: Output: default@T2 +Warning: Shuffle Join JOIN[13][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Stage-2:MAPRED' is a cross product +Warning: Shuffle Join JOIN[10][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: INSERT OVERWRITE TABLE T2 SELECT * FROM ( SELECT tmp1.name as name FROM ( SELECT name, 'MMM' AS n FROM T1) tmp1 diff --git a/ql/src/test/results/clientpositive/cast1.q.out b/ql/src/test/results/clientpositive/cast1.q.out index 0bdecba..48a0c14 100644 --- a/ql/src/test/results/clientpositive/cast1.q.out +++ b/ql/src/test/results/clientpositive/cast1.q.out @@ -105,11 +105,11 @@ POSTHOOK: query: FROM src INSERT OVERWRITE TABLE dest1 SELECT 3 + 2, 3.0 + 2, 3 POSTHOOK: type: QUERY POSTHOOK: Input: default@src POSTHOOK: Output: default@dest1 -POSTHOOK: Lineage: dest1.c1 EXPRESSION [] -POSTHOOK: Lineage: dest1.c2 EXPRESSION [] -POSTHOOK: Lineage: dest1.c3 EXPRESSION [] -POSTHOOK: Lineage: dest1.c4 EXPRESSION [] -POSTHOOK: Lineage: dest1.c5 EXPRESSION [] +POSTHOOK: Lineage: dest1.c1 SIMPLE [] +POSTHOOK: Lineage: dest1.c2 SIMPLE [] +POSTHOOK: Lineage: dest1.c3 SIMPLE [] +POSTHOOK: Lineage: dest1.c4 SIMPLE [] +POSTHOOK: Lineage: dest1.c5 SIMPLE [] POSTHOOK: Lineage: dest1.c6 EXPRESSION [] POSTHOOK: Lineage: dest1.c7 EXPRESSION [] PREHOOK: query: select dest1.* FROM dest1 diff --git a/ql/src/test/results/clientpositive/cbo_const.q.out b/ql/src/test/results/clientpositive/cbo_const.q.out new file mode 100644 index 0000000..adc5232 --- /dev/null +++ b/ql/src/test/results/clientpositive/cbo_const.q.out @@ -0,0 +1,334 @@ +PREHOOK: query: select + interval_day_time('2 1:2:3'), + interval_day_time(cast('2 1:2:3' as string)), + interval_day_time(cast('2 1:2:3' as varchar(10))), + interval_day_time(cast('2 1:2:3' as char(10))), + interval_day_time('2 1:2:3') = interval '2 1:2:3' day to second +from src limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select + interval_day_time('2 1:2:3'), + interval_day_time(cast('2 1:2:3' as string)), + interval_day_time(cast('2 1:2:3' as varchar(10))), + interval_day_time(cast('2 1:2:3' as char(10))), + interval_day_time('2 1:2:3') = interval '2 1:2:3' day to second +from src limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +2 01:02:03.000000000 2 01:02:03.000000000 2 01:02:03.000000000 2 01:02:03.000000000 true +PREHOOK: query: select count(*) from srcpart join (select ds as ds, ds as `date` from srcpart group by ds) s on (srcpart.ds = s.ds) where s.`date` = '2008-04-08' +PREHOOK: type: QUERY +PREHOOK: Input: default@srcpart +PREHOOK: Input: default@srcpart@ds=2008-04-08/hr=11 +PREHOOK: Input: default@srcpart@ds=2008-04-08/hr=12 +PREHOOK: Input: default@srcpart@ds=2008-04-09/hr=11 +PREHOOK: Input: default@srcpart@ds=2008-04-09/hr=12 +#### A masked pattern was here #### +POSTHOOK: query: select count(*) from srcpart join (select ds as ds, ds as `date` from srcpart group by ds) s on (srcpart.ds = s.ds) where s.`date` = '2008-04-08' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@srcpart +POSTHOOK: Input: default@srcpart@ds=2008-04-08/hr=11 +POSTHOOK: Input: default@srcpart@ds=2008-04-08/hr=12 +POSTHOOK: Input: default@srcpart@ds=2008-04-09/hr=11 +POSTHOOK: Input: default@srcpart@ds=2008-04-09/hr=12 +#### A masked pattern was here #### +1000 +PREHOOK: query: drop view t1 +PREHOOK: type: DROPVIEW +POSTHOOK: query: drop view t1 +POSTHOOK: type: DROPVIEW +PREHOOK: query: create table t1_new (key string, value string) partitioned by (ds string) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@t1_new +POSTHOOK: query: create table t1_new (key string, value string) partitioned by (ds string) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t1_new +PREHOOK: query: insert overwrite table t1_new partition (ds = '2011-10-15') +select 'key1', 'value1' from src tablesample (1 rows) +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: default@t1_new@ds=2011-10-15 +POSTHOOK: query: insert overwrite table t1_new partition (ds = '2011-10-15') +select 'key1', 'value1' from src tablesample (1 rows) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: default@t1_new@ds=2011-10-15 +POSTHOOK: Lineage: t1_new PARTITION(ds=2011-10-15).key SIMPLE [] +POSTHOOK: Lineage: t1_new PARTITION(ds=2011-10-15).value SIMPLE [] +PREHOOK: query: insert overwrite table t1_new partition (ds = '2011-10-16') +select 'key2', 'value2' from src tablesample (1 rows) +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: default@t1_new@ds=2011-10-16 +POSTHOOK: query: insert overwrite table t1_new partition (ds = '2011-10-16') +select 'key2', 'value2' from src tablesample (1 rows) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: default@t1_new@ds=2011-10-16 +POSTHOOK: Lineage: t1_new PARTITION(ds=2011-10-16).key SIMPLE [] +POSTHOOK: Lineage: t1_new PARTITION(ds=2011-10-16).value SIMPLE [] +PREHOOK: query: create view t1 partitioned on (ds) as +select * from +( +select key, value, ds from t1_new +union all +select key, value, ds from t1_new +)subq +PREHOOK: type: CREATEVIEW +PREHOOK: Input: default@t1_new +PREHOOK: Output: database:default +PREHOOK: Output: default@t1 +POSTHOOK: query: create view t1 partitioned on (ds) as +select * from +( +select key, value, ds from t1_new +union all +select key, value, ds from t1_new +)subq +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: default@t1_new +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t1 +PREHOOK: query: select * from t1 where ds = '2011-10-15' +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t1_new +PREHOOK: Input: default@t1_new@ds=2011-10-15 +#### A masked pattern was here #### +POSTHOOK: query: select * from t1 where ds = '2011-10-15' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t1_new +POSTHOOK: Input: default@t1_new@ds=2011-10-15 +#### A masked pattern was here #### +key1 value1 2011-10-15 +key1 value1 2011-10-15 +PREHOOK: query: explain select array(1,2,3) from src +PREHOOK: type: QUERY +POSTHOOK: query: explain select array(1,2,3) from src +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: COMPLETE + Select Operator + expressions: array(1,2,3) (type: array) + outputColumnNames: _col0 + Statistics: Num rows: 500 Data size: 28000 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 500 Data size: 28000 Basic stats: COMPLETE Column stats: COMPLETE + 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 + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN +select key from (SELECT key from src where key = 1+3)s +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN +select key from (SELECT key from src where key = 1+3)s +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: (UDFToDouble(key) = 4.0) (type: boolean) + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: '4.0' (type: string) + outputColumnNames: _col0 + 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.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: select * from (select key from src where key = '1')subq +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key from src where key = '1')subq +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +PREHOOK: query: select '1' +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: select '1' +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +1 +PREHOOK: query: select * from (select '1')subq +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: select * from (select '1')subq +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +1 +PREHOOK: query: select * from (select key from src where false)subq +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key from src where false)subq +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +PREHOOK: query: EXPLAIN +SELECT x.key, z.value, y.value +FROM src1 x JOIN src y ON (x.key = y.key and y.key = 1+2) +JOIN srcpart z ON (x.value = z.value and z.ds='2008-04-08' and z.hr=11+3) +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN +SELECT x.key, z.value, y.value +FROM src1 x JOIN src y ON (x.key = y.key and y.key = 1+2) +JOIN srcpart z ON (x.value = z.value and z.ds='2008-04-08' and z.hr=11+3) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: y + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (UDFToDouble(key) = 3.0) (type: boolean) + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: '3.0' (type: string) + sort order: + + Map-reduce partition columns: '3.0' (type: string) + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: string) + TableScan + alias: x + Statistics: Num rows: 25 Data size: 191 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: ((UDFToDouble(key) = 3.0) and value is not null) (type: boolean) + Statistics: Num rows: 12 Data size: 91 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 12 Data size: 91 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: '3.0' (type: string) + sort order: + + Map-reduce partition columns: '3.0' (type: string) + Statistics: Num rows: 12 Data size: 91 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: string) + Reduce Operator Tree: + Join Operator + condition map: + Inner Join 0 to 1 + keys: + 0 _col0 (type: string) + 1 _col0 (type: string) + outputColumnNames: _col1, _col3 + Statistics: Num rows: 275 Data size: 2921 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 + Reduce Output Operator + key expressions: _col3 (type: string) + sort order: + + Map-reduce partition columns: _col3 (type: string) + Statistics: Num rows: 275 Data size: 2921 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: string) + TableScan + alias: z + Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + Filter Operator + predicate: (((UDFToDouble(hr) = 14.0) and (ds = '2008-04-08')) and value is not null) (type: boolean) + Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + Select Operator + expressions: value (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL 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: 0 Basic stats: PARTIAL Column stats: NONE + Reduce Operator Tree: + Join Operator + condition map: + Inner Join 0 to 1 + keys: + 0 _col3 (type: string) + 1 _col0 (type: string) + outputColumnNames: _col1, _col4 + Statistics: Num rows: 302 Data size: 3213 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: '3.0' (type: string), _col4 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 302 Data size: 3213 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 302 Data size: 3213 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 + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + diff --git a/ql/src/test/results/clientpositive/cbo_rp_cross_product_check_2.q.out b/ql/src/test/results/clientpositive/cbo_rp_cross_product_check_2.q.out index 13d8a50..ff3b9f6 100644 --- a/ql/src/test/results/clientpositive/cbo_rp_cross_product_check_2.q.out +++ b/ql/src/test/results/clientpositive/cbo_rp_cross_product_check_2.q.out @@ -327,8 +327,8 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Map Join MAPJOIN[22][bigTable=?] in task 'Stage-5:MAPRED' is a cross product -Warning: Map Join MAPJOIN[23][bigTable=?] in task 'Stage-3:MAPRED' is a cross product +Warning: Map Join MAPJOIN[21][bigTable=?] in task 'Stage-5:MAPRED' is a cross product +Warning: Map Join MAPJOIN[22][bigTable=?] in task 'Stage-3:MAPRED' is a cross product PREHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 PREHOOK: type: QUERY POSTHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 diff --git a/ql/src/test/results/clientpositive/cbo_rp_lineage2.q.out b/ql/src/test/results/clientpositive/cbo_rp_lineage2.q.out index 79f76bf..1b2a2ab 100644 --- a/ql/src/test/results/clientpositive/cbo_rp_lineage2.q.out +++ b/ql/src/test/results/clientpositive/cbo_rp_lineage2.q.out @@ -402,7 +402,7 @@ PREHOOK: query: select 3 * 5 from dest1 PREHOOK: type: QUERY PREHOOK: Input: default@dest1 #### A masked pattern was here #### -{"version":"1.0","engine":"mr","database":"default","hash":"753abad4d55afd3df34fdc73abfcd44d","queryText":"select 3 * 5 from dest1","edges":[{"sources":[],"targets":[0],"expression":"(3 * 5)","edgeType":"PROJECTION"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"_c0"}]} +{"version":"1.0","engine":"mr","database":"default","hash":"753abad4d55afd3df34fdc73abfcd44d","queryText":"select 3 * 5 from dest1","edges":[{"sources":[],"targets":[0],"expression":"15","edgeType":"PROJECTION"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"_c0"}]} 15 15 15 diff --git a/ql/src/test/results/clientpositive/constantfolding.q.out b/ql/src/test/results/clientpositive/constantfolding.q.out new file mode 100644 index 0000000..1e86127 --- /dev/null +++ b/ql/src/test/results/clientpositive/constantfolding.q.out @@ -0,0 +1,305 @@ +PREHOOK: query: -- SORT_QUERY_RESULTS + +select * from (select 'k2' as key, '1 ' as value from src limit 2)b +union all +select * from (select 'k3' as key, '' as value from src limit 2)b +union all +select * from (select 'k4' as key, ' ' as value from src limit 2)c +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: -- SORT_QUERY_RESULTS + +select * from (select 'k2' as key, '1 ' as value from src limit 2)b +union all +select * from (select 'k3' as key, '' as value from src limit 2)b +union all +select * from (select 'k4' as key, ' ' as value from src limit 2)c +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +k2 1 +k2 1 +k3 +k3 +k4 +k4 +PREHOOK: query: drop table if exists union_all_bug_test_1 +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists union_all_bug_test_1 +POSTHOOK: type: DROPTABLE +PREHOOK: query: drop table if exists union_all_bug_test_2 +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists union_all_bug_test_2 +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table if not exists union_all_bug_test_1 +( +f1 int, +f2 int +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@union_all_bug_test_1 +POSTHOOK: query: create table if not exists union_all_bug_test_1 +( +f1 int, +f2 int +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@union_all_bug_test_1 +PREHOOK: query: create table if not exists union_all_bug_test_2 +( +f1 int +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@union_all_bug_test_2 +POSTHOOK: query: create table if not exists union_all_bug_test_2 +( +f1 int +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@union_all_bug_test_2 +PREHOOK: query: insert into table union_all_bug_test_1 values (1,1) +PREHOOK: type: QUERY +PREHOOK: Input: default@values__tmp__table__1 +PREHOOK: Output: default@union_all_bug_test_1 +POSTHOOK: query: insert into table union_all_bug_test_1 values (1,1) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@values__tmp__table__1 +POSTHOOK: Output: default@union_all_bug_test_1 +POSTHOOK: Lineage: union_all_bug_test_1.f1 EXPRESSION [(values__tmp__table__1)values__tmp__table__1.FieldSchema(name:tmp_values_col1, type:string, comment:), ] +POSTHOOK: Lineage: union_all_bug_test_1.f2 EXPRESSION [(values__tmp__table__1)values__tmp__table__1.FieldSchema(name:tmp_values_col2, type:string, comment:), ] +PREHOOK: query: insert into table union_all_bug_test_2 values (1) +PREHOOK: type: QUERY +PREHOOK: Input: default@values__tmp__table__2 +PREHOOK: Output: default@union_all_bug_test_2 +POSTHOOK: query: insert into table union_all_bug_test_2 values (1) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@values__tmp__table__2 +POSTHOOK: Output: default@union_all_bug_test_2 +POSTHOOK: Lineage: union_all_bug_test_2.f1 EXPRESSION [(values__tmp__table__2)values__tmp__table__2.FieldSchema(name:tmp_values_col1, type:string, comment:), ] +PREHOOK: query: insert into table union_all_bug_test_1 values (0,0) +PREHOOK: type: QUERY +PREHOOK: Input: default@values__tmp__table__3 +PREHOOK: Output: default@union_all_bug_test_1 +POSTHOOK: query: insert into table union_all_bug_test_1 values (0,0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@values__tmp__table__3 +POSTHOOK: Output: default@union_all_bug_test_1 +POSTHOOK: Lineage: union_all_bug_test_1.f1 EXPRESSION [(values__tmp__table__3)values__tmp__table__3.FieldSchema(name:tmp_values_col1, type:string, comment:), ] +POSTHOOK: Lineage: union_all_bug_test_1.f2 EXPRESSION [(values__tmp__table__3)values__tmp__table__3.FieldSchema(name:tmp_values_col2, type:string, comment:), ] +PREHOOK: query: insert into table union_all_bug_test_2 values (0) +PREHOOK: type: QUERY +PREHOOK: Input: default@values__tmp__table__4 +PREHOOK: Output: default@union_all_bug_test_2 +POSTHOOK: query: insert into table union_all_bug_test_2 values (0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@values__tmp__table__4 +POSTHOOK: Output: default@union_all_bug_test_2 +POSTHOOK: Lineage: union_all_bug_test_2.f1 EXPRESSION [(values__tmp__table__4)values__tmp__table__4.FieldSchema(name:tmp_values_col1, type:string, comment:), ] +PREHOOK: query: SELECT f1 +FROM ( + +SELECT +f1 +, if('helloworld' like '%hello%' ,f1,f2) as filter +FROM union_all_bug_test_1 + +union all + +select +f1 +, 0 as filter +from union_all_bug_test_2 +) A +WHERE (filter = 1 and f1 = 1) +PREHOOK: type: QUERY +PREHOOK: Input: default@union_all_bug_test_1 +PREHOOK: Input: default@union_all_bug_test_2 +#### A masked pattern was here #### +POSTHOOK: query: SELECT f1 +FROM ( + +SELECT +f1 +, if('helloworld' like '%hello%' ,f1,f2) as filter +FROM union_all_bug_test_1 + +union all + +select +f1 +, 0 as filter +from union_all_bug_test_2 +) A +WHERE (filter = 1 and f1 = 1) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@union_all_bug_test_1 +POSTHOOK: Input: default@union_all_bug_test_2 +#### A masked pattern was here #### +1 +PREHOOK: query: select percentile(cast(key as bigint), array()) from src where false +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select percentile(cast(key as bigint), array()) from src where false +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +NULL +PREHOOK: query: select unbase64("0xe23") from src limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select unbase64("0xe23") from src limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +�� +PREHOOK: query: SELECT key,randum123, h4 +FROM (SELECT *, cast(rand() as double) AS randum123, hex(4) AS h4 FROM src WHERE key = 100) a +WHERE a.h4 <= 3 limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: SELECT key,randum123, h4 +FROM (SELECT *, cast(rand() as double) AS randum123, hex(4) AS h4 FROM src WHERE key = 100) a +WHERE a.h4 <= 3 limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +PREHOOK: query: select null from src limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select null from src limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +NULL +PREHOOK: query: -- numRows: 2 rawDataSize: 80 +explain select cast("1970-12-31 15:59:58.174" as TIMESTAMP) from src +PREHOOK: type: QUERY +POSTHOOK: query: -- numRows: 2 rawDataSize: 80 +explain select cast("1970-12-31 15:59:58.174" as TIMESTAMP) from src +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: 1970-12-31 15:59:58.174 (type: timestamp) + outputColumnNames: _col0 + Statistics: Num rows: 500 Data size: 20000 Basic stats: COMPLETE Column stats: COMPLETE + ListSink + +PREHOOK: query: -- numRows: 2 rawDataSize: 112 +explain select cast("1970-12-31 15:59:58.174" as DATE) from src +PREHOOK: type: QUERY +POSTHOOK: query: -- numRows: 2 rawDataSize: 112 +explain select cast("1970-12-31 15:59:58.174" as DATE) from src +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: null (type: date) + outputColumnNames: _col0 + Statistics: Num rows: 500 Data size: 0 Basic stats: PARTIAL Column stats: COMPLETE + ListSink + +PREHOOK: query: CREATE TABLE dest1(c1 STRING) STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@dest1 +POSTHOOK: query: CREATE TABLE dest1(c1 STRING) STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@dest1 +PREHOOK: query: FROM src INSERT OVERWRITE TABLE dest1 SELECT ' abc ' WHERE src.key = 86 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: default@dest1 +POSTHOOK: query: FROM src INSERT OVERWRITE TABLE dest1 SELECT ' abc ' WHERE src.key = 86 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: default@dest1 +POSTHOOK: Lineage: dest1.c1 SIMPLE [] +PREHOOK: query: EXPLAIN +SELECT ROUND(LN(3.0),12), LN(0.0), LN(-1), ROUND(LOG(3.0),12), LOG(0.0), + LOG(-1), ROUND(LOG2(3.0),12), LOG2(0.0), LOG2(-1), + ROUND(LOG10(3.0),12), LOG10(0.0), LOG10(-1), ROUND(LOG(2, 3.0),12), + LOG(2, 0.0), LOG(2, -1), LOG(0.5, 2), LOG(2, 0.5), ROUND(EXP(2.0),12), + POW(2,3), POWER(2,3), POWER(2,-3), POWER(0.5, -3), POWER(4, 0.5), + POWER(-1, 0.5), POWER(-1, 2), POWER(CAST (1 AS DECIMAL), CAST (0 AS INT)), + POWER(CAST (2 AS DECIMAL), CAST (3 AS INT)), + POW(CAST (2 AS DECIMAL), CAST(3 AS INT)) FROM dest1 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN +SELECT ROUND(LN(3.0),12), LN(0.0), LN(-1), ROUND(LOG(3.0),12), LOG(0.0), + LOG(-1), ROUND(LOG2(3.0),12), LOG2(0.0), LOG2(-1), + ROUND(LOG10(3.0),12), LOG10(0.0), LOG10(-1), ROUND(LOG(2, 3.0),12), + LOG(2, 0.0), LOG(2, -1), LOG(0.5, 2), LOG(2, 0.5), ROUND(EXP(2.0),12), + POW(2,3), POWER(2,3), POWER(2,-3), POWER(0.5, -3), POWER(4, 0.5), + POWER(-1, 0.5), POWER(-1, 2), POWER(CAST (1 AS DECIMAL), CAST (0 AS INT)), + POWER(CAST (2 AS DECIMAL), CAST (3 AS INT)), + POW(CAST (2 AS DECIMAL), CAST(3 AS INT)) FROM dest1 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: dest1 + Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: 1.098612288668 (type: double), null (type: double), null (type: double), 1.098612288668 (type: double), null (type: double), null (type: double), 1.584962500721 (type: double), null (type: double), null (type: double), 0.47712125472 (type: double), null (type: double), null (type: double), 1.584962500721 (type: double), null (type: double), null (type: double), null (type: double), -1.0 (type: double), 7.389056098931 (type: double), 8.0 (type: double), 8.0 (type: double), 0.125 (type: double), 8.0 (type: double), 2.0 (type: double), NaN (type: double), 1.0 (type: double), 1.0 (type: double), 8.0 (type: double), 8.0 (type: double) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21, _col22, _col23, _col24, _col25, _col26, _col27 + Statistics: Num rows: 1 Data size: 136 Basic stats: COMPLETE Column stats: COMPLETE + ListSink + +PREHOOK: query: SELECT ROUND(LN(3.0),12), LN(0.0), LN(-1), ROUND(LOG(3.0),12), LOG(0.0), + LOG(-1), ROUND(LOG2(3.0),12), LOG2(0.0), LOG2(-1), + ROUND(LOG10(3.0),12), LOG10(0.0), LOG10(-1), ROUND(LOG(2, 3.0),12), + LOG(2, 0.0), LOG(2, -1), LOG(0.5, 2), LOG(2, 0.5), ROUND(EXP(2.0),12), + POW(2,3), POWER(2,3), POWER(2,-3), POWER(0.5, -3), POWER(4, 0.5), + POWER(-1, 0.5), POWER(-1, 2), POWER(CAST (1 AS DECIMAL), CAST (0 AS INT)), + POWER(CAST (2 AS DECIMAL), CAST (3 AS INT)), + POW(CAST (2 AS DECIMAL), CAST(3 AS INT)) FROM dest1 +PREHOOK: type: QUERY +PREHOOK: Input: default@dest1 +#### A masked pattern was here #### +POSTHOOK: query: SELECT ROUND(LN(3.0),12), LN(0.0), LN(-1), ROUND(LOG(3.0),12), LOG(0.0), + LOG(-1), ROUND(LOG2(3.0),12), LOG2(0.0), LOG2(-1), + ROUND(LOG10(3.0),12), LOG10(0.0), LOG10(-1), ROUND(LOG(2, 3.0),12), + LOG(2, 0.0), LOG(2, -1), LOG(0.5, 2), LOG(2, 0.5), ROUND(EXP(2.0),12), + POW(2,3), POWER(2,3), POWER(2,-3), POWER(0.5, -3), POWER(4, 0.5), + POWER(-1, 0.5), POWER(-1, 2), POWER(CAST (1 AS DECIMAL), CAST (0 AS INT)), + POWER(CAST (2 AS DECIMAL), CAST (3 AS INT)), + POW(CAST (2 AS DECIMAL), CAST(3 AS INT)) FROM dest1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@dest1 +#### A masked pattern was here #### +1.098612288668 NULL NULL 1.098612288668 NULL NULL 1.584962500721 NULL NULL 0.47712125472 NULL NULL 1.584962500721 NULL NULL NULL -1.0 7.389056098931 8.0 8.0 0.125 8.0 2.0 NaN 1.0 1.0 8.0 8.0 diff --git a/ql/src/test/results/clientpositive/cross_product_check_1.q.out b/ql/src/test/results/clientpositive/cross_product_check_1.q.out index d9143c8..05eb270 100644 --- a/ql/src/test/results/clientpositive/cross_product_check_1.q.out +++ b/ql/src/test/results/clientpositive/cross_product_check_1.q.out @@ -326,8 +326,8 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[19][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product -Warning: Shuffle Join JOIN[10][tables = [$hdt$_1, $hdt$_2]] in Stage 'Stage-2:MAPRED' is a cross product +Warning: Shuffle Join JOIN[18][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[9][tables = [$hdt$_1, $hdt$_2]] in Stage 'Stage-2:MAPRED' is a cross product PREHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 PREHOOK: type: QUERY POSTHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 diff --git a/ql/src/test/results/clientpositive/cross_product_check_2.q.out b/ql/src/test/results/clientpositive/cross_product_check_2.q.out index 4e2b93e..625a465 100644 --- a/ql/src/test/results/clientpositive/cross_product_check_2.q.out +++ b/ql/src/test/results/clientpositive/cross_product_check_2.q.out @@ -323,8 +323,8 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Map Join MAPJOIN[26][bigTable=?] in task 'Stage-5:MAPRED' is a cross product -Warning: Map Join MAPJOIN[27][bigTable=?] in task 'Stage-3:MAPRED' is a cross product +Warning: Map Join MAPJOIN[25][bigTable=?] in task 'Stage-5:MAPRED' is a cross product +Warning: Map Join MAPJOIN[26][bigTable=?] in task 'Stage-3:MAPRED' is a cross product PREHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 PREHOOK: type: QUERY POSTHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 diff --git a/ql/src/test/results/clientpositive/dynamic_rdd_cache.q.out b/ql/src/test/results/clientpositive/dynamic_rdd_cache.q.out index 3153c7e..66d9a78 100644 --- a/ql/src/test/results/clientpositive/dynamic_rdd_cache.q.out +++ b/ql/src/test/results/clientpositive/dynamic_rdd_cache.q.out @@ -1046,12 +1046,12 @@ STAGE PLANS: outputColumnNames: _col2, _col4, _col5, _col6 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col4 (type: int), _col5 (type: int), _col6 (type: string), 3 (type: int), _col2 (type: int) - outputColumnNames: _col4, _col5, _col6, _col9, _col2 + expressions: _col6 (type: string), _col5 (type: int), _col4 (type: int), _col2 (type: int) + outputColumnNames: _col0, _col1, _col2, _col4 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Group By Operator - aggregations: stddev_samp(_col2), avg(_col2) - keys: _col4 (type: int), _col5 (type: int), _col6 (type: string), _col9 (type: int) + aggregations: avg(_col4), stddev_samp(_col4) + keys: _col0 (type: string), _col1 (type: int), _col2 (type: int), 3 (type: int) mode: hash outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE @@ -1067,28 +1067,28 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int) + key expressions: _col0 (type: string), _col1 (type: int), _col2 (type: int), _col3 (type: int) sort order: ++++ - Map-reduce partition columns: _col0 (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int) + Map-reduce partition columns: _col0 (type: string), _col1 (type: int), _col2 (type: int), _col3 (type: int) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - value expressions: _col4 (type: struct), _col5 (type: struct) + value expressions: _col4 (type: struct), _col5 (type: struct) Reduce Operator Tree: Group By Operator - aggregations: stddev_samp(VALUE._col0), avg(VALUE._col1) - keys: KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: int) + aggregations: avg(VALUE._col0), stddev_samp(VALUE._col1) + keys: KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: int), KEY._col3 (type: int) mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col1 (type: int), _col0 (type: int), _col3 (type: int), _col4 (type: double), _col5 (type: double) - outputColumnNames: _col1, _col2, _col3, _col4, _col5 + expressions: _col1 (type: int), _col2 (type: int), _col4 (type: double), _col5 (type: double) + outputColumnNames: _col1, _col2, _col4, _col5 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Filter Operator - predicate: (CASE (_col5) WHEN (0) THEN (0) ELSE ((_col4 / _col5)) END > 1.0) (type: boolean) + predicate: (CASE (_col4) WHEN (0) THEN (0) ELSE ((_col5 / _col4)) END > 1.0) (type: boolean) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col1 (type: int), _col2 (type: int), _col3 (type: int), _col5 (type: double), CASE (_col5) WHEN (0) THEN (null) ELSE ((_col4 / _col5)) END (type: double) - outputColumnNames: _col1, _col2, _col3, _col4, _col5 + expressions: _col1 (type: int), _col2 (type: int), _col4 (type: double), CASE (_col4) WHEN (0) THEN (null) ELSE ((_col5 / _col4)) END (type: double) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE File Output Operator compressed: true @@ -1102,11 +1102,11 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col2 (type: int), _col1 (type: int) + key expressions: _col1 (type: int), _col0 (type: int) sort order: ++ - Map-reduce partition columns: _col2 (type: int), _col1 (type: int) + Map-reduce partition columns: _col1 (type: int), _col0 (type: int) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - value expressions: _col3 (type: int), _col4 (type: double), _col5 (type: double) + value expressions: _col2 (type: double), _col3 (type: double) TableScan Reduce Output Operator key expressions: _col2 (type: int), _col1 (type: int) @@ -1119,13 +1119,13 @@ STAGE PLANS: condition map: Inner Join 0 to 1 keys: - 0 _col2 (type: int), _col1 (type: int) + 0 _col1 (type: int), _col0 (type: int) 1 _col2 (type: int), _col1 (type: int) - outputColumnNames: _col1, _col2, _col3, _col4, _col5, _col7, _col8, _col9, _col10, _col11 + outputColumnNames: _col0, _col1, _col2, _col3, _col5, _col6, _col7, _col8, _col9 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: double), _col5 (type: double), _col7 (type: int), _col8 (type: int), _col9 (type: int), _col10 (type: double), _col11 (type: double) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9 + expressions: _col0 (type: int), _col1 (type: int), _col2 (type: double), _col3 (type: double), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col8 (type: double), _col9 (type: double) + outputColumnNames: _col0, _col1, _col3, _col4, _col5, _col6, _col7, _col8, _col9 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE File Output Operator compressed: true @@ -1139,13 +1139,13 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: double), _col4 (type: double), _col7 (type: int), _col8 (type: double), _col9 (type: double) + key expressions: _col0 (type: int), _col1 (type: int), 3 (type: int), _col3 (type: double), _col4 (type: double), _col7 (type: int), _col8 (type: double), _col9 (type: double) sort order: ++++++++ Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE value expressions: _col5 (type: int), _col6 (type: int) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int), KEY.reducesinkkey2 (type: int), KEY.reducesinkkey3 (type: double), KEY.reducesinkkey4 (type: double), VALUE._col0 (type: int), VALUE._col1 (type: int), KEY.reducesinkkey5 (type: int), KEY.reducesinkkey6 (type: double), KEY.reducesinkkey7 (type: double) + expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int), 3 (type: int), KEY.reducesinkkey3 (type: double), KEY.reducesinkkey4 (type: double), VALUE._col0 (type: int), VALUE._col1 (type: int), KEY.reducesinkkey5 (type: int), KEY.reducesinkkey6 (type: double), KEY.reducesinkkey7 (type: double) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/dynpart_sort_optimization2.q.out b/ql/src/test/results/clientpositive/dynpart_sort_optimization2.q.out index 24ac550..141bcd8 100644 --- a/ql/src/test/results/clientpositive/dynpart_sort_optimization2.q.out +++ b/ql/src/test/results/clientpositive/dynpart_sort_optimization2.q.out @@ -1560,7 +1560,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int), _col0 (type: string) + expressions: UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int), 'day' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -1642,8 +1642,9 @@ group by "day", key POSTHOOK: type: QUERY STAGE DEPENDENCIES: Stage-1 is a root stage - Stage-0 depends on stages: Stage-1 - Stage-2 depends on stages: Stage-0 + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + Stage-3 depends on stages: Stage-0 STAGE PLANS: Stage: Stage-1 @@ -1665,7 +1666,7 @@ STAGE PLANS: Reduce Output Operator key expressions: _col0 (type: string), _col1 (type: string) sort order: ++ - Map-reduce partition columns: _col0 (type: string) + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE value expressions: _col2 (type: bigint) Reduce Operator Tree: @@ -1676,17 +1677,39 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int), _col0 (type: string) + expressions: UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int), 'day' (type: string) 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.hive.ql.io.orc.OrcInputFormat - output format: org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat - serde: org.apache.hadoop.hive.ql.io.orc.OrcSerde - name: default.hive13_dp1 + 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 + Reduce Output Operator + key expressions: _col2 (type: string) + sort order: + + Map-reduce partition columns: _col2 (type: string) + Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE + value expressions: _col0 (type: int), _col1 (type: int), _col2 (type: string) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: int), VALUE._col1 (type: int), VALUE._col2 (type: string) + 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.hive.ql.io.orc.OrcInputFormat + output format: org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat + serde: org.apache.hadoop.hive.ql.io.orc.OrcSerde + name: default.hive13_dp1 Stage: Stage-0 Move Operator @@ -1700,7 +1723,7 @@ STAGE PLANS: serde: org.apache.hadoop.hive.ql.io.orc.OrcSerde name: default.hive13_dp1 - Stage: Stage-2 + Stage: Stage-3 Stats-Aggr Operator PREHOOK: query: insert overwrite table `hive13_dp1` partition(`day`) diff --git a/ql/src/test/results/clientpositive/groupby_ppd.q.out b/ql/src/test/results/clientpositive/groupby_ppd.q.out index 6164a26..e3e4a50 100644 --- a/ql/src/test/results/clientpositive/groupby_ppd.q.out +++ b/ql/src/test/results/clientpositive/groupby_ppd.q.out @@ -28,16 +28,16 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: foo (type: int) - outputColumnNames: _col1 + 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 Select Operator - expressions: 1 (type: int), _col1 (type: int) - outputColumnNames: _col0, _col1 + expressions: _col0 (type: int) + outputColumnNames: _col1 Statistics: Num rows: 2 Data size: 0 Basic stats: PARTIAL Column stats: NONE Group By Operator - keys: _col0 (type: int), _col1 (type: int) + keys: 1 (type: int), _col1 (type: int) mode: hash outputColumnNames: _col0, _col1 Statistics: Num rows: 2 Data size: 0 Basic stats: PARTIAL Column stats: NONE @@ -54,16 +54,16 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: foo (type: int) - outputColumnNames: _col1 + 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 Select Operator - expressions: 1 (type: int), _col1 (type: int) - outputColumnNames: _col0, _col1 + expressions: _col0 (type: int) + outputColumnNames: _col1 Statistics: Num rows: 2 Data size: 0 Basic stats: PARTIAL Column stats: NONE Group By Operator - keys: _col0 (type: int), _col1 (type: int) + keys: 1 (type: int), _col1 (type: int) mode: hash outputColumnNames: _col0, _col1 Statistics: Num rows: 2 Data size: 0 Basic stats: PARTIAL Column stats: NONE @@ -79,7 +79,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col1 (type: int), _col0 (type: int) + expressions: _col1 (type: int), 1 (type: int) outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/groupby_sort_1_23.q.out b/ql/src/test/results/clientpositive/groupby_sort_1_23.q.out index 7333677..ceecbb9 100644 --- a/ql/src/test/results/clientpositive/groupby_sort_1_23.q.out +++ b/ql/src/test/results/clientpositive/groupby_sort_1_23.q.out @@ -1510,7 +1510,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int) + expressions: 1 (type: int), UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -1942,7 +1942,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -4639,7 +4639,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -5054,7 +5054,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int), UDFToInteger(_col4) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), 2 (type: int), UDFToInteger(_col4) (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -5443,7 +5443,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -5901,7 +5901,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 2 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/groupby_sort_skew_1_23.q.out b/ql/src/test/results/clientpositive/groupby_sort_skew_1_23.q.out index e19d1de..009ab2e 100644 --- a/ql/src/test/results/clientpositive/groupby_sort_skew_1_23.q.out +++ b/ql/src/test/results/clientpositive/groupby_sort_skew_1_23.q.out @@ -1575,7 +1575,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int) + expressions: 1 (type: int), UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -2072,7 +2072,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -5094,7 +5094,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -5509,7 +5509,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int), UDFToInteger(_col4) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), 2 (type: int), UDFToInteger(_col4) (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -5898,7 +5898,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -6356,7 +6356,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 2 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/input_part1.q.out b/ql/src/test/results/clientpositive/input_part1.q.out index d6f4d3e..c5c46af 100644 --- a/ql/src/test/results/clientpositive/input_part1.q.out +++ b/ql/src/test/results/clientpositive/input_part1.q.out @@ -365,8 +365,8 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@srcpart POSTHOOK: Input: default@srcpart@ds=2008-04-08/hr=12 POSTHOOK: Output: default@dest1 -POSTHOOK: Lineage: dest1.ds SIMPLE [(srcpart)srcpart.FieldSchema(name:ds, type:string, comment:null), ] -POSTHOOK: Lineage: dest1.hr SIMPLE [(srcpart)srcpart.FieldSchema(name:hr, type:string, comment:null), ] +POSTHOOK: Lineage: dest1.ds SIMPLE [] +POSTHOOK: Lineage: dest1.hr SIMPLE [] POSTHOOK: Lineage: dest1.key EXPRESSION [(srcpart)srcpart.FieldSchema(name:key, type:string, comment:default), ] POSTHOOK: Lineage: dest1.value SIMPLE [(srcpart)srcpart.FieldSchema(name:value, type:string, comment:default), ] PREHOOK: query: SELECT dest1.* FROM dest1 diff --git a/ql/src/test/results/clientpositive/input_part5.q.out b/ql/src/test/results/clientpositive/input_part5.q.out index f2d7335..c6ae2fd 100644 --- a/ql/src/test/results/clientpositive/input_part5.q.out +++ b/ql/src/test/results/clientpositive/input_part5.q.out @@ -114,7 +114,7 @@ POSTHOOK: Input: default@srcpart@ds=2008-04-08/hr=11 POSTHOOK: Input: default@srcpart@ds=2008-04-08/hr=12 POSTHOOK: Output: default@tmptable POSTHOOK: Lineage: tmptable.ds SIMPLE [(srcpart)x.FieldSchema(name:hr, type:string, comment:null), ] -POSTHOOK: Lineage: tmptable.hr SIMPLE [(srcpart)x.FieldSchema(name:ds, type:string, comment:null), ] +POSTHOOK: Lineage: tmptable.hr SIMPLE [] POSTHOOK: Lineage: tmptable.key SIMPLE [(srcpart)x.FieldSchema(name:key, type:string, comment:default), ] POSTHOOK: Lineage: tmptable.value SIMPLE [(srcpart)x.FieldSchema(name:value, type:string, comment:default), ] PREHOOK: query: select * from tmptable x sort by x.key,x.value,x.ds,x.hr diff --git a/ql/src/test/results/clientpositive/input_part6.q.out b/ql/src/test/results/clientpositive/input_part6.q.out index fa51cdf..c01d8af 100644 --- a/ql/src/test/results/clientpositive/input_part6.q.out +++ b/ql/src/test/results/clientpositive/input_part6.q.out @@ -19,7 +19,7 @@ STAGE PLANS: predicate: (UDFToDouble(ds) = 1996.0) (type: boolean) Statistics: Num rows: 1000 Data size: 10624 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), '1996' (type: string), hr (type: string) + expressions: key (type: string), value (type: string), '1996.0' (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1000 Data size: 10624 Basic stats: COMPLETE Column stats: NONE Limit diff --git a/ql/src/test/results/clientpositive/lineage2.q.out b/ql/src/test/results/clientpositive/lineage2.q.out index ec8b76b..a189f82 100644 --- a/ql/src/test/results/clientpositive/lineage2.q.out +++ b/ql/src/test/results/clientpositive/lineage2.q.out @@ -402,7 +402,7 @@ PREHOOK: query: select 3 * 5 from dest1 PREHOOK: type: QUERY PREHOOK: Input: default@dest1 #### A masked pattern was here #### -{"version":"1.0","engine":"mr","database":"default","hash":"753abad4d55afd3df34fdc73abfcd44d","queryText":"select 3 * 5 from dest1","edges":[{"sources":[],"targets":[0],"expression":"(3 * 5)","edgeType":"PROJECTION"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"c0"}]} +{"version":"1.0","engine":"mr","database":"default","hash":"753abad4d55afd3df34fdc73abfcd44d","queryText":"select 3 * 5 from dest1","edges":[{"sources":[],"targets":[0],"expression":"15","edgeType":"PROJECTION"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"c0"}]} 15 15 15 diff --git a/ql/src/test/results/clientpositive/lineage3.q.out b/ql/src/test/results/clientpositive/lineage3.q.out index 747dc9a..f1162a2 100644 --- a/ql/src/test/results/clientpositive/lineage3.q.out +++ b/ql/src/test/results/clientpositive/lineage3.q.out @@ -166,7 +166,7 @@ where key in (select key+18 from src1) order by key PREHOOK: type: QUERY PREHOOK: Input: default@src1 #### A masked pattern was here #### -{"version":"1.0","engine":"mr","database":"default","hash":"8b9d63653e36ecf4dd425d3cc3de9199","queryText":"select key, value from src1\nwhere key in (select key+18 from src1) order by key","edges":[{"sources":[2],"targets":[0],"edgeType":"PROJECTION"},{"sources":[3],"targets":[1],"edgeType":"PROJECTION"},{"sources":[2],"targets":[0,1],"expression":"((1 = 1) and UDFToDouble(src1.key) is not null)","edgeType":"PREDICATE"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(src1.key) = (UDFToDouble(src1.key) + UDFToDouble(18)))","edgeType":"PREDICATE"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(src1.key) + UDFToDouble(18)) is not null","edgeType":"PREDICATE"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"key"},{"id":1,"vertexType":"COLUMN","vertexId":"value"},{"id":2,"vertexType":"COLUMN","vertexId":"default.src1.key"},{"id":3,"vertexType":"COLUMN","vertexId":"default.src1.value"}]} +{"version":"1.0","engine":"mr","database":"default","hash":"8b9d63653e36ecf4dd425d3cc3de9199","queryText":"select key, value from src1\nwhere key in (select key+18 from src1) order by key","edges":[{"sources":[2],"targets":[0],"edgeType":"PROJECTION"},{"sources":[3],"targets":[1],"edgeType":"PROJECTION"},{"sources":[2],"targets":[0,1],"expression":"UDFToDouble(src1.key) is not null","edgeType":"PREDICATE"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(src1.key) = (UDFToDouble(src1.key) + UDFToDouble(18)))","edgeType":"PREDICATE"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(src1.key) + UDFToDouble(18)) is not null","edgeType":"PREDICATE"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"key"},{"id":1,"vertexType":"COLUMN","vertexId":"value"},{"id":2,"vertexType":"COLUMN","vertexId":"default.src1.key"},{"id":3,"vertexType":"COLUMN","vertexId":"default.src1.value"}]} 146 val_146 273 val_273 PREHOOK: query: select * from src1 a @@ -178,15 +178,15 @@ PREHOOK: type: QUERY PREHOOK: Input: default@alltypesorc PREHOOK: Input: default@src1 #### A masked pattern was here #### -{"version":"1.0","engine":"mr","database":"default","hash":"8bf193b0658183be94e2428a79d91d10","queryText":"select * from src1 a\nwhere exists\n (select cint from alltypesorc b\n where a.key = b.ctinyint + 300)\nand key > 300","edges":[{"sources":[2],"targets":[0],"edgeType":"PROJECTION"},{"sources":[3],"targets":[1],"edgeType":"PROJECTION"},{"sources":[2],"targets":[0,1],"expression":"((UDFToDouble(a.key) > UDFToDouble(300)) and UDFToDouble(a.key) is not null)","edgeType":"PREDICATE"},{"sources":[2,4],"targets":[0,1],"expression":"(UDFToDouble(a.key) = UDFToDouble((UDFToInteger(b.ctinyint) + 300)))","edgeType":"PREDICATE"},{"sources":[4],"targets":[0,1],"expression":"((1 = 1) and UDFToDouble((UDFToInteger(b.ctinyint) + 300)) is not null)","edgeType":"PREDICATE"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"a.key"},{"id":1,"vertexType":"COLUMN","vertexId":"a.value"},{"id":2,"vertexType":"COLUMN","vertexId":"default.src1.key"},{"id":3,"vertexType":"COLUMN","vertexId":"default.src1.value"},{"id":4,"vertexType":"COLUMN","vertexId":"default.alltypesorc.ctinyint"}]} +{"version":"1.0","engine":"mr","database":"default","hash":"8bf193b0658183be94e2428a79d91d10","queryText":"select * from src1 a\nwhere exists\n (select cint from alltypesorc b\n where a.key = b.ctinyint + 300)\nand key > 300","edges":[{"sources":[2],"targets":[0],"edgeType":"PROJECTION"},{"sources":[3],"targets":[1],"edgeType":"PROJECTION"},{"sources":[2],"targets":[0,1],"expression":"((UDFToDouble(a.key) > UDFToDouble(300)) and UDFToDouble(a.key) is not null)","edgeType":"PREDICATE"},{"sources":[2,4],"targets":[0,1],"expression":"(UDFToDouble(a.key) = UDFToDouble((UDFToInteger(b.ctinyint) + 300)))","edgeType":"PREDICATE"},{"sources":[4],"targets":[0,1],"expression":"UDFToDouble((UDFToInteger(b.ctinyint) + 300)) is not null","edgeType":"PREDICATE"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"a.key"},{"id":1,"vertexType":"COLUMN","vertexId":"a.value"},{"id":2,"vertexType":"COLUMN","vertexId":"default.src1.key"},{"id":3,"vertexType":"COLUMN","vertexId":"default.src1.value"},{"id":4,"vertexType":"COLUMN","vertexId":"default.alltypesorc.ctinyint"}]} 311 val_311 -Warning: Shuffle Join JOIN[17][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[16][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: select key, value from src1 where key not in (select key+18 from src1) order by key PREHOOK: type: QUERY PREHOOK: Input: default@src1 #### A masked pattern was here #### -{"version":"1.0","engine":"mr","database":"default","hash":"9b488fe1d7cf018aad3825173808cd36","queryText":"select key, value from src1\nwhere key not in (select key+18 from src1) order by key","edges":[{"sources":[2],"targets":[0],"edgeType":"PROJECTION"},{"sources":[3],"targets":[1],"edgeType":"PROJECTION"},{"sources":[],"targets":[0,1],"expression":"(1 = 1)","edgeType":"PREDICATE"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(src1.key) + UDFToDouble(18)) is null","edgeType":"PREDICATE"},{"sources":[4],"targets":[0,1],"expression":"(count(*) = 0)","edgeType":"PREDICATE"},{"sources":[],"targets":[0,1],"expression":"true","edgeType":"PREDICATE"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(src1.key) = (UDFToDouble(src1.key) + UDFToDouble(18)))","edgeType":"PREDICATE"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"key"},{"id":1,"vertexType":"COLUMN","vertexId":"value"},{"id":2,"vertexType":"COLUMN","vertexId":"default.src1.key"},{"id":3,"vertexType":"COLUMN","vertexId":"default.src1.value"},{"id":4,"vertexType":"TABLE","vertexId":"default.src1"}]} +{"version":"1.0","engine":"mr","database":"default","hash":"9b488fe1d7cf018aad3825173808cd36","queryText":"select key, value from src1\nwhere key not in (select key+18 from src1) order by key","edges":[{"sources":[2],"targets":[0],"edgeType":"PROJECTION"},{"sources":[3],"targets":[1],"edgeType":"PROJECTION"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(src1.key) + UDFToDouble(18)) is null","edgeType":"PREDICATE"},{"sources":[4],"targets":[0,1],"expression":"(count(*) = 0)","edgeType":"PREDICATE"},{"sources":[],"targets":[0,1],"expression":"true","edgeType":"PREDICATE"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(src1.key) = (UDFToDouble(src1.key) + UDFToDouble(18)))","edgeType":"PREDICATE"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"key"},{"id":1,"vertexType":"COLUMN","vertexId":"value"},{"id":2,"vertexType":"COLUMN","vertexId":"default.src1.key"},{"id":3,"vertexType":"COLUMN","vertexId":"default.src1.value"},{"id":4,"vertexType":"TABLE","vertexId":"default.src1"}]} PREHOOK: query: select * from src1 a where not exists (select cint from alltypesorc b @@ -196,7 +196,7 @@ PREHOOK: type: QUERY PREHOOK: Input: default@alltypesorc PREHOOK: Input: default@src1 #### A masked pattern was here #### -{"version":"1.0","engine":"mr","database":"default","hash":"53191056e05af9080a30de853e8cea9c","queryText":"select * from src1 a\nwhere not exists\n (select cint from alltypesorc b\n where a.key = b.ctinyint + 300)\nand key > 300","edges":[{"sources":[2],"targets":[0],"edgeType":"PROJECTION"},{"sources":[3],"targets":[1],"edgeType":"PROJECTION"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(a.key) > UDFToDouble(300))","edgeType":"PREDICATE"},{"sources":[2,4],"targets":[0,1],"expression":"(UDFToDouble(a.key) = UDFToDouble((UDFToInteger(b.ctinyint) + 300)))","edgeType":"PREDICATE"},{"sources":[],"targets":[0,1],"expression":"(1 = 1)","edgeType":"PREDICATE"},{"sources":[4],"targets":[0,1],"expression":"(UDFToInteger(b.ctinyint) + 300) is null","edgeType":"PREDICATE"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"a.key"},{"id":1,"vertexType":"COLUMN","vertexId":"a.value"},{"id":2,"vertexType":"COLUMN","vertexId":"default.src1.key"},{"id":3,"vertexType":"COLUMN","vertexId":"default.src1.value"},{"id":4,"vertexType":"COLUMN","vertexId":"default.alltypesorc.ctinyint"}]} +{"version":"1.0","engine":"mr","database":"default","hash":"53191056e05af9080a30de853e8cea9c","queryText":"select * from src1 a\nwhere not exists\n (select cint from alltypesorc b\n where a.key = b.ctinyint + 300)\nand key > 300","edges":[{"sources":[2],"targets":[0],"edgeType":"PROJECTION"},{"sources":[3],"targets":[1],"edgeType":"PROJECTION"},{"sources":[2],"targets":[0,1],"expression":"(UDFToDouble(a.key) > UDFToDouble(300))","edgeType":"PREDICATE"},{"sources":[2,4],"targets":[0,1],"expression":"(UDFToDouble(a.key) = UDFToDouble((UDFToInteger(b.ctinyint) + 300)))","edgeType":"PREDICATE"},{"sources":[4],"targets":[0,1],"expression":"(UDFToInteger(b.ctinyint) + 300) is null","edgeType":"PREDICATE"}],"vertices":[{"id":0,"vertexType":"COLUMN","vertexId":"a.key"},{"id":1,"vertexType":"COLUMN","vertexId":"a.value"},{"id":2,"vertexType":"COLUMN","vertexId":"default.src1.key"},{"id":3,"vertexType":"COLUMN","vertexId":"default.src1.value"},{"id":4,"vertexType":"COLUMN","vertexId":"default.alltypesorc.ctinyint"}]} 369 401 val_401 406 val_406 diff --git a/ql/src/test/results/clientpositive/list_bucket_query_oneskew_2.q.out b/ql/src/test/results/clientpositive/list_bucket_query_oneskew_2.q.out index be77ba8..48cc6ea 100644 --- a/ql/src/test/results/clientpositive/list_bucket_query_oneskew_2.q.out +++ b/ql/src/test/results/clientpositive/list_bucket_query_oneskew_2.q.out @@ -690,12 +690,10 @@ STAGE PLANS: predicate: (x = 484) (type: boolean) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 484 (type: int) - outputColumnNames: _col0 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1) - keys: _col0 (type: int) + keys: 484 (type: int) mode: hash outputColumnNames: _col0, _col1 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE @@ -766,28 +764,32 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - GlobalTableId: 0 -#### A masked pattern was here #### - NumFilesPerFileSink: 1 + Select Operator + expressions: 484 (type: int), _col1 (type: bigint) + outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE -#### A masked pattern was here #### - table: - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - properties: - columns _col0,_col1 - columns.types int:bigint - 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 + File Output Operator + compressed: false + GlobalTableId: 0 +#### A masked pattern was here #### + NumFilesPerFileSink: 1 + Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE +#### A masked pattern was here #### + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + properties: + columns _col0,_col1 + columns.types int:bigint + 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 Stage: Stage-0 Fetch Operator diff --git a/ql/src/test/results/clientpositive/llap/bucket_map_join_tez1.q.out b/ql/src/test/results/clientpositive/llap/bucket_map_join_tez1.q.out index 79348f3..0f8167b 100644 --- a/ql/src/test/results/clientpositive/llap/bucket_map_join_tez1.q.out +++ b/ql/src/test/results/clientpositive/llap/bucket_map_join_tez1.q.out @@ -1519,7 +1519,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@srcbucket_mapjoin POSTHOOK: Input: default@srcbucket_mapjoin@ds=2008-04-08 POSTHOOK: Output: default@tab@ds=2008-04-08 -POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:key, type:int, comment:null), ] +POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [] POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).value SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:value, type:string, comment:null), ] PREHOOK: query: explain select count(*) @@ -1635,7 +1635,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@srcbucket_mapjoin POSTHOOK: Input: default@srcbucket_mapjoin@ds=2008-04-08 POSTHOOK: Output: default@tab@ds=2008-04-08 -POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:key, type:int, comment:null), ] +POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [] POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).value SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:value, type:string, comment:null), ] PREHOOK: query: explain select count(*) diff --git a/ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out b/ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out index f6d8388..90032fe 100644 --- a/ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out +++ b/ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out @@ -768,23 +768,23 @@ STAGE PLANS: alias: orc_pred Statistics: Num rows: 1049 Data size: 311170 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) - Statistics: Num rows: 4 Data size: 1186 Basic stats: COMPLETE Column stats: NONE + predicate: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (t > 0)) and si BETWEEN 300 AND 400) and (not (s like '%car%'))) (type: boolean) + Statistics: Num rows: 5 Data size: 1483 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 4 Data size: 1186 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 1483 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col3 (type: string) sort order: - - Statistics: Num rows: 4 Data size: 1186 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 1483 Basic stats: COMPLETE Column stats: NONE TopN Hash Memory Usage: 0.1 value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Reduce Operator Tree: Select Operator expressions: VALUE._col0 (type: tinyint), VALUE._col1 (type: smallint), VALUE._col2 (type: double), KEY.reducesinkkey0 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 4 Data size: 1186 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 1483 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 3 Statistics: Num rows: 3 Data size: 888 Basic stats: COMPLETE Column stats: NONE @@ -834,26 +834,26 @@ STAGE PLANS: Map Operator Tree: TableScan alias: orc_pred - filterExpr: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) + filterExpr: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (t > 0)) and si BETWEEN 300 AND 400) and (not (s like '%car%'))) (type: boolean) Statistics: Num rows: 1049 Data size: 311170 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) - Statistics: Num rows: 4 Data size: 1186 Basic stats: COMPLETE Column stats: NONE + predicate: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (t > 0)) and si BETWEEN 300 AND 400) and (not (s like '%car%'))) (type: boolean) + Statistics: Num rows: 5 Data size: 1483 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 4 Data size: 1186 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 1483 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col3 (type: string) sort order: - - Statistics: Num rows: 4 Data size: 1186 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 1483 Basic stats: COMPLETE Column stats: NONE TopN Hash Memory Usage: 0.1 value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Reduce Operator Tree: Select Operator expressions: VALUE._col0 (type: tinyint), VALUE._col1 (type: smallint), VALUE._col2 (type: double), KEY.reducesinkkey0 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 4 Data size: 1186 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 1483 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 3 Statistics: Num rows: 3 Data size: 888 Basic stats: COMPLETE Column stats: NONE diff --git a/ql/src/test/results/clientpositive/parquet_predicate_pushdown.q.out b/ql/src/test/results/clientpositive/parquet_predicate_pushdown.q.out index b322ef1..7c5be6d 100644 --- a/ql/src/test/results/clientpositive/parquet_predicate_pushdown.q.out +++ b/ql/src/test/results/clientpositive/parquet_predicate_pushdown.q.out @@ -756,23 +756,23 @@ STAGE PLANS: alias: tbl_pred Statistics: Num rows: 1049 Data size: 11539 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) - Statistics: Num rows: 4 Data size: 44 Basic stats: COMPLETE Column stats: NONE + predicate: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (t > 0)) and si BETWEEN 300 AND 400) and (not (s like '%car%'))) (type: boolean) + Statistics: Num rows: 5 Data size: 55 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 4 Data size: 44 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 55 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col3 (type: string) sort order: - - Statistics: Num rows: 4 Data size: 44 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 55 Basic stats: COMPLETE Column stats: NONE TopN Hash Memory Usage: 0.1 value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Reduce Operator Tree: Select Operator expressions: VALUE._col0 (type: tinyint), VALUE._col1 (type: smallint), VALUE._col2 (type: double), KEY.reducesinkkey0 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 4 Data size: 44 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 55 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 3 Statistics: Num rows: 3 Data size: 33 Basic stats: COMPLETE Column stats: NONE @@ -822,26 +822,26 @@ STAGE PLANS: Map Operator Tree: TableScan alias: tbl_pred - filterExpr: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) + filterExpr: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (t > 0)) and si BETWEEN 300 AND 400) and (not (s like '%car%'))) (type: boolean) Statistics: Num rows: 1049 Data size: 11539 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) - Statistics: Num rows: 4 Data size: 44 Basic stats: COMPLETE Column stats: NONE + predicate: ((((((d >= 10.0) and (d < 12.0)) and (s like '%son')) and (t > 0)) and si BETWEEN 300 AND 400) and (not (s like '%car%'))) (type: boolean) + Statistics: Num rows: 5 Data size: 55 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 4 Data size: 44 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 55 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col3 (type: string) sort order: - - Statistics: Num rows: 4 Data size: 44 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 55 Basic stats: COMPLETE Column stats: NONE TopN Hash Memory Usage: 0.1 value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Reduce Operator Tree: Select Operator expressions: VALUE._col0 (type: tinyint), VALUE._col1 (type: smallint), VALUE._col2 (type: double), KEY.reducesinkkey0 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 4 Data size: 44 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 55 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 3 Statistics: Num rows: 3 Data size: 33 Basic stats: COMPLETE Column stats: NONE diff --git a/ql/src/test/results/clientpositive/partition_multilevels.q.out b/ql/src/test/results/clientpositive/partition_multilevels.q.out index c1c8778..0fe7f82 100644 --- a/ql/src/test/results/clientpositive/partition_multilevels.q.out +++ b/ql/src/test/results/clientpositive/partition_multilevels.q.out @@ -990,12 +990,12 @@ STAGE PLANS: alias: partition_test_multilevel Statistics: Num rows: 108 Data size: 1146 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: '2222' (type: string), level2 (type: string), level3 (type: string) - outputColumnNames: level1, level2, level3 + expressions: level2 (type: string), level3 (type: string) + outputColumnNames: _col1, _col2 Statistics: Num rows: 108 Data size: 1146 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count() - keys: level1 (type: string), level2 (type: string), level3 (type: string) + keys: '2222' (type: string), _col1 (type: string), _col2 (type: string) mode: hash outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 108 Data size: 1146 Basic stats: COMPLETE Column stats: NONE @@ -1012,13 +1012,17 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 54 Data size: 573 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false + Select Operator + expressions: '2222' (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: bigint) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 54 Data size: 573 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 + File Output Operator + compressed: false + Statistics: Num rows: 54 Data size: 573 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 Stage: Stage-0 Fetch Operator @@ -1578,12 +1582,12 @@ STAGE PLANS: alias: partition_test_multilevel Statistics: Num rows: 108 Data size: 1146 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: '2222' (type: string), level2 (type: string), level3 (type: string) - outputColumnNames: level1, level2, level3 + expressions: level2 (type: string), level3 (type: string) + outputColumnNames: _col1, _col2 Statistics: Num rows: 108 Data size: 1146 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count() - keys: level1 (type: string), level2 (type: string), level3 (type: string) + keys: '2222' (type: string), _col1 (type: string), _col2 (type: string) mode: hash outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 108 Data size: 1146 Basic stats: COMPLETE Column stats: NONE @@ -1600,13 +1604,17 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 54 Data size: 573 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false + Select Operator + expressions: '2222' (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: bigint) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 54 Data size: 573 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 + File Output Operator + compressed: false + Statistics: Num rows: 54 Data size: 573 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 Stage: Stage-0 Fetch Operator diff --git a/ql/src/test/results/clientpositive/perf/query31.q.out b/ql/src/test/results/clientpositive/perf/query31.q.out index 52cbdf4..8c370c4 100644 --- a/ql/src/test/results/clientpositive/perf/query31.q.out +++ b/ql/src/test/results/clientpositive/perf/query31.q.out @@ -32,549 +32,549 @@ Stage-0 limit:-1 Stage-1 Reducer 7 - File Output Operator [FS_135] + File Output Operator [FS_141] compressed:false Statistics:Num rows: 11831111 Data size: 12007156967 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"} - Select Operator [SEL_134] + Select Operator [SEL_140] | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5"] | Statistics:Num rows: 11831111 Data size: 12007156967 Basic stats: COMPLETE Column stats: NONE |<-Reducer 6 [SIMPLE_EDGE] - Reduce Output Operator [RS_133] + Reduce Output Operator [RS_139] key expressions:_col2 (type: decimal(37,20)) sort order:+ Statistics:Num rows: 11831111 Data size: 12007156967 Basic stats: COMPLETE Column stats: NONE - value expressions:_col0 (type: string), _col1 (type: int), _col3 (type: decimal(37,20)), _col4 (type: decimal(37,20)), _col5 (type: decimal(37,20)) - Select Operator [SEL_132] - outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5"] + value expressions:_col0 (type: string), _col3 (type: decimal(37,20)), _col4 (type: decimal(37,20)), _col5 (type: decimal(37,20)) + Select Operator [SEL_138] + outputColumnNames:["_col0","_col2","_col3","_col4","_col5"] Statistics:Num rows: 11831111 Data size: 12007156967 Basic stats: COMPLETE Column stats: NONE - Filter Operator [FIL_131] + Filter Operator [FIL_137] predicate:(CASE WHEN ((_col19 > 0)) THEN ((_col23 / _col19)) ELSE (null) END > CASE WHEN ((_col7 > 0)) THEN ((_col11 / _col7)) ELSE (null) END) (type: boolean) Statistics:Num rows: 11831111 Data size: 12007156967 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_275] + Merge Join Operator [MERGEJOIN_281] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{"0":"_col12 (type: string)","1":"_col0 (type: string)"} - | outputColumnNames:["_col0","_col2","_col3","_col7","_col11","_col15","_col19","_col23"] + | outputColumnNames:["_col0","_col3","_col7","_col11","_col15","_col19","_col23"] | Statistics:Num rows: 35493334 Data size: 36021471918 Basic stats: COMPLETE Column stats: NONE |<-Reducer 37 [SIMPLE_EDGE] - | Reduce Output Operator [RS_129] + | Reduce Output Operator [RS_135] | key expressions:_col0 (type: string) | Map-reduce partition columns:_col0 (type: string) | sort order:+ | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Select Operator [SEL_127] + | Select Operator [SEL_133] | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE - | Group By Operator [GBY_126] + | Group By Operator [GBY_132] | | aggregations:["sum(VALUE._col0)"] - | | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string) + | | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: int) | | outputColumnNames:["_col0","_col1","_col2","_col3"] | | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 36 [SIMPLE_EDGE] - | Reduce Output Operator [RS_125] - | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string) - | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string) + | Reduce Output Operator [RS_131] + | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: int) + | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: int) | sort order:+++ | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Group By Operator [GBY_124] - | aggregations:["sum(_col2)"] - | keys:_col4 (type: int), _col5 (type: int), _col7 (type: string) + | Group By Operator [GBY_130] + | aggregations:["sum(_col3)"] + | keys:_col0 (type: string), 3 (type: int), 1998 (type: int) | outputColumnNames:["_col0","_col1","_col2","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_123] - | outputColumnNames:["_col4","_col5","_col7","_col2"] + | Select Operator [SEL_128] + | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_273] + | Merge Join Operator [MERGEJOIN_279] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col2","_col7"] | | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | |<-Map 39 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_121] + | | Reduce Output Operator [RS_126] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string) - | | Select Operator [SEL_116] + | | Select Operator [SEL_121] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_261] + | | Filter Operator [FIL_267] | | predicate:(ca_address_sk is not null and ca_county is not null) (type: boolean) | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_114] + | | TableScan [TS_119] | | alias:customer_address | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 35 [SIMPLE_EDGE] - | Reduce Output Operator [RS_120] + | Reduce Output Operator [RS_125] | key expressions:_col1 (type: int) | Map-reduce partition columns:_col1 (type: int) | sort order:+ | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | value expressions:_col2 (type: decimal(7,2)) - | Merge Join Operator [MERGEJOIN_272] + | Merge Join Operator [MERGEJOIN_278] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col2"] | | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | |<-Map 34 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_117] + | | Reduce Output Operator [RS_122] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | value expressions:_col1 (type: int), _col2 (type: decimal(7,2)) - | | Select Operator [SEL_110] + | | Select Operator [SEL_115] | | outputColumnNames:["_col0","_col1","_col2"] | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_259] + | | Filter Operator [FIL_265] | | predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null) (type: boolean) | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_108] + | | TableScan [TS_113] | | alias:web_sales | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | |<-Map 38 [SIMPLE_EDGE] - | Reduce Output Operator [RS_118] + | Reduce Output Operator [RS_123] | key expressions:_col0 (type: int) | Map-reduce partition columns:_col0 (type: int) | sort order:+ | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_113] + | Select Operator [SEL_118] | outputColumnNames:["_col0"] | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_260] + | Filter Operator [FIL_266] | predicate:(((d_qoy = 3) and (d_year = 1998)) and d_date_sk is not null) (type: boolean) | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_111] + | TableScan [TS_116] | alias:date_dim | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE |<-Reducer 5 [SIMPLE_EDGE] - Reduce Output Operator [RS_128] + Reduce Output Operator [RS_134] key expressions:_col12 (type: string) Map-reduce partition columns:_col12 (type: string) sort order:+ Statistics:Num rows: 32266667 Data size: 32746791943 Basic stats: COMPLETE Column stats: NONE - value expressions:_col0 (type: string), _col2 (type: int), _col3 (type: decimal(17,2)), _col7 (type: decimal(17,2)), _col11 (type: decimal(17,2)), _col15 (type: decimal(17,2)), _col19 (type: decimal(17,2)) - Select Operator [SEL_107] - outputColumnNames:["_col0","_col11","_col12","_col15","_col19","_col2","_col3","_col7"] + value expressions:_col0 (type: string), _col3 (type: decimal(17,2)), _col7 (type: decimal(17,2)), _col11 (type: decimal(17,2)), _col15 (type: decimal(17,2)), _col19 (type: decimal(17,2)) + Select Operator [SEL_112] + outputColumnNames:["_col0","_col11","_col12","_col15","_col19","_col3","_col7"] Statistics:Num rows: 32266667 Data size: 32746791943 Basic stats: COMPLETE Column stats: NONE - Filter Operator [FIL_106] + Filter Operator [FIL_111] predicate:(CASE WHEN ((_col15 > 0)) THEN ((_col19 / _col15)) ELSE (null) END > CASE WHEN ((_col3 > 0)) THEN ((_col7 / _col3)) ELSE (null) END) (type: boolean) Statistics:Num rows: 32266667 Data size: 32746791943 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_274] + Merge Join Operator [MERGEJOIN_280] | condition map:[{"":"Inner Join 0 to 1"},{"":"Inner Join 1 to 2"},{"":"Inner Join 0 to 3"},{"":"Inner Join 3 to 4"}] | keys:{"0":"_col0 (type: string)","1":"_col0 (type: string)","2":"_col0 (type: string)","3":"_col0 (type: string)","4":"_col0 (type: string)"} - | outputColumnNames:["_col0","_col2","_col3","_col7","_col11","_col12","_col15","_col19"] + | outputColumnNames:["_col0","_col3","_col7","_col11","_col12","_col15","_col19"] | Statistics:Num rows: 96800002 Data size: 98240376845 Basic stats: COMPLETE Column stats: NONE |<-Reducer 13 [SIMPLE_EDGE] - | Reduce Output Operator [RS_101] + | Reduce Output Operator [RS_106] | key expressions:_col0 (type: string) | Map-reduce partition columns:_col0 (type: string) | sort order:+ | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Select Operator [SEL_39] + | Select Operator [SEL_41] | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE - | Group By Operator [GBY_38] + | Group By Operator [GBY_40] | | aggregations:["sum(VALUE._col0)"] - | | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string) + | | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: int) | | outputColumnNames:["_col0","_col1","_col2","_col3"] | | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 12 [SIMPLE_EDGE] - | Reduce Output Operator [RS_37] - | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string) - | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string) + | Reduce Output Operator [RS_39] + | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: int) + | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: int) | sort order:+++ | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Group By Operator [GBY_36] - | aggregations:["sum(_col2)"] - | keys:_col4 (type: int), _col5 (type: int), _col7 (type: string) + | Group By Operator [GBY_38] + | aggregations:["sum(_col3)"] + | keys:_col0 (type: string), 2 (type: int), 1998 (type: int) | outputColumnNames:["_col0","_col1","_col2","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_35] - | outputColumnNames:["_col4","_col5","_col7","_col2"] + | Select Operator [SEL_36] + | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_265] + | Merge Join Operator [MERGEJOIN_271] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col2","_col7"] | | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | |<-Map 15 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_33] + | | Reduce Output Operator [RS_34] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string) - | | Select Operator [SEL_28] + | | Select Operator [SEL_29] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_249] + | | Filter Operator [FIL_255] | | predicate:(ca_address_sk is not null and ca_county is not null) (type: boolean) | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_26] + | | TableScan [TS_27] | | alias:customer_address | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 11 [SIMPLE_EDGE] - | Reduce Output Operator [RS_32] + | Reduce Output Operator [RS_33] | key expressions:_col1 (type: int) | Map-reduce partition columns:_col1 (type: int) | sort order:+ | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | value expressions:_col2 (type: decimal(7,2)) - | Merge Join Operator [MERGEJOIN_264] + | Merge Join Operator [MERGEJOIN_270] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col2"] | | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | |<-Map 10 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_29] + | | Reduce Output Operator [RS_30] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | value expressions:_col1 (type: int), _col2 (type: decimal(7,2)) - | | Select Operator [SEL_22] + | | Select Operator [SEL_23] | | outputColumnNames:["_col0","_col1","_col2"] | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_247] + | | Filter Operator [FIL_253] | | predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null) (type: boolean) | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_20] + | | TableScan [TS_21] | | alias:store_sales | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | |<-Map 14 [SIMPLE_EDGE] - | Reduce Output Operator [RS_30] + | Reduce Output Operator [RS_31] | key expressions:_col0 (type: int) | Map-reduce partition columns:_col0 (type: int) | sort order:+ | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_25] + | Select Operator [SEL_26] | outputColumnNames:["_col0"] | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_248] + | Filter Operator [FIL_254] | predicate:(((d_qoy = 2) and (d_year = 1998)) and d_date_sk is not null) (type: boolean) | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_23] + | TableScan [TS_24] | alias:date_dim | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE |<-Reducer 19 [SIMPLE_EDGE] - | Reduce Output Operator [RS_102] + | Reduce Output Operator [RS_107] | key expressions:_col0 (type: string) | Map-reduce partition columns:_col0 (type: string) | sort order:+ | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Select Operator [SEL_59] + | Select Operator [SEL_62] | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE - | Group By Operator [GBY_58] + | Group By Operator [GBY_61] | | aggregations:["sum(VALUE._col0)"] - | | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string) + | | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: int) | | outputColumnNames:["_col0","_col1","_col2","_col3"] | | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 18 [SIMPLE_EDGE] - | Reduce Output Operator [RS_57] - | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string) - | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string) + | Reduce Output Operator [RS_60] + | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: int) + | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: int) | sort order:+++ | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Group By Operator [GBY_56] - | aggregations:["sum(_col2)"] - | keys:_col4 (type: int), _col5 (type: int), _col7 (type: string) + | Group By Operator [GBY_59] + | aggregations:["sum(_col3)"] + | keys:_col0 (type: string), 3 (type: int), 1998 (type: int) | outputColumnNames:["_col0","_col1","_col2","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_55] - | outputColumnNames:["_col4","_col5","_col7","_col2"] + | Select Operator [SEL_57] + | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_267] + | Merge Join Operator [MERGEJOIN_273] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col2","_col7"] | | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | |<-Map 21 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_53] + | | Reduce Output Operator [RS_55] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string) - | | Select Operator [SEL_48] + | | Select Operator [SEL_50] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_252] + | | Filter Operator [FIL_258] | | predicate:(ca_address_sk is not null and ca_county is not null) (type: boolean) | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_46] + | | TableScan [TS_48] | | alias:customer_address | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 17 [SIMPLE_EDGE] - | Reduce Output Operator [RS_52] + | Reduce Output Operator [RS_54] | key expressions:_col1 (type: int) | Map-reduce partition columns:_col1 (type: int) | sort order:+ | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | value expressions:_col2 (type: decimal(7,2)) - | Merge Join Operator [MERGEJOIN_266] + | Merge Join Operator [MERGEJOIN_272] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col2"] | | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | |<-Map 16 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_49] + | | Reduce Output Operator [RS_51] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | value expressions:_col1 (type: int), _col2 (type: decimal(7,2)) - | | Select Operator [SEL_42] + | | Select Operator [SEL_44] | | outputColumnNames:["_col0","_col1","_col2"] | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_250] + | | Filter Operator [FIL_256] | | predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null) (type: boolean) | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_40] + | | TableScan [TS_42] | | alias:store_sales | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | |<-Map 20 [SIMPLE_EDGE] - | Reduce Output Operator [RS_50] + | Reduce Output Operator [RS_52] | key expressions:_col0 (type: int) | Map-reduce partition columns:_col0 (type: int) | sort order:+ | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_45] + | Select Operator [SEL_47] | outputColumnNames:["_col0"] | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_251] + | Filter Operator [FIL_257] | predicate:(((d_qoy = 3) and (d_year = 1998)) and d_date_sk is not null) (type: boolean) | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_43] + | TableScan [TS_45] | alias:date_dim | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE |<-Reducer 25 [SIMPLE_EDGE] - | Reduce Output Operator [RS_103] + | Reduce Output Operator [RS_108] | key expressions:_col0 (type: string) | Map-reduce partition columns:_col0 (type: string) | sort order:+ | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Select Operator [SEL_79] + | Select Operator [SEL_83] | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE - | Group By Operator [GBY_78] + | Group By Operator [GBY_82] | | aggregations:["sum(VALUE._col0)"] - | | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string) + | | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: int) | | outputColumnNames:["_col0","_col1","_col2","_col3"] | | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 24 [SIMPLE_EDGE] - | Reduce Output Operator [RS_77] - | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string) - | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string) + | Reduce Output Operator [RS_81] + | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: int) + | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: int) | sort order:+++ | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Group By Operator [GBY_76] - | aggregations:["sum(_col2)"] - | keys:_col4 (type: int), _col5 (type: int), _col7 (type: string) + | Group By Operator [GBY_80] + | aggregations:["sum(_col3)"] + | keys:_col0 (type: string), 1 (type: int), 1998 (type: int) | outputColumnNames:["_col0","_col1","_col2","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_75] - | outputColumnNames:["_col4","_col5","_col7","_col2"] + | Select Operator [SEL_78] + | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_269] + | Merge Join Operator [MERGEJOIN_275] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col2","_col7"] | | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | |<-Map 27 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_73] + | | Reduce Output Operator [RS_76] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string) - | | Select Operator [SEL_68] + | | Select Operator [SEL_71] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_255] + | | Filter Operator [FIL_261] | | predicate:(ca_address_sk is not null and ca_county is not null) (type: boolean) | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_66] + | | TableScan [TS_69] | | alias:customer_address | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 23 [SIMPLE_EDGE] - | Reduce Output Operator [RS_72] + | Reduce Output Operator [RS_75] | key expressions:_col1 (type: int) | Map-reduce partition columns:_col1 (type: int) | sort order:+ | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | value expressions:_col2 (type: decimal(7,2)) - | Merge Join Operator [MERGEJOIN_268] + | Merge Join Operator [MERGEJOIN_274] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col2"] | | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | |<-Map 22 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_69] + | | Reduce Output Operator [RS_72] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | value expressions:_col1 (type: int), _col2 (type: decimal(7,2)) - | | Select Operator [SEL_62] + | | Select Operator [SEL_65] | | outputColumnNames:["_col0","_col1","_col2"] | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_253] + | | Filter Operator [FIL_259] | | predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null) (type: boolean) | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_60] + | | TableScan [TS_63] | | alias:web_sales | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | |<-Map 26 [SIMPLE_EDGE] - | Reduce Output Operator [RS_70] + | Reduce Output Operator [RS_73] | key expressions:_col0 (type: int) | Map-reduce partition columns:_col0 (type: int) | sort order:+ | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_65] + | Select Operator [SEL_68] | outputColumnNames:["_col0"] | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_254] + | Filter Operator [FIL_260] | predicate:(((d_year = 1998) and (d_qoy = 1)) and d_date_sk is not null) (type: boolean) | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_63] + | TableScan [TS_66] | alias:date_dim | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE |<-Reducer 31 [SIMPLE_EDGE] - | Reduce Output Operator [RS_104] + | Reduce Output Operator [RS_109] | key expressions:_col0 (type: string) | Map-reduce partition columns:_col0 (type: string) | sort order:+ | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Select Operator [SEL_99] + | Select Operator [SEL_104] | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE - | Group By Operator [GBY_98] + | Group By Operator [GBY_103] | | aggregations:["sum(VALUE._col0)"] - | | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string) + | | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: int) | | outputColumnNames:["_col0","_col1","_col2","_col3"] | | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 30 [SIMPLE_EDGE] - | Reduce Output Operator [RS_97] - | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string) - | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string) + | Reduce Output Operator [RS_102] + | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: int) + | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: int) | sort order:+++ | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: decimal(17,2)) - | Group By Operator [GBY_96] - | aggregations:["sum(_col2)"] - | keys:_col4 (type: int), _col5 (type: int), _col7 (type: string) + | Group By Operator [GBY_101] + | aggregations:["sum(_col3)"] + | keys:_col0 (type: string), 2 (type: int), 1998 (type: int) | outputColumnNames:["_col0","_col1","_col2","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_95] - | outputColumnNames:["_col4","_col5","_col7","_col2"] + | Select Operator [SEL_99] + | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_271] + | Merge Join Operator [MERGEJOIN_277] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col2","_col7"] | | Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE | |<-Map 33 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_93] + | | Reduce Output Operator [RS_97] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string) - | | Select Operator [SEL_88] + | | Select Operator [SEL_92] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_258] + | | Filter Operator [FIL_264] | | predicate:(ca_address_sk is not null and ca_county is not null) (type: boolean) | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_86] + | | TableScan [TS_90] | | alias:customer_address | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 29 [SIMPLE_EDGE] - | Reduce Output Operator [RS_92] + | Reduce Output Operator [RS_96] | key expressions:_col1 (type: int) | Map-reduce partition columns:_col1 (type: int) | sort order:+ | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | value expressions:_col2 (type: decimal(7,2)) - | Merge Join Operator [MERGEJOIN_270] + | Merge Join Operator [MERGEJOIN_276] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col2"] | | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE | |<-Map 28 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_89] + | | Reduce Output Operator [RS_93] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | value expressions:_col1 (type: int), _col2 (type: decimal(7,2)) - | | Select Operator [SEL_82] + | | Select Operator [SEL_86] | | outputColumnNames:["_col0","_col1","_col2"] | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_256] + | | Filter Operator [FIL_262] | | predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null) (type: boolean) | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_80] + | | TableScan [TS_84] | | alias:web_sales | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | |<-Map 32 [SIMPLE_EDGE] - | Reduce Output Operator [RS_90] + | Reduce Output Operator [RS_94] | key expressions:_col0 (type: int) | Map-reduce partition columns:_col0 (type: int) | sort order:+ | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_85] + | Select Operator [SEL_89] | outputColumnNames:["_col0"] | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_257] + | Filter Operator [FIL_263] | predicate:(((d_qoy = 2) and (d_year = 1998)) and d_date_sk is not null) (type: boolean) | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_83] + | TableScan [TS_87] | alias:date_dim | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE |<-Reducer 4 [SIMPLE_EDGE] - Reduce Output Operator [RS_100] + Reduce Output Operator [RS_105] key expressions:_col0 (type: string) Map-reduce partition columns:_col0 (type: string) sort order:+ Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE - value expressions:_col2 (type: int), _col3 (type: decimal(17,2)) - Select Operator [SEL_19] - outputColumnNames:["_col0","_col2","_col3"] + value expressions:_col3 (type: decimal(17,2)) + Select Operator [SEL_20] + outputColumnNames:["_col0","_col3"] Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE - Group By Operator [GBY_18] + Group By Operator [GBY_19] | aggregations:["sum(VALUE._col0)"] - | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string) + | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: int) | outputColumnNames:["_col0","_col1","_col2","_col3"] | Statistics:Num rows: 22000000 Data size: 22327357890 Basic stats: COMPLETE Column stats: NONE |<-Reducer 3 [SIMPLE_EDGE] - Reduce Output Operator [RS_17] - key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string) - Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string) + Reduce Output Operator [RS_18] + key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: int) + Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: int) sort order:+++ Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE value expressions:_col3 (type: decimal(17,2)) - Group By Operator [GBY_16] - aggregations:["sum(_col2)"] - keys:_col4 (type: int), _col5 (type: int), _col7 (type: string) + Group By Operator [GBY_17] + aggregations:["sum(_col3)"] + keys:_col0 (type: string), 1 (type: int), 1998 (type: int) outputColumnNames:["_col0","_col1","_col2","_col3"] Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE Select Operator [SEL_15] - outputColumnNames:["_col4","_col5","_col7","_col2"] + outputColumnNames:["_col0","_col3"] Statistics:Num rows: 44000000 Data size: 44654715780 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_263] + Merge Join Operator [MERGEJOIN_269] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} | outputColumnNames:["_col2","_col7"] @@ -589,7 +589,7 @@ Stage-0 | Select Operator [SEL_8] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_246] + | Filter Operator [FIL_252] | predicate:(ca_address_sk is not null and ca_county is not null) (type: boolean) | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | TableScan [TS_6] @@ -602,7 +602,7 @@ Stage-0 sort order:+ Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE value expressions:_col2 (type: decimal(7,2)) - Merge Join Operator [MERGEJOIN_262] + Merge Join Operator [MERGEJOIN_268] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | outputColumnNames:["_col1","_col2"] @@ -617,7 +617,7 @@ Stage-0 | Select Operator [SEL_2] | outputColumnNames:["_col0","_col1","_col2"] | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Filter Operator [FIL_244] + | Filter Operator [FIL_250] | predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null) (type: boolean) | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | TableScan [TS_0] @@ -632,7 +632,7 @@ Stage-0 Select Operator [SEL_5] outputColumnNames:["_col0"] Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - Filter Operator [FIL_245] + Filter Operator [FIL_251] predicate:(((d_year = 1998) and (d_qoy = 1)) and d_date_sk is not null) (type: boolean) Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE TableScan [TS_3] diff --git a/ql/src/test/results/clientpositive/perf/query39.q.out b/ql/src/test/results/clientpositive/perf/query39.q.out index a18cdaf..f4ad98c 100644 --- a/ql/src/test/results/clientpositive/perf/query39.q.out +++ b/ql/src/test/results/clientpositive/perf/query39.q.out @@ -30,17 +30,17 @@ Stage-0 | Statistics:Num rows: 112735 Data size: 161919824 Basic stats: COMPLETE Column stats: NONE |<-Reducer 6 [SIMPLE_EDGE] Reduce Output Operator [RS_60] - key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: double), _col4 (type: double), _col7 (type: int), _col8 (type: double), _col9 (type: double) + key expressions:_col0 (type: int), _col1 (type: int), 3 (type: int), _col3 (type: double), _col4 (type: double), _col7 (type: int), _col8 (type: double), _col9 (type: double) sort order:++++++++ Statistics:Num rows: 112735 Data size: 161919824 Basic stats: COMPLETE Column stats: NONE value expressions:_col5 (type: int), _col6 (type: int) Select Operator [SEL_59] - outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] + outputColumnNames:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] Statistics:Num rows: 112735 Data size: 161919824 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_103] + Merge Join Operator [MERGEJOIN_104] | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col2 (type: int), _col1 (type: int)","1":"_col2 (type: int), _col1 (type: int)"} - | outputColumnNames:["_col1","_col2","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11"] + | keys:{"0":"_col1 (type: int), _col0 (type: int)","1":"_col2 (type: int), _col1 (type: int)"} + | outputColumnNames:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8","_col9"] | Statistics:Num rows: 112735 Data size: 161919824 Basic stats: COMPLETE Column stats: NONE |<-Reducer 15 [SIMPLE_EDGE] | Reduce Output Operator [RS_57] @@ -78,7 +78,7 @@ Stage-0 | Select Operator [SEL_49] | outputColumnNames:["_col4","_col5","_col6","_col9","_col3"] | Statistics:Num rows: 614922 Data size: 883199024 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_102] + | Merge Join Operator [MERGEJOIN_103] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col3","_col4","_col5","_col6"] @@ -105,7 +105,7 @@ Stage-0 | sort order:+ | Statistics:Num rows: 559020 Data size: 802908187 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: string) - | Merge Join Operator [MERGEJOIN_101] + | Merge Join Operator [MERGEJOIN_102] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col0","_col3","_col4","_col5","_col6"] @@ -133,7 +133,7 @@ Stage-0 | sort order:+ | Statistics:Num rows: 508200 Data size: 729916518 Basic stats: COMPLETE Column stats: NONE | value expressions:_col0 (type: int), _col3 (type: int), _col4 (type: int) - | Merge Join Operator [MERGEJOIN_100] + | Merge Join Operator [MERGEJOIN_101] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col0","_col2","_col3","_col4"] @@ -171,41 +171,41 @@ Stage-0 | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE |<-Reducer 5 [SIMPLE_EDGE] Reduce Output Operator [RS_56] - key expressions:_col2 (type: int), _col1 (type: int) - Map-reduce partition columns:_col2 (type: int), _col1 (type: int) + key expressions:_col1 (type: int), _col0 (type: int) + Map-reduce partition columns:_col1 (type: int), _col0 (type: int) sort order:++ Statistics:Num rows: 102487 Data size: 147199837 Basic stats: COMPLETE Column stats: NONE - value expressions:_col3 (type: int), _col4 (type: double), _col5 (type: double) + value expressions:_col2 (type: double), _col3 (type: double) Select Operator [SEL_27] - outputColumnNames:["_col1","_col2","_col3","_col4","_col5"] + outputColumnNames:["_col0","_col1","_col2","_col3"] Statistics:Num rows: 102487 Data size: 147199837 Basic stats: COMPLETE Column stats: NONE Filter Operator [FIL_26] - predicate:(CASE (_col5) WHEN (0) THEN (0) ELSE ((_col4 / _col5)) END > 1.0) (type: boolean) + predicate:(CASE (_col4) WHEN (0) THEN (0) ELSE ((_col5 / _col4)) END > 1.0) (type: boolean) Statistics:Num rows: 102487 Data size: 147199837 Basic stats: COMPLETE Column stats: NONE - Select Operator [SEL_25] - outputColumnNames:["_col1","_col2","_col3","_col4","_col5"] + Select Operator [SEL_97] + outputColumnNames:["_col1","_col2","_col4","_col5"] Statistics:Num rows: 307461 Data size: 441599512 Basic stats: COMPLETE Column stats: NONE - Group By Operator [GBY_24] - | aggregations:["stddev_samp(VALUE._col0)","avg(VALUE._col1)"] - | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: int) + Group By Operator [GBY_25] + | aggregations:["avg(VALUE._col0)","stddev_samp(VALUE._col1)"] + | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: int), KEY._col3 (type: int) | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5"] | Statistics:Num rows: 307461 Data size: 441599512 Basic stats: COMPLETE Column stats: NONE |<-Reducer 4 [SIMPLE_EDGE] - Reduce Output Operator [RS_23] - key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int) - Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int) + Reduce Output Operator [RS_24] + key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: int), _col3 (type: int) + Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: int), _col3 (type: int) sort order:++++ Statistics:Num rows: 614922 Data size: 883199024 Basic stats: COMPLETE Column stats: NONE - value expressions:_col4 (type: struct), _col5 (type: struct) - Group By Operator [GBY_22] - aggregations:["stddev_samp(_col3)","avg(_col3)"] - keys:_col4 (type: int), _col5 (type: int), _col6 (type: string), _col9 (type: int) + value expressions:_col4 (type: struct), _col5 (type: struct) + Group By Operator [GBY_23] + aggregations:["avg(_col4)","stddev_samp(_col4)"] + keys:_col0 (type: string), _col1 (type: int), _col2 (type: int), 3 (type: int) outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5"] Statistics:Num rows: 614922 Data size: 883199024 Basic stats: COMPLETE Column stats: NONE Select Operator [SEL_21] - outputColumnNames:["_col4","_col5","_col6","_col9","_col3"] + outputColumnNames:["_col0","_col1","_col2","_col4"] Statistics:Num rows: 614922 Data size: 883199024 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_99] + Merge Join Operator [MERGEJOIN_100] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | outputColumnNames:["_col3","_col4","_col5","_col6"] @@ -232,7 +232,7 @@ Stage-0 sort order:+ Statistics:Num rows: 559020 Data size: 802908187 Basic stats: COMPLETE Column stats: NONE value expressions:_col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: string) - Merge Join Operator [MERGEJOIN_98] + Merge Join Operator [MERGEJOIN_99] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"} | outputColumnNames:["_col0","_col3","_col4","_col5","_col6"] @@ -260,7 +260,7 @@ Stage-0 sort order:+ Statistics:Num rows: 508200 Data size: 729916518 Basic stats: COMPLETE Column stats: NONE value expressions:_col0 (type: int), _col3 (type: int), _col4 (type: int) - Merge Join Operator [MERGEJOIN_97] + Merge Join Operator [MERGEJOIN_98] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} | outputColumnNames:["_col0","_col2","_col3","_col4"] diff --git a/ql/src/test/results/clientpositive/perf/query42.q.out b/ql/src/test/results/clientpositive/perf/query42.q.out index 3954829..94f7e32 100644 --- a/ql/src/test/results/clientpositive/perf/query42.q.out +++ b/ql/src/test/results/clientpositive/perf/query42.q.out @@ -15,103 +15,106 @@ Stage-0 limit:100 Stage-1 Reducer 5 - File Output Operator [FS_23] + File Output Operator [FS_24] compressed:false Statistics:Num rows: 100 Data size: 143600 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"} - Limit [LIM_22] + Limit [LIM_23] Number of rows:100 Statistics:Num rows: 100 Data size: 143600 Basic stats: COMPLETE Column stats: NONE - Select Operator [SEL_21] + Select Operator [SEL_22] | outputColumnNames:["_col0","_col1","_col2","_col3"] | Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE |<-Reducer 4 [SIMPLE_EDGE] - Reduce Output Operator [RS_20] - key expressions:_col3 (type: decimal(17,2)), _col0 (type: int), _col1 (type: int), _col2 (type: string) + Reduce Output Operator [RS_21] + key expressions:_col3 (type: decimal(17,2)), 1998 (type: int), _col1 (type: int), _col2 (type: string) sort order:-+++ Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE - Group By Operator [GBY_18] - | aggregations:["sum(VALUE._col0)"] - | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string) - | outputColumnNames:["_col0","_col1","_col2","_col3"] - | Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 3 [SIMPLE_EDGE] - Reduce Output Operator [RS_17] - key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string) - Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string) - sort order:+++ - Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - value expressions:_col3 (type: decimal(17,2)) - Group By Operator [GBY_16] - aggregations:["sum(_col5)"] - keys:_col1 (type: int), _col7 (type: int), _col8 (type: string) - outputColumnNames:["_col0","_col1","_col2","_col3"] + Select Operator [SEL_20] + outputColumnNames:["_col1","_col2","_col3"] + Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE + Group By Operator [GBY_19] + | aggregations:["sum(VALUE._col0)"] + | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string) + | outputColumnNames:["_col0","_col1","_col2","_col3"] + | Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 3 [SIMPLE_EDGE] + Reduce Output Operator [RS_18] + key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string) + Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string) + sort order:+++ Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - Select Operator [SEL_15] - outputColumnNames:["_col1","_col7","_col8","_col5"] + value expressions:_col3 (type: decimal(17,2)) + Group By Operator [GBY_17] + aggregations:["sum(_col3)"] + keys:1998 (type: int), _col1 (type: int), _col2 (type: string) + outputColumnNames:["_col0","_col1","_col2","_col3"] Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_33] - | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col4 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col5","_col7","_col8"] - | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - |<-Map 7 [SIMPLE_EDGE] - | Reduce Output Operator [RS_13] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col1 (type: int), _col2 (type: string) - | Select Operator [SEL_8] - | outputColumnNames:["_col0","_col1","_col2"] - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_31] - | predicate:((i_manager_id = 1) and i_item_sk is not null) (type: boolean) - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_6] - | alias:item - | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 2 [SIMPLE_EDGE] - Reduce Output Operator [RS_12] - key expressions:_col4 (type: int) - Map-reduce partition columns:_col4 (type: int) - sort order:+ - Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE - value expressions:_col5 (type: decimal(7,2)) - Merge Join Operator [MERGEJOIN_32] - | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col4","_col5"] - | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE - |<-Map 1 [SIMPLE_EDGE] - | Reduce Output Operator [RS_9] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_2] - | outputColumnNames:["_col0"] - | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_29] - | predicate:(((d_year = 1998) and (d_moy = 12)) and d_date_sk is not null) (type: boolean) - | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_0] - | alias:dt - | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - |<-Map 6 [SIMPLE_EDGE] - Reduce Output Operator [RS_10] - key expressions:_col0 (type: int) - Map-reduce partition columns:_col0 (type: int) - sort order:+ - Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - value expressions:_col1 (type: int), _col2 (type: decimal(7,2)) - Select Operator [SEL_5] - outputColumnNames:["_col0","_col1","_col2"] + Select Operator [SEL_15] + outputColumnNames:["_col1","_col2","_col3"] + Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + Merge Join Operator [MERGEJOIN_34] + | condition map:[{"":"Inner Join 0 to 1"}] + | keys:{"0":"_col4 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col5","_col7","_col8"] + | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + |<-Map 7 [SIMPLE_EDGE] + | Reduce Output Operator [RS_13] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col1 (type: int), _col2 (type: string) + | Select Operator [SEL_8] + | outputColumnNames:["_col0","_col1","_col2"] + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_32] + | predicate:((i_manager_id = 1) and i_item_sk is not null) (type: boolean) + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_6] + | alias:item + | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 2 [SIMPLE_EDGE] + Reduce Output Operator [RS_12] + key expressions:_col4 (type: int) + Map-reduce partition columns:_col4 (type: int) + sort order:+ + Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE + value expressions:_col5 (type: decimal(7,2)) + Merge Join Operator [MERGEJOIN_33] + | condition map:[{"":"Inner Join 0 to 1"}] + | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col4","_col5"] + | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE + |<-Map 1 [SIMPLE_EDGE] + | Reduce Output Operator [RS_9] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_2] + | outputColumnNames:["_col0"] + | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_30] + | predicate:(((d_year = 1998) and (d_moy = 12)) and d_date_sk is not null) (type: boolean) + | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_0] + | alias:dt + | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE + |<-Map 6 [SIMPLE_EDGE] + Reduce Output Operator [RS_10] + key expressions:_col0 (type: int) + Map-reduce partition columns:_col0 (type: int) + sort order:+ Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Filter Operator [FIL_30] - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null) (type: boolean) + value expressions:_col1 (type: int), _col2 (type: decimal(7,2)) + Select Operator [SEL_5] + outputColumnNames:["_col0","_col1","_col2"] Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - TableScan [TS_3] - alias:store_sales + Filter Operator [FIL_31] + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null) (type: boolean) Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + TableScan [TS_3] + alias:store_sales + Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE diff --git a/ql/src/test/results/clientpositive/perf/query52.q.out b/ql/src/test/results/clientpositive/perf/query52.q.out index 63f0bf6..b4f46cc 100644 --- a/ql/src/test/results/clientpositive/perf/query52.q.out +++ b/ql/src/test/results/clientpositive/perf/query52.q.out @@ -27,92 +27,95 @@ Stage-0 | Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE |<-Reducer 4 [SIMPLE_EDGE] Reduce Output Operator [RS_21] - key expressions:_col0 (type: int), _col3 (type: decimal(17,2)), _col1 (type: int) + key expressions:1998 (type: int), _col3 (type: decimal(17,2)), _col1 (type: int) sort order:+-+ Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE value expressions:_col2 (type: string) - Group By Operator [GBY_18] - | aggregations:["sum(VALUE._col0)"] - | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string) - | outputColumnNames:["_col0","_col1","_col2","_col3"] - | Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 3 [SIMPLE_EDGE] - Reduce Output Operator [RS_17] - key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: string) - Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: string) - sort order:+++ - Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - value expressions:_col3 (type: decimal(17,2)) - Group By Operator [GBY_16] - aggregations:["sum(_col5)"] - keys:_col1 (type: int), _col7 (type: int), _col8 (type: string) - outputColumnNames:["_col0","_col1","_col2","_col3"] + Select Operator [SEL_20] + outputColumnNames:["_col1","_col2","_col3"] + Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE + Group By Operator [GBY_19] + | aggregations:["sum(VALUE._col0)"] + | keys:KEY._col0 (type: int), KEY._col1 (type: string), KEY._col2 (type: int) + | outputColumnNames:["_col0","_col1","_col2","_col3"] + | Statistics:Num rows: 127050 Data size: 182479129 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 3 [SIMPLE_EDGE] + Reduce Output Operator [RS_18] + key expressions:_col0 (type: int), _col1 (type: string), _col2 (type: int) + Map-reduce partition columns:_col0 (type: int), _col1 (type: string), _col2 (type: int) + sort order:+++ Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - Select Operator [SEL_15] - outputColumnNames:["_col1","_col7","_col8","_col5"] + value expressions:_col3 (type: decimal(17,2)) + Group By Operator [GBY_17] + aggregations:["sum(_col3)"] + keys:1998 (type: int), _col1 (type: string), _col2 (type: int) + outputColumnNames:["_col0","_col1","_col2","_col3"] Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_34] - | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col4 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col5","_col7","_col8"] - | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - |<-Map 7 [SIMPLE_EDGE] - | Reduce Output Operator [RS_13] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col1 (type: int), _col2 (type: string) - | Select Operator [SEL_8] - | outputColumnNames:["_col0","_col1","_col2"] - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_32] - | predicate:((i_manager_id = 1) and i_item_sk is not null) (type: boolean) - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_6] - | alias:item - | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 2 [SIMPLE_EDGE] - Reduce Output Operator [RS_12] - key expressions:_col4 (type: int) - Map-reduce partition columns:_col4 (type: int) - sort order:+ - Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE - value expressions:_col5 (type: decimal(7,2)) - Merge Join Operator [MERGEJOIN_33] - | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col4","_col5"] - | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE - |<-Map 1 [SIMPLE_EDGE] - | Reduce Output Operator [RS_9] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_2] - | outputColumnNames:["_col0"] - | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_30] - | predicate:(((d_year = 1998) and (d_moy = 12)) and d_date_sk is not null) (type: boolean) - | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_0] - | alias:dt - | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - |<-Map 6 [SIMPLE_EDGE] - Reduce Output Operator [RS_10] - key expressions:_col0 (type: int) - Map-reduce partition columns:_col0 (type: int) - sort order:+ - Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - value expressions:_col1 (type: int), _col2 (type: decimal(7,2)) - Select Operator [SEL_5] - outputColumnNames:["_col0","_col1","_col2"] + Select Operator [SEL_15] + outputColumnNames:["_col1","_col2","_col3"] + Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + Merge Join Operator [MERGEJOIN_34] + | condition map:[{"":"Inner Join 0 to 1"}] + | keys:{"0":"_col4 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col5","_col7","_col8"] + | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + |<-Map 7 [SIMPLE_EDGE] + | Reduce Output Operator [RS_13] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col1 (type: int), _col2 (type: string) + | Select Operator [SEL_8] + | outputColumnNames:["_col0","_col1","_col2"] + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_32] + | predicate:((i_manager_id = 1) and i_item_sk is not null) (type: boolean) + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_6] + | alias:item + | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 2 [SIMPLE_EDGE] + Reduce Output Operator [RS_12] + key expressions:_col4 (type: int) + Map-reduce partition columns:_col4 (type: int) + sort order:+ + Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE + value expressions:_col5 (type: decimal(7,2)) + Merge Join Operator [MERGEJOIN_33] + | condition map:[{"":"Inner Join 0 to 1"}] + | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col4","_col5"] + | Statistics:Num rows: 20088 Data size: 22478696 Basic stats: COMPLETE Column stats: NONE + |<-Map 1 [SIMPLE_EDGE] + | Reduce Output Operator [RS_9] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_2] + | outputColumnNames:["_col0"] + | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_30] + | predicate:(((d_year = 1998) and (d_moy = 12)) and d_date_sk is not null) (type: boolean) + | Statistics:Num rows: 18262 Data size: 20435178 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_0] + | alias:dt + | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE + |<-Map 6 [SIMPLE_EDGE] + Reduce Output Operator [RS_10] + key expressions:_col0 (type: int) + Map-reduce partition columns:_col0 (type: int) + sort order:+ Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Filter Operator [FIL_31] - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null) (type: boolean) + value expressions:_col1 (type: int), _col2 (type: decimal(7,2)) + Select Operator [SEL_5] + outputColumnNames:["_col0","_col1","_col2"] Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - TableScan [TS_3] - alias:store_sales + Filter Operator [FIL_31] + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null) (type: boolean) Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + TableScan [TS_3] + alias:store_sales + Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE diff --git a/ql/src/test/results/clientpositive/perf/query64.q.out b/ql/src/test/results/clientpositive/perf/query64.q.out index a630000..68730e7 100644 --- a/ql/src/test/results/clientpositive/perf/query64.q.out +++ b/ql/src/test/results/clientpositive/perf/query64.q.out @@ -51,61 +51,61 @@ Stage-0 limit:-1 Stage-1 Reducer 20 - File Output Operator [FS_253] + File Output Operator [FS_254] compressed:false Statistics:Num rows: 122532649 Data size: 105380558466 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"} - Select Operator [SEL_252] + Select Operator [SEL_253] | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20"] | Statistics:Num rows: 122532649 Data size: 105380558466 Basic stats: COMPLETE Column stats: NONE |<-Reducer 19 [SIMPLE_EDGE] - Reduce Output Operator [RS_251] + Reduce Output Operator [RS_252] key expressions:_col0 (type: string), _col1 (type: string), _col20 (type: bigint) sort order:+++ Statistics:Num rows: 122532649 Data size: 105380558466 Basic stats: COMPLETE Column stats: NONE - value expressions:_col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: int), _col12 (type: bigint), _col13 (type: decimal(17,2)), _col14 (type: decimal(17,2)), _col15 (type: decimal(17,2)), _col16 (type: decimal(17,2)), _col17 (type: decimal(17,2)), _col18 (type: decimal(17,2)), _col19 (type: int) - Select Operator [SEL_250] - outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20"] + value expressions:_col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col12 (type: bigint), _col13 (type: decimal(17,2)), _col14 (type: decimal(17,2)), _col15 (type: decimal(17,2)), _col16 (type: decimal(17,2)), _col17 (type: decimal(17,2)), _col18 (type: decimal(17,2)), _col19 (type: int) + Select Operator [SEL_251] + outputColumnNames:["_col0","_col1","_col10","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col2","_col20","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] Statistics:Num rows: 122532649 Data size: 105380558466 Basic stats: COMPLETE Column stats: NONE - Filter Operator [FIL_249] + Filter Operator [FIL_250] predicate:(_col34 <= _col15) (type: boolean) Statistics:Num rows: 122532649 Data size: 105380558466 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_714] + Merge Join Operator [MERGEJOIN_715] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{"0":"_col1 (type: int), _col2 (type: string), _col3 (type: string)","1":"_col1 (type: int), _col2 (type: string), _col3 (type: string)"} - | outputColumnNames:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col15","_col16","_col17","_col18","_col31","_col34","_col35","_col36","_col37"] + | outputColumnNames:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col15","_col16","_col17","_col18","_col31","_col34","_col35","_col36","_col37"] | Statistics:Num rows: 367597947 Data size: 316141675400 Basic stats: COMPLETE Column stats: NONE |<-Reducer 18 [SIMPLE_EDGE] - | Reduce Output Operator [RS_246] + | Reduce Output Operator [RS_247] | key expressions:_col1 (type: int), _col2 (type: string), _col3 (type: string) | Map-reduce partition columns:_col1 (type: int), _col2 (type: string), _col3 (type: string) | sort order:+++ | Statistics:Num rows: 334179945 Data size: 287401516862 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col0 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: string), _col12 (type: int), _col15 (type: bigint), _col16 (type: decimal(17,2)), _col17 (type: decimal(17,2)), _col18 (type: decimal(17,2)) - | Select Operator [SEL_122] - | outputColumnNames:["_col0","_col1","_col10","_col11","_col12","_col15","_col16","_col17","_col18","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] + | value expressions:_col0 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: string), _col15 (type: bigint), _col16 (type: decimal(17,2)), _col17 (type: decimal(17,2)), _col18 (type: decimal(17,2)) + | Select Operator [SEL_123] + | outputColumnNames:["_col0","_col1","_col10","_col11","_col15","_col16","_col17","_col18","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] | Statistics:Num rows: 334179945 Data size: 287401516862 Basic stats: COMPLETE Column stats: NONE - | Group By Operator [GBY_121] + | Group By Operator [GBY_122] | | aggregations:["count(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"] - | | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: int), KEY._col3 (type: string), KEY._col4 (type: string), KEY._col5 (type: string), KEY._col6 (type: string), KEY._col7 (type: string), KEY._col8 (type: string), KEY._col9 (type: string), KEY._col10 (type: string), KEY._col11 (type: string), KEY._col12 (type: string), KEY._col13 (type: int), KEY._col14 (type: string) + | | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: string), KEY._col4 (type: string), KEY._col5 (type: string), KEY._col6 (type: string), KEY._col7 (type: string), KEY._col8 (type: string), KEY._col9 (type: string), KEY._col10 (type: string), KEY._col11 (type: string), KEY._col12 (type: int), KEY._col13 (type: int), KEY._col14 (type: int) | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"] | | Statistics:Num rows: 334179945 Data size: 287401516862 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 17 [SIMPLE_EDGE] - | Reduce Output Operator [RS_120] - | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: int), _col14 (type: string) - | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: int), _col14 (type: string) + | Reduce Output Operator [RS_121] + | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: string), _col12 (type: int), _col13 (type: int), _col14 (type: int) + | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: string), _col12 (type: int), _col13 (type: int), _col14 (type: int) | sort order:+++++++++++++++ | Statistics:Num rows: 668359891 Data size: 574803034585 Basic stats: COMPLETE Column stats: NONE | value expressions:_col15 (type: bigint), _col16 (type: decimal(17,2)), _col17 (type: decimal(17,2)), _col18 (type: decimal(17,2)) - | Group By Operator [GBY_119] - | aggregations:["count()","sum(_col9)","sum(_col10)","sum(_col11)"] - | keys:_col21 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string), _col44 (type: string), _col45 (type: string), _col46 (type: string), _col47 (type: string), _col50 (type: int), _col53 (type: string) + | Group By Operator [GBY_120] + | aggregations:["count()","sum(_col15)","sum(_col16)","sum(_col17)"] + | keys:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: string), 2000 (type: int), _col13 (type: int), _col14 (type: int) | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"] | Statistics:Num rows: 668359891 Data size: 574803034585 Basic stats: COMPLETE Column stats: NONE | Select Operator [SEL_118] - | outputColumnNames:["_col21","_col23","_col25","_col27","_col28","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47","_col50","_col53","_col9","_col10","_col11"] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col13","_col14","_col15","_col16","_col17"] | Statistics:Num rows: 668359891 Data size: 574803034585 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_696] + | Merge Join Operator [MERGEJOIN_697] | | condition map:[{"":"Inner Join 0 to 1"},{"":"Inner Join 0 to 2"}] | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)","2":"_col0 (type: int)"} | | outputColumnNames:["_col9","_col10","_col11","_col23","_col25","_col27","_col28","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47","_col50","_col53"] @@ -120,7 +120,7 @@ Stage-0 | | Select Operator [SEL_76] | | outputColumnNames:["_col0","_col3"] | | Statistics:Num rows: 57750 Data size: 82945057 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_658] + | | Filter Operator [FIL_659] | | predicate:((((i_color) IN ('maroon', 'burnished', 'dim', 'steel', 'navajo', 'chocolate') and i_current_price BETWEEN 35 AND 45) and i_current_price BETWEEN 36 AND 50) and i_item_sk is not null) (type: boolean) | | Statistics:Num rows: 57750 Data size: 82945057 Basic stats: COMPLETE Column stats: NONE | | TableScan [TS_74] @@ -133,7 +133,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 303799944 Data size: 261274100967 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string), _col44 (type: string), _col45 (type: string), _col46 (type: string), _col47 (type: string) - | | Merge Join Operator [MERGEJOIN_694] + | | Merge Join Operator [MERGEJOIN_695] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col37 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col9","_col10","_col11","_col23","_col25","_col27","_col28","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47"] @@ -147,7 +147,7 @@ Stage-0 | | | Select Operator [SEL_73] | | | outputColumnNames:["_col0"] | | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_657] + | | | Filter Operator [FIL_658] | | | predicate:ib_income_band_sk is not null (type: boolean) | | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_71] @@ -160,7 +160,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 276181762 Data size: 237521904822 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string), _col44 (type: string), _col45 (type: string), _col46 (type: string), _col47 (type: string) - | | Merge Join Operator [MERGEJOIN_693] + | | Merge Join Operator [MERGEJOIN_694] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col35 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col9","_col10","_col11","_col23","_col25","_col27","_col28","_col37","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47"] @@ -174,7 +174,7 @@ Stage-0 | | | Select Operator [SEL_70] | | | outputColumnNames:["_col0"] | | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_656] + | | | Filter Operator [FIL_657] | | | predicate:ib_income_band_sk is not null (type: boolean) | | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_68] @@ -187,7 +187,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 251074324 Data size: 215928999704 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col37 (type: int), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string), _col44 (type: string), _col45 (type: string), _col46 (type: string), _col47 (type: string) - | | Merge Join Operator [MERGEJOIN_692] + | | Merge Join Operator [MERGEJOIN_693] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col17 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col9","_col10","_col11","_col23","_col25","_col27","_col28","_col35","_col37","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47"] @@ -202,7 +202,7 @@ Stage-0 | | | Select Operator [SEL_67] | | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] | | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_655] + | | | Filter Operator [FIL_656] | | | predicate:ca_address_sk is not null (type: boolean) | | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_65] @@ -215,7 +215,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 228249381 Data size: 196299086386 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col35 (type: int), _col37 (type: int), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string) - | | Merge Join Operator [MERGEJOIN_691] + | | Merge Join Operator [MERGEJOIN_692] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col5 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col9","_col10","_col11","_col17","_col23","_col25","_col27","_col28","_col35","_col37","_col39","_col40","_col41","_col42"] @@ -230,7 +230,7 @@ Stage-0 | | | Select Operator [SEL_64] | | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] | | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_654] + | | | Filter Operator [FIL_655] | | | predicate:ca_address_sk is not null (type: boolean) | | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_62] @@ -243,7 +243,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 207499433 Data size: 178453711029 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col35 (type: int), _col37 (type: int) - | | Merge Join Operator [MERGEJOIN_690] + | | Merge Join Operator [MERGEJOIN_691] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col16 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col5","_col9","_col10","_col11","_col17","_col23","_col25","_col27","_col28","_col35","_col37"] @@ -258,7 +258,7 @@ Stage-0 | | | Select Operator [SEL_61] | | | outputColumnNames:["_col0","_col1"] | | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_653] + | | | Filter Operator [FIL_654] | | | predicate:(hd_demo_sk is not null and hd_income_band_sk is not null) (type: boolean) | | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_59] @@ -271,7 +271,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 188635845 Data size: 162230642874 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col5 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col35 (type: int) - | | Merge Join Operator [MERGEJOIN_689] + | | Merge Join Operator [MERGEJOIN_690] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col4 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col5","_col9","_col10","_col11","_col16","_col17","_col23","_col25","_col27","_col28","_col35"] @@ -286,7 +286,7 @@ Stage-0 | | | Select Operator [SEL_58] | | | outputColumnNames:["_col0","_col1"] | | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_652] + | | | Filter Operator [FIL_653] | | | predicate:(hd_demo_sk is not null and hd_income_band_sk is not null) (type: boolean) | | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_56] @@ -299,7 +299,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 171487129 Data size: 147482399417 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col5 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col16 (type: int), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string) - | | Merge Join Operator [MERGEJOIN_688] + | | Merge Join Operator [MERGEJOIN_689] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col7 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col4","_col5","_col9","_col10","_col11","_col16","_col17","_col23","_col25","_col27","_col28"] @@ -313,7 +313,7 @@ Stage-0 | | | Select Operator [SEL_55] | | | outputColumnNames:["_col0"] | | | Statistics:Num rows: 2300 Data size: 2713420 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_651] + | | | Filter Operator [FIL_652] | | | predicate:p_promo_sk is not null (type: boolean) | | | Statistics:Num rows: 2300 Data size: 2713420 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_53] @@ -332,7 +332,7 @@ Stage-0 | | Filter Operator [FIL_51] | | predicate:(_col30 <> _col32) (type: boolean) | | Statistics:Num rows: 155897387 Data size: 134074905655 Basic stats: COMPLETE Column stats: NONE - | | Merge Join Operator [MERGEJOIN_687] + | | Merge Join Operator [MERGEJOIN_688] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col15 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col4","_col5","_col7","_col9","_col10","_col11","_col16","_col17","_col23","_col25","_col27","_col28","_col30","_col32"] @@ -347,7 +347,7 @@ Stage-0 | | | Select Operator [SEL_26] | | | outputColumnNames:["_col0","_col1"] | | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_650] + | | | Filter Operator [FIL_651] | | | predicate:cd_demo_sk is not null (type: boolean) | | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_24] @@ -360,7 +360,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 141724895 Data size: 121886275227 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col4 (type: int), _col5 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col16 (type: int), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col30 (type: string) - | | Merge Join Operator [MERGEJOIN_686] + | | Merge Join Operator [MERGEJOIN_687] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col3 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col4","_col5","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col23","_col25","_col27","_col28","_col30"] @@ -375,7 +375,7 @@ Stage-0 | | | Select Operator [SEL_23] | | | outputColumnNames:["_col0","_col1"] | | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_649] + | | | Filter Operator [FIL_650] | | | predicate:cd_demo_sk is not null (type: boolean) | | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_21] @@ -388,7 +388,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 128840811 Data size: 110805702351 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col4 (type: int), _col5 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string) - | | Merge Join Operator [MERGEJOIN_685] + | | Merge Join Operator [MERGEJOIN_686] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col6 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col23","_col25","_col27","_col28"] @@ -403,7 +403,7 @@ Stage-0 | | | Select Operator [SEL_20] | | | outputColumnNames:["_col0","_col1","_col2"] | | | Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_648] + | | | Filter Operator [FIL_649] | | | predicate:((s_store_sk is not null and s_zip is not null) and s_store_name is not null) (type: boolean) | | | Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_18] @@ -416,7 +416,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 117128008 Data size: 100732454500 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col23 (type: int), _col25 (type: int) - | | Merge Join Operator [MERGEJOIN_684] + | | Merge Join Operator [MERGEJOIN_685] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col18 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col23","_col25"] @@ -431,7 +431,7 @@ Stage-0 | | | Select Operator [SEL_17] | | | outputColumnNames:["_col0","_col1"] | | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_647] + | | | Filter Operator [FIL_648] | | | predicate:d_date_sk is not null (type: boolean) | | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_15] @@ -444,7 +444,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 106480005 Data size: 91574956652 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col23 (type: int) - | | Merge Join Operator [MERGEJOIN_683] + | | Merge Join Operator [MERGEJOIN_684] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col19 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col18","_col23"] @@ -459,7 +459,7 @@ Stage-0 | | | Select Operator [SEL_14] | | | outputColumnNames:["_col0","_col1"] | | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_646] + | | | Filter Operator [FIL_647] | | | predicate:d_date_sk is not null (type: boolean) | | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_12] @@ -472,7 +472,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 96800003 Data size: 83249958789 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col18 (type: int) - | | Merge Join Operator [MERGEJOIN_682] + | | Merge Join Operator [MERGEJOIN_683] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col18","_col19"] @@ -486,7 +486,7 @@ Stage-0 | | | Select Operator [SEL_11] | | | outputColumnNames:["_col0"] | | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_645] + | | | Filter Operator [FIL_646] | | | predicate:((d_year = 2000) and d_date_sk is not null) (type: boolean) | | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_9] @@ -499,7 +499,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 88000001 Data size: 75681779077 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col18 (type: int), _col19 (type: int) - | | Merge Join Operator [MERGEJOIN_681] + | | Merge Join Operator [MERGEJOIN_682] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"} | | | outputColumnNames:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col18","_col19"] @@ -514,7 +514,7 @@ Stage-0 | | | Select Operator [SEL_8] | | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5"] | | | Statistics:Num rows: 80000000 Data size: 68801615852 Basic stats: COMPLETE Column stats: NONE - | | | Filter Operator [FIL_644] + | | | Filter Operator [FIL_645] | | | predicate:(((((c_customer_sk is not null and c_first_sales_date_sk is not null) and c_first_shipto_date_sk is not null) and c_current_cdemo_sk is not null) and c_current_hdemo_sk is not null) and c_current_addr_sk is not null) (type: boolean) | | | Statistics:Num rows: 80000000 Data size: 68801615852 Basic stats: COMPLETE Column stats: NONE | | | TableScan [TS_6] @@ -527,7 +527,7 @@ Stage-0 | | sort order:+ | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | value expressions:_col0 (type: int), _col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)) - | | Merge Join Operator [MERGEJOIN_680] + | | Merge Join Operator [MERGEJOIN_681] | | | condition map:[{"":"Inner Join 0 to 1"}] | | | keys:{"0":"_col1 (type: int), _col8 (type: int)","1":"_col0 (type: int), _col1 (type: int)"} | | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11"] @@ -542,7 +542,7 @@ Stage-0 | | | Select Operator [SEL_2] | | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] | | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | | Filter Operator [FIL_642] + | | | Filter Operator [FIL_643] | | | predicate:((((((((ss_ticket_number is not null and ss_item_sk is not null) and ss_customer_sk is not null) and ss_sold_date_sk is not null) and ss_store_sk is not null) and ss_cdemo_sk is not null) and ss_promo_sk is not null) and ss_hdemo_sk is not null) and ss_addr_sk is not null) (type: boolean) | | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | | TableScan [TS_0] @@ -557,7 +557,7 @@ Stage-0 | | Select Operator [SEL_5] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_643] + | | Filter Operator [FIL_644] | | predicate:(sr_ticket_number is not null and sr_item_sk is not null) (type: boolean) | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | TableScan [TS_3] @@ -595,7 +595,7 @@ Stage-0 | Select Operator [SEL_86] | outputColumnNames:["_col0","_col1","_col2"] | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Merge Join Operator [MERGEJOIN_695] + | Merge Join Operator [MERGEJOIN_696] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col0 (type: int), _col1 (type: int)","1":"_col0 (type: int), _col1 (type: int)"} | | outputColumnNames:["_col0","_col2","_col5","_col6","_col7"] @@ -610,7 +610,7 @@ Stage-0 | | Select Operator [SEL_79] | | outputColumnNames:["_col0","_col1","_col2"] | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_659] + | | Filter Operator [FIL_660] | | predicate:(cs_item_sk is not null and cs_order_number is not null) (type: boolean) | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | TableScan [TS_77] @@ -626,567 +626,567 @@ Stage-0 | Select Operator [SEL_82] | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Filter Operator [FIL_660] + | Filter Operator [FIL_661] | predicate:(cr_item_sk is not null and cr_order_number is not null) (type: boolean) | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | TableScan [TS_80] | alias:catalog_returns | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE |<-Reducer 58 [SIMPLE_EDGE] - Reduce Output Operator [RS_247] + Reduce Output Operator [RS_248] key expressions:_col1 (type: int), _col2 (type: string), _col3 (type: string) Map-reduce partition columns:_col1 (type: int), _col2 (type: string), _col3 (type: string) sort order:+++ Statistics:Num rows: 334179945 Data size: 287401516862 Basic stats: COMPLETE Column stats: NONE value expressions:_col12 (type: int), _col15 (type: bigint), _col16 (type: decimal(17,2)), _col17 (type: decimal(17,2)), _col18 (type: decimal(17,2)) - Select Operator [SEL_245] + Select Operator [SEL_246] outputColumnNames:["_col1","_col12","_col15","_col16","_col17","_col18","_col2","_col3"] Statistics:Num rows: 334179945 Data size: 287401516862 Basic stats: COMPLETE Column stats: NONE - Group By Operator [GBY_244] + Group By Operator [GBY_245] | aggregations:["count(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"] | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: int), KEY._col3 (type: string), KEY._col4 (type: string), KEY._col5 (type: string), KEY._col6 (type: string), KEY._col7 (type: string), KEY._col8 (type: string), KEY._col9 (type: string), KEY._col10 (type: string), KEY._col11 (type: string), KEY._col12 (type: string), KEY._col13 (type: int), KEY._col14 (type: string) | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"] | Statistics:Num rows: 334179945 Data size: 287401516862 Basic stats: COMPLETE Column stats: NONE |<-Reducer 57 [SIMPLE_EDGE] - Reduce Output Operator [RS_243] + Reduce Output Operator [RS_244] key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: int), _col14 (type: string) Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: int), _col14 (type: string) sort order:+++++++++++++++ Statistics:Num rows: 668359891 Data size: 574803034585 Basic stats: COMPLETE Column stats: NONE value expressions:_col15 (type: bigint), _col16 (type: decimal(17,2)), _col17 (type: decimal(17,2)), _col18 (type: decimal(17,2)) - Group By Operator [GBY_242] + Group By Operator [GBY_243] aggregations:["count()","sum(_col9)","sum(_col10)","sum(_col11)"] keys:_col21 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string), _col44 (type: string), _col45 (type: string), _col46 (type: string), _col47 (type: string), _col50 (type: int), _col53 (type: string) outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"] Statistics:Num rows: 668359891 Data size: 574803034585 Basic stats: COMPLETE Column stats: NONE - Select Operator [SEL_241] + Select Operator [SEL_242] outputColumnNames:["_col21","_col23","_col25","_col27","_col28","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47","_col50","_col53","_col9","_col10","_col11"] Statistics:Num rows: 668359891 Data size: 574803034585 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_713] + Merge Join Operator [MERGEJOIN_714] | condition map:[{"":"Inner Join 0 to 1"},{"":"Inner Join 0 to 2"}] | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)","2":"_col0 (type: int)"} | outputColumnNames:["_col9","_col10","_col11","_col23","_col25","_col27","_col28","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47","_col50","_col53"] | Statistics:Num rows: 668359891 Data size: 574803034585 Basic stats: COMPLETE Column stats: NONE |<-Map 74 [SIMPLE_EDGE] - | Reduce Output Operator [RS_238] + | Reduce Output Operator [RS_239] | key expressions:_col0 (type: int) | Map-reduce partition columns:_col0 (type: int) | sort order:+ | Statistics:Num rows: 57750 Data size: 82945057 Basic stats: COMPLETE Column stats: NONE | value expressions:_col3 (type: string) - | Select Operator [SEL_199] + | Select Operator [SEL_200] | outputColumnNames:["_col0","_col3"] | Statistics:Num rows: 57750 Data size: 82945057 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_677] + | Filter Operator [FIL_678] | predicate:((((i_color) IN ('maroon', 'burnished', 'dim', 'steel', 'navajo', 'chocolate') and i_current_price BETWEEN 35 AND 45) and i_current_price BETWEEN 36 AND 50) and i_item_sk is not null) (type: boolean) | Statistics:Num rows: 57750 Data size: 82945057 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_197] + | TableScan [TS_198] | alias:item | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE |<-Reducer 56 [SIMPLE_EDGE] - | Reduce Output Operator [RS_237] + | Reduce Output Operator [RS_238] | key expressions:_col1 (type: int) | Map-reduce partition columns:_col1 (type: int) | sort order:+ | Statistics:Num rows: 303799944 Data size: 261274100967 Basic stats: COMPLETE Column stats: NONE | value expressions:_col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string), _col44 (type: string), _col45 (type: string), _col46 (type: string), _col47 (type: string) - | Merge Join Operator [MERGEJOIN_711] + | Merge Join Operator [MERGEJOIN_712] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col37 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col9","_col10","_col11","_col23","_col25","_col27","_col28","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47"] | | Statistics:Num rows: 303799944 Data size: 261274100967 Basic stats: COMPLETE Column stats: NONE | |<-Map 73 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_235] + | | Reduce Output Operator [RS_236] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE - | | Select Operator [SEL_196] + | | Select Operator [SEL_197] | | outputColumnNames:["_col0"] | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_676] + | | Filter Operator [FIL_677] | | predicate:ib_income_band_sk is not null (type: boolean) | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_194] + | | TableScan [TS_195] | | alias:ib1 | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 55 [SIMPLE_EDGE] - | Reduce Output Operator [RS_234] + | Reduce Output Operator [RS_235] | key expressions:_col37 (type: int) | Map-reduce partition columns:_col37 (type: int) | sort order:+ | Statistics:Num rows: 276181762 Data size: 237521904822 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string), _col44 (type: string), _col45 (type: string), _col46 (type: string), _col47 (type: string) - | Merge Join Operator [MERGEJOIN_710] + | Merge Join Operator [MERGEJOIN_711] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col35 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col9","_col10","_col11","_col23","_col25","_col27","_col28","_col37","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47"] | | Statistics:Num rows: 276181762 Data size: 237521904822 Basic stats: COMPLETE Column stats: NONE | |<-Map 72 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_232] + | | Reduce Output Operator [RS_233] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE - | | Select Operator [SEL_193] + | | Select Operator [SEL_194] | | outputColumnNames:["_col0"] | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_675] + | | Filter Operator [FIL_676] | | predicate:ib_income_band_sk is not null (type: boolean) | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_191] + | | TableScan [TS_192] | | alias:ib1 | | Statistics:Num rows: 20 Data size: 240 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 54 [SIMPLE_EDGE] - | Reduce Output Operator [RS_231] + | Reduce Output Operator [RS_232] | key expressions:_col35 (type: int) | Map-reduce partition columns:_col35 (type: int) | sort order:+ | Statistics:Num rows: 251074324 Data size: 215928999704 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col37 (type: int), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string), _col44 (type: string), _col45 (type: string), _col46 (type: string), _col47 (type: string) - | Merge Join Operator [MERGEJOIN_709] + | Merge Join Operator [MERGEJOIN_710] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col17 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col9","_col10","_col11","_col23","_col25","_col27","_col28","_col35","_col37","_col39","_col40","_col41","_col42","_col44","_col45","_col46","_col47"] | | Statistics:Num rows: 251074324 Data size: 215928999704 Basic stats: COMPLETE Column stats: NONE | |<-Map 71 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_229] + | | Reduce Output Operator [RS_230] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string) - | | Select Operator [SEL_190] + | | Select Operator [SEL_191] | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_674] + | | Filter Operator [FIL_675] | | predicate:ca_address_sk is not null (type: boolean) | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_188] + | | TableScan [TS_189] | | alias:ad1 | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 53 [SIMPLE_EDGE] - | Reduce Output Operator [RS_228] + | Reduce Output Operator [RS_229] | key expressions:_col17 (type: int) | Map-reduce partition columns:_col17 (type: int) | sort order:+ | Statistics:Num rows: 228249381 Data size: 196299086386 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col35 (type: int), _col37 (type: int), _col39 (type: string), _col40 (type: string), _col41 (type: string), _col42 (type: string) - | Merge Join Operator [MERGEJOIN_708] + | Merge Join Operator [MERGEJOIN_709] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col5 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col9","_col10","_col11","_col17","_col23","_col25","_col27","_col28","_col35","_col37","_col39","_col40","_col41","_col42"] | | Statistics:Num rows: 228249381 Data size: 196299086386 Basic stats: COMPLETE Column stats: NONE | |<-Map 70 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_226] + | | Reduce Output Operator [RS_227] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string) - | | Select Operator [SEL_187] + | | Select Operator [SEL_188] | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_673] + | | Filter Operator [FIL_674] | | predicate:ca_address_sk is not null (type: boolean) | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_185] + | | TableScan [TS_186] | | alias:ad1 | | Statistics:Num rows: 40000000 Data size: 40595195284 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 52 [SIMPLE_EDGE] - | Reduce Output Operator [RS_225] + | Reduce Output Operator [RS_226] | key expressions:_col5 (type: int) | Map-reduce partition columns:_col5 (type: int) | sort order:+ | Statistics:Num rows: 207499433 Data size: 178453711029 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col35 (type: int), _col37 (type: int) - | Merge Join Operator [MERGEJOIN_707] + | Merge Join Operator [MERGEJOIN_708] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col16 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col5","_col9","_col10","_col11","_col17","_col23","_col25","_col27","_col28","_col35","_col37"] | | Statistics:Num rows: 207499433 Data size: 178453711029 Basic stats: COMPLETE Column stats: NONE | |<-Map 69 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_223] + | | Reduce Output Operator [RS_224] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int) - | | Select Operator [SEL_184] + | | Select Operator [SEL_185] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_672] + | | Filter Operator [FIL_673] | | predicate:(hd_demo_sk is not null and hd_income_band_sk is not null) (type: boolean) | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_182] + | | TableScan [TS_183] | | alias:hd1 | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 51 [SIMPLE_EDGE] - | Reduce Output Operator [RS_222] + | Reduce Output Operator [RS_223] | key expressions:_col16 (type: int) | Map-reduce partition columns:_col16 (type: int) | sort order:+ | Statistics:Num rows: 188635845 Data size: 162230642874 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col5 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col35 (type: int) - | Merge Join Operator [MERGEJOIN_706] + | Merge Join Operator [MERGEJOIN_707] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col4 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col5","_col9","_col10","_col11","_col16","_col17","_col23","_col25","_col27","_col28","_col35"] | | Statistics:Num rows: 188635845 Data size: 162230642874 Basic stats: COMPLETE Column stats: NONE | |<-Map 68 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_220] + | | Reduce Output Operator [RS_221] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int) - | | Select Operator [SEL_181] + | | Select Operator [SEL_182] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_671] + | | Filter Operator [FIL_672] | | predicate:(hd_demo_sk is not null and hd_income_band_sk is not null) (type: boolean) | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_179] + | | TableScan [TS_180] | | alias:hd1 | | Statistics:Num rows: 7200 Data size: 770400 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 50 [SIMPLE_EDGE] - | Reduce Output Operator [RS_219] + | Reduce Output Operator [RS_220] | key expressions:_col4 (type: int) | Map-reduce partition columns:_col4 (type: int) | sort order:+ | Statistics:Num rows: 171487129 Data size: 147482399417 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col5 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col16 (type: int), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string) - | Merge Join Operator [MERGEJOIN_705] + | Merge Join Operator [MERGEJOIN_706] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col7 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col4","_col5","_col9","_col10","_col11","_col16","_col17","_col23","_col25","_col27","_col28"] | | Statistics:Num rows: 171487129 Data size: 147482399417 Basic stats: COMPLETE Column stats: NONE | |<-Map 67 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_217] + | | Reduce Output Operator [RS_218] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 2300 Data size: 2713420 Basic stats: COMPLETE Column stats: NONE - | | Select Operator [SEL_178] + | | Select Operator [SEL_179] | | outputColumnNames:["_col0"] | | Statistics:Num rows: 2300 Data size: 2713420 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_670] + | | Filter Operator [FIL_671] | | predicate:p_promo_sk is not null (type: boolean) | | Statistics:Num rows: 2300 Data size: 2713420 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_176] + | | TableScan [TS_177] | | alias:promotion | | Statistics:Num rows: 2300 Data size: 2713420 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 49 [SIMPLE_EDGE] - | Reduce Output Operator [RS_216] + | Reduce Output Operator [RS_217] | key expressions:_col7 (type: int) | Map-reduce partition columns:_col7 (type: int) | sort order:+ | Statistics:Num rows: 155897387 Data size: 134074905655 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col4 (type: int), _col5 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col16 (type: int), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string) - | Select Operator [SEL_175] + | Select Operator [SEL_176] | outputColumnNames:["_col1","_col10","_col11","_col16","_col17","_col23","_col25","_col27","_col28","_col4","_col5","_col7","_col9"] | Statistics:Num rows: 155897387 Data size: 134074905655 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_174] + | Filter Operator [FIL_175] | predicate:(_col30 <> _col32) (type: boolean) | Statistics:Num rows: 155897387 Data size: 134074905655 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_704] + | Merge Join Operator [MERGEJOIN_705] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col15 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col4","_col5","_col7","_col9","_col10","_col11","_col16","_col17","_col23","_col25","_col27","_col28","_col30","_col32"] | | Statistics:Num rows: 155897387 Data size: 134074905655 Basic stats: COMPLETE Column stats: NONE | |<-Map 66 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_172] + | | Reduce Output Operator [RS_173] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string) - | | Select Operator [SEL_149] + | | Select Operator [SEL_150] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_669] + | | Filter Operator [FIL_670] | | predicate:cd_demo_sk is not null (type: boolean) | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_147] + | | TableScan [TS_148] | | alias:cd1 | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 48 [SIMPLE_EDGE] - | Reduce Output Operator [RS_171] + | Reduce Output Operator [RS_172] | key expressions:_col15 (type: int) | Map-reduce partition columns:_col15 (type: int) | sort order:+ | Statistics:Num rows: 141724895 Data size: 121886275227 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col4 (type: int), _col5 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col16 (type: int), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string), _col30 (type: string) - | Merge Join Operator [MERGEJOIN_703] + | Merge Join Operator [MERGEJOIN_704] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col3 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col4","_col5","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col23","_col25","_col27","_col28","_col30"] | | Statistics:Num rows: 141724895 Data size: 121886275227 Basic stats: COMPLETE Column stats: NONE | |<-Map 65 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_169] + | | Reduce Output Operator [RS_170] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string) - | | Select Operator [SEL_146] + | | Select Operator [SEL_147] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_668] + | | Filter Operator [FIL_669] | | predicate:cd_demo_sk is not null (type: boolean) | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_144] + | | TableScan [TS_145] | | alias:cd1 | | Statistics:Num rows: 19800 Data size: 7171059 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 47 [SIMPLE_EDGE] - | Reduce Output Operator [RS_168] + | Reduce Output Operator [RS_169] | key expressions:_col3 (type: int) | Map-reduce partition columns:_col3 (type: int) | sort order:+ | Statistics:Num rows: 128840811 Data size: 110805702351 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col4 (type: int), _col5 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col23 (type: int), _col25 (type: int), _col27 (type: string), _col28 (type: string) - | Merge Join Operator [MERGEJOIN_702] + | Merge Join Operator [MERGEJOIN_703] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col6 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col3","_col4","_col5","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col23","_col25","_col27","_col28"] | | Statistics:Num rows: 128840811 Data size: 110805702351 Basic stats: COMPLETE Column stats: NONE | |<-Map 64 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_166] + | | Reduce Output Operator [RS_167] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: string), _col2 (type: string) - | | Select Operator [SEL_143] + | | Select Operator [SEL_144] | | outputColumnNames:["_col0","_col1","_col2"] | | Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_667] + | | Filter Operator [FIL_668] | | predicate:((s_store_sk is not null and s_zip is not null) and s_store_name is not null) (type: boolean) | | Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_141] + | | TableScan [TS_142] | | alias:store | | Statistics:Num rows: 1704 Data size: 3256276 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 46 [SIMPLE_EDGE] - | Reduce Output Operator [RS_165] + | Reduce Output Operator [RS_166] | key expressions:_col6 (type: int) | Map-reduce partition columns:_col6 (type: int) | sort order:+ | Statistics:Num rows: 117128008 Data size: 100732454500 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col23 (type: int), _col25 (type: int) - | Merge Join Operator [MERGEJOIN_701] + | Merge Join Operator [MERGEJOIN_702] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col18 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col23","_col25"] | | Statistics:Num rows: 117128008 Data size: 100732454500 Basic stats: COMPLETE Column stats: NONE | |<-Map 63 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_163] + | | Reduce Output Operator [RS_164] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int) - | | Select Operator [SEL_140] + | | Select Operator [SEL_141] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_666] + | | Filter Operator [FIL_667] | | predicate:d_date_sk is not null (type: boolean) | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_138] + | | TableScan [TS_139] | | alias:d1 | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 45 [SIMPLE_EDGE] - | Reduce Output Operator [RS_162] + | Reduce Output Operator [RS_163] | key expressions:_col18 (type: int) | Map-reduce partition columns:_col18 (type: int) | sort order:+ | Statistics:Num rows: 106480005 Data size: 91574956652 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col23 (type: int) - | Merge Join Operator [MERGEJOIN_700] + | Merge Join Operator [MERGEJOIN_701] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col19 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col18","_col23"] | | Statistics:Num rows: 106480005 Data size: 91574956652 Basic stats: COMPLETE Column stats: NONE | |<-Map 62 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_160] + | | Reduce Output Operator [RS_161] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int) - | | Select Operator [SEL_137] + | | Select Operator [SEL_138] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_665] + | | Filter Operator [FIL_666] | | predicate:d_date_sk is not null (type: boolean) | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_135] + | | TableScan [TS_136] | | alias:d1 | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 44 [SIMPLE_EDGE] - | Reduce Output Operator [RS_159] + | Reduce Output Operator [RS_160] | key expressions:_col19 (type: int) | Map-reduce partition columns:_col19 (type: int) | sort order:+ | Statistics:Num rows: 96800003 Data size: 83249958789 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col18 (type: int) - | Merge Join Operator [MERGEJOIN_699] + | Merge Join Operator [MERGEJOIN_700] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col18","_col19"] | | Statistics:Num rows: 96800003 Data size: 83249958789 Basic stats: COMPLETE Column stats: NONE | |<-Map 61 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_157] + | | Reduce Output Operator [RS_158] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | Select Operator [SEL_134] + | | Select Operator [SEL_135] | | outputColumnNames:["_col0"] | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_664] + | | Filter Operator [FIL_665] | | predicate:((d_year = 2001) and d_date_sk is not null) (type: boolean) | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_132] + | | TableScan [TS_133] | | alias:d1 | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 43 [SIMPLE_EDGE] - | Reduce Output Operator [RS_156] + | Reduce Output Operator [RS_157] | key expressions:_col0 (type: int) | Map-reduce partition columns:_col0 (type: int) | sort order:+ | Statistics:Num rows: 88000001 Data size: 75681779077 Basic stats: COMPLETE Column stats: NONE | value expressions:_col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)), _col15 (type: int), _col16 (type: int), _col17 (type: int), _col18 (type: int), _col19 (type: int) - | Merge Join Operator [MERGEJOIN_698] + | Merge Join Operator [MERGEJOIN_699] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"} | | outputColumnNames:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col15","_col16","_col17","_col18","_col19"] | | Statistics:Num rows: 88000001 Data size: 75681779077 Basic stats: COMPLETE Column stats: NONE | |<-Map 60 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_154] + | | Reduce Output Operator [RS_155] | | key expressions:_col0 (type: int) | | Map-reduce partition columns:_col0 (type: int) | | sort order:+ | | Statistics:Num rows: 80000000 Data size: 68801615852 Basic stats: COMPLETE Column stats: NONE | | value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int) - | | Select Operator [SEL_131] + | | Select Operator [SEL_132] | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5"] | | Statistics:Num rows: 80000000 Data size: 68801615852 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_663] + | | Filter Operator [FIL_664] | | predicate:(((((c_customer_sk is not null and c_first_sales_date_sk is not null) and c_first_shipto_date_sk is not null) and c_current_cdemo_sk is not null) and c_current_hdemo_sk is not null) and c_current_addr_sk is not null) (type: boolean) | | Statistics:Num rows: 80000000 Data size: 68801615852 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_129] + | | TableScan [TS_130] | | alias:customer | | Statistics:Num rows: 80000000 Data size: 68801615852 Basic stats: COMPLETE Column stats: NONE | |<-Reducer 42 [SIMPLE_EDGE] - | Reduce Output Operator [RS_153] + | Reduce Output Operator [RS_154] | key expressions:_col2 (type: int) | Map-reduce partition columns:_col2 (type: int) | sort order:+ | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | value expressions:_col0 (type: int), _col1 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)) - | Merge Join Operator [MERGEJOIN_697] + | Merge Join Operator [MERGEJOIN_698] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{"0":"_col1 (type: int), _col8 (type: int)","1":"_col0 (type: int), _col1 (type: int)"} | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11"] | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | |<-Map 41 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_150] + | | Reduce Output Operator [RS_151] | | key expressions:_col1 (type: int), _col8 (type: int) | | Map-reduce partition columns:_col1 (type: int), _col8 (type: int) | | sort order:++ | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | | value expressions:_col0 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col9 (type: decimal(7,2)), _col10 (type: decimal(7,2)), _col11 (type: decimal(7,2)) - | | Select Operator [SEL_125] + | | Select Operator [SEL_126] | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_661] + | | Filter Operator [FIL_662] | | predicate:((((((((ss_ticket_number is not null and ss_item_sk is not null) and ss_customer_sk is not null) and ss_sold_date_sk is not null) and ss_store_sk is not null) and ss_cdemo_sk is not null) and ss_promo_sk is not null) and ss_hdemo_sk is not null) and ss_addr_sk is not null) (type: boolean) | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_123] + | | TableScan [TS_124] | | alias:store_sales | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | |<-Map 59 [SIMPLE_EDGE] - | Reduce Output Operator [RS_151] + | Reduce Output Operator [RS_152] | key expressions:_col0 (type: int), _col1 (type: int) | Map-reduce partition columns:_col0 (type: int), _col1 (type: int) | sort order:++ | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Select Operator [SEL_128] + | Select Operator [SEL_129] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Filter Operator [FIL_662] + | Filter Operator [FIL_663] | predicate:(sr_ticket_number is not null and sr_item_sk is not null) (type: boolean) | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | TableScan [TS_126] + | TableScan [TS_127] | alias:store_returns | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE |<-Reducer 77 [SIMPLE_EDGE] - Reduce Output Operator [RS_239] + Reduce Output Operator [RS_240] key expressions:_col0 (type: int) Map-reduce partition columns:_col0 (type: int) sort order:+ Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Select Operator [SEL_215] + Select Operator [SEL_216] outputColumnNames:["_col0"] Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Filter Operator [FIL_214] + Filter Operator [FIL_215] predicate:(_col1 > (2 * _col2)) (type: boolean) Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Group By Operator [GBY_213] + Group By Operator [GBY_214] | aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"] | keys:KEY._col0 (type: int) | outputColumnNames:["_col0","_col1","_col2"] | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE |<-Reducer 76 [SIMPLE_EDGE] - Reduce Output Operator [RS_212] + Reduce Output Operator [RS_213] key expressions:_col0 (type: int) Map-reduce partition columns:_col0 (type: int) sort order:+ Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE value expressions:_col1 (type: decimal(17,2)), _col2 (type: decimal(19,2)) - Group By Operator [GBY_211] + Group By Operator [GBY_212] aggregations:["sum(_col1)","sum(_col2)"] keys:_col0 (type: int) outputColumnNames:["_col0","_col1","_col2"] Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Select Operator [SEL_209] + Select Operator [SEL_210] outputColumnNames:["_col0","_col1","_col2"] Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Merge Join Operator [MERGEJOIN_712] + Merge Join Operator [MERGEJOIN_713] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{"0":"_col0 (type: int), _col1 (type: int)","1":"_col0 (type: int), _col1 (type: int)"} | outputColumnNames:["_col0","_col2","_col5","_col6","_col7"] | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE |<-Map 75 [SIMPLE_EDGE] - | Reduce Output Operator [RS_206] + | Reduce Output Operator [RS_207] | key expressions:_col0 (type: int), _col1 (type: int) | Map-reduce partition columns:_col0 (type: int), _col1 (type: int) | sort order:++ | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE | value expressions:_col2 (type: decimal(7,2)) - | Select Operator [SEL_202] + | Select Operator [SEL_203] | outputColumnNames:["_col0","_col1","_col2"] | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Filter Operator [FIL_678] + | Filter Operator [FIL_679] | predicate:(cs_item_sk is not null and cs_order_number is not null) (type: boolean) | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | TableScan [TS_200] + | TableScan [TS_201] | alias:catalog_sales | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE |<-Map 78 [SIMPLE_EDGE] - Reduce Output Operator [RS_207] + Reduce Output Operator [RS_208] key expressions:_col0 (type: int), _col1 (type: int) Map-reduce partition columns:_col0 (type: int), _col1 (type: int) sort order:++ Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE value expressions:_col2 (type: decimal(7,2)), _col3 (type: decimal(7,2)), _col4 (type: decimal(7,2)) - Select Operator [SEL_205] + Select Operator [SEL_206] outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Filter Operator [FIL_679] + Filter Operator [FIL_680] predicate:(cr_item_sk is not null and cr_order_number is not null) (type: boolean) Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - TableScan [TS_203] + TableScan [TS_204] alias:catalog_returns Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE diff --git a/ql/src/test/results/clientpositive/perf/query66.q.out b/ql/src/test/results/clientpositive/perf/query66.q.out index 22eaf61..b2e6bf7 100644 --- a/ql/src/test/results/clientpositive/perf/query66.q.out +++ b/ql/src/test/results/clientpositive/perf/query66.q.out @@ -472,325 +472,328 @@ Stage-0 key expressions:_col0 (type: string) sort order:+ Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE - value expressions:_col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int), _col8 (type: decimal(38,2)), _col9 (type: decimal(38,2)), _col10 (type: decimal(38,2)), _col11 (type: decimal(38,2)), _col12 (type: decimal(38,2)), _col13 (type: decimal(38,2)), _col14 (type: decimal(38,2)), _col15 (type: decimal(38,2)), _col16 (type: decimal(38,2)), _col17 (type: decimal(38,2)), _col18 (type: decimal(38,2)), _col19 (type: decimal(38,2)), _col20 (type: decimal(38,12)), _col21 (type: decimal(38,12)), _col22 (type: decimal(38,12)), _col23 (type: decimal(38,12)), _col24 (type: decimal(38,12)), _col25 (type: decimal(38,12)), _col26 (type: decimal(38,12)), _col27 (type: decimal(38,12)), _col28 (type: decimal(38,12)), _col29 (type: decimal(38,12)), _col30 (type: decimal(38,12)), _col31 (type: decimal(38,12)), _col32 (type: decimal(38,2)), _col33 (type: decimal(38,2)), _col34 (type: decimal(38,2)), _col35 (type: decimal(38,2)), _col36 (type: decimal(38,2)), _col37 (type: decimal(38,2)), _col38 (type: decimal(38,2)), _col39 (type: decimal(38,2)), _col40 (type: decimal(38,2)), _col41 (type: decimal(38,2)), _col42 (type: decimal(38,2)), _col43 (type: decimal(38,2)) - Group By Operator [GBY_71] - | aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)","sum(VALUE._col24)","sum(VALUE._col25)","sum(VALUE._col26)","sum(VALUE._col27)","sum(VALUE._col28)","sum(VALUE._col29)","sum(VALUE._col30)","sum(VALUE._col31)","sum(VALUE._col32)","sum(VALUE._col33)","sum(VALUE._col34)","sum(VALUE._col35)"] - | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: string), KEY._col4 (type: string), KEY._col5 (type: string), KEY._col6 (type: string), KEY._col7 (type: int) - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] - | Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE - |<-Union 7 [SIMPLE_EDGE] - |<-Reducer 19 [CONTAINS] - | Reduce Output Operator [RS_70] - | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) - | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) - | sort order:++++++++ - | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col8 (type: decimal(38,2)), _col9 (type: decimal(38,2)), _col10 (type: decimal(38,2)), _col11 (type: decimal(38,2)), _col12 (type: decimal(38,2)), _col13 (type: decimal(38,2)), _col14 (type: decimal(38,2)), _col15 (type: decimal(38,2)), _col16 (type: decimal(38,2)), _col17 (type: decimal(38,2)), _col18 (type: decimal(38,2)), _col19 (type: decimal(38,2)), _col20 (type: decimal(38,12)), _col21 (type: decimal(38,12)), _col22 (type: decimal(38,12)), _col23 (type: decimal(38,12)), _col24 (type: decimal(38,12)), _col25 (type: decimal(38,12)), _col26 (type: decimal(38,12)), _col27 (type: decimal(38,12)), _col28 (type: decimal(38,12)), _col29 (type: decimal(38,12)), _col30 (type: decimal(38,12)), _col31 (type: decimal(38,12)), _col32 (type: decimal(38,2)), _col33 (type: decimal(38,2)), _col34 (type: decimal(38,2)), _col35 (type: decimal(38,2)), _col36 (type: decimal(38,2)), _col37 (type: decimal(38,2)), _col38 (type: decimal(38,2)), _col39 (type: decimal(38,2)), _col40 (type: decimal(38,2)), _col41 (type: decimal(38,2)), _col42 (type: decimal(38,2)), _col43 (type: decimal(38,2)) - | Group By Operator [GBY_69] - | aggregations:["sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)","sum(_col31)","sum(_col32)","sum(_col33)","sum(_col34)","sum(_col35)","sum(_col36)","sum(_col37)","sum(_col38)","sum(_col39)","sum(_col40)","sum(_col41)","sum(_col42)","sum(_col43)"] - | keys:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] - | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_67] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] - | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_65] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31"] - | Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE - | Group By Operator [GBY_64] - | | aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)"] - | | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: string), KEY._col4 (type: string), KEY._col5 (type: string), KEY._col6 (type: int) - | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] - | | Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE - | |<-Reducer 18 [SIMPLE_EDGE] - | Reduce Output Operator [RS_63] - | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) - | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) - | sort order:+++++++ - | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col7 (type: decimal(28,2)), _col8 (type: decimal(28,2)), _col9 (type: decimal(28,2)), _col10 (type: decimal(28,2)), _col11 (type: decimal(28,2)), _col12 (type: decimal(28,2)), _col13 (type: decimal(28,2)), _col14 (type: decimal(28,2)), _col15 (type: decimal(28,2)), _col16 (type: decimal(28,2)), _col17 (type: decimal(28,2)), _col18 (type: decimal(28,2)), _col19 (type: decimal(28,2)), _col20 (type: decimal(28,2)), _col21 (type: decimal(28,2)), _col22 (type: decimal(28,2)), _col23 (type: decimal(28,2)), _col24 (type: decimal(28,2)), _col25 (type: decimal(28,2)), _col26 (type: decimal(28,2)), _col27 (type: decimal(28,2)), _col28 (type: decimal(28,2)), _col29 (type: decimal(28,2)), _col30 (type: decimal(28,2)) - | Group By Operator [GBY_62] - | aggregations:["sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)"] - | keys:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] - | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_60] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] - | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_122] - | | condition map:[{"":"Inner Join 0 to 1"}] - | | keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"} - | | outputColumnNames:["_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] - | | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - | |<-Map 23 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_58] - | | key expressions:_col0 (type: int) - | | Map-reduce partition columns:_col0 (type: int) - | | sort order:+ - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Select Operator [SEL_47] - | | outputColumnNames:["_col0"] - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_114] - | | predicate:((sm_carrier) IN ('DIAMOND', 'AIRBORNE') and sm_ship_mode_sk is not null) (type: boolean) - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_45] - | | alias:ship_mode - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | |<-Reducer 17 [SIMPLE_EDGE] - | Reduce Output Operator [RS_57] - | key expressions:_col2 (type: int) - | Map-reduce partition columns:_col2 (type: int) - | sort order:+ - | Statistics:Num rows: 47520 Data size: 22381920 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string), _col16 (type: int) - | Merge Join Operator [MERGEJOIN_121] - | | condition map:[{"":"Inner Join 0 to 1"}] - | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} - | | outputColumnNames:["_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] - | | Statistics:Num rows: 47520 Data size: 22381920 Basic stats: COMPLETE Column stats: NONE - | |<-Map 22 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_55] - | | key expressions:_col0 (type: int) - | | Map-reduce partition columns:_col0 (type: int) - | | sort order:+ - | | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE - | | Select Operator [SEL_44] - | | outputColumnNames:["_col0"] - | | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_113] - | | predicate:(t_time BETWEEN 49530 AND 78330 and t_time_sk is not null) (type: boolean) - | | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_42] - | | alias:time_dim - | | Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE - | |<-Reducer 16 [SIMPLE_EDGE] - | Reduce Output Operator [RS_54] - | key expressions:_col1 (type: int) - | Map-reduce partition columns:_col1 (type: int) - | sort order:+ - | Statistics:Num rows: 40176 Data size: 44957392 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string), _col16 (type: int) - | Merge Join Operator [MERGEJOIN_120] - | | condition map:[{"":"Inner Join 0 to 1"}] - | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} - | | outputColumnNames:["_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] - | | Statistics:Num rows: 40176 Data size: 44957392 Basic stats: COMPLETE Column stats: NONE - | |<-Map 21 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_52] - | | key expressions:_col0 (type: int) - | | Map-reduce partition columns:_col0 (type: int) - | | sort order:+ - | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | value expressions:_col2 (type: int) - | | Select Operator [SEL_41] - | | outputColumnNames:["_col0","_col2"] - | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_112] - | | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) - | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_39] - | | alias:date_dim - | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - | |<-Reducer 15 [SIMPLE_EDGE] - | Reduce Output Operator [RS_51] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 29 Data size: 30582 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col1 (type: int), _col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string) - | Merge Join Operator [MERGEJOIN_119] - | | condition map:[{"":"Inner Join 0 to 1"}] - | | keys:{"0":"_col3 (type: int)","1":"_col0 (type: int)"} - | | outputColumnNames:["_col0","_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13"] - | | Statistics:Num rows: 29 Data size: 30582 Basic stats: COMPLETE Column stats: NONE - | |<-Map 14 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_48] - | | key expressions:_col3 (type: int) - | | Map-reduce partition columns:_col3 (type: int) - | | sort order:+ - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | value expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)) - | | Select Operator [SEL_35] - | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_110] - | | predicate:(((cs_warehouse_sk is not null and cs_sold_date_sk is not null) and cs_sold_time_sk is not null) and cs_ship_mode_sk is not null) (type: boolean) - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_33] - | | alias:catalog_sales - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | |<-Map 20 [SIMPLE_EDGE] - | Reduce Output Operator [RS_49] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col1 (type: string), _col2 (type: int), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string) - | Select Operator [SEL_38] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - | Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_111] - | predicate:w_warehouse_sk is not null (type: boolean) - | Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_36] - | alias:warehouse - | Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 6 [CONTAINS] - Reduce Output Operator [RS_70] - key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) - Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) - sort order:++++++++ - Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - value expressions:_col8 (type: decimal(38,2)), _col9 (type: decimal(38,2)), _col10 (type: decimal(38,2)), _col11 (type: decimal(38,2)), _col12 (type: decimal(38,2)), _col13 (type: decimal(38,2)), _col14 (type: decimal(38,2)), _col15 (type: decimal(38,2)), _col16 (type: decimal(38,2)), _col17 (type: decimal(38,2)), _col18 (type: decimal(38,2)), _col19 (type: decimal(38,2)), _col20 (type: decimal(38,12)), _col21 (type: decimal(38,12)), _col22 (type: decimal(38,12)), _col23 (type: decimal(38,12)), _col24 (type: decimal(38,12)), _col25 (type: decimal(38,12)), _col26 (type: decimal(38,12)), _col27 (type: decimal(38,12)), _col28 (type: decimal(38,12)), _col29 (type: decimal(38,12)), _col30 (type: decimal(38,12)), _col31 (type: decimal(38,12)), _col32 (type: decimal(38,2)), _col33 (type: decimal(38,2)), _col34 (type: decimal(38,2)), _col35 (type: decimal(38,2)), _col36 (type: decimal(38,2)), _col37 (type: decimal(38,2)), _col38 (type: decimal(38,2)), _col39 (type: decimal(38,2)), _col40 (type: decimal(38,2)), _col41 (type: decimal(38,2)), _col42 (type: decimal(38,2)), _col43 (type: decimal(38,2)) - Group By Operator [GBY_69] - aggregations:["sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)","sum(_col31)","sum(_col32)","sum(_col33)","sum(_col34)","sum(_col35)","sum(_col36)","sum(_col37)","sum(_col38)","sum(_col39)","sum(_col40)","sum(_col41)","sum(_col42)","sum(_col43)"] - keys:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) - outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] + value expressions:_col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col8 (type: decimal(38,2)), _col9 (type: decimal(38,2)), _col10 (type: decimal(38,2)), _col11 (type: decimal(38,2)), _col12 (type: decimal(38,2)), _col13 (type: decimal(38,2)), _col14 (type: decimal(38,2)), _col15 (type: decimal(38,2)), _col16 (type: decimal(38,2)), _col17 (type: decimal(38,2)), _col18 (type: decimal(38,2)), _col19 (type: decimal(38,2)), _col20 (type: decimal(38,12)), _col21 (type: decimal(38,12)), _col22 (type: decimal(38,12)), _col23 (type: decimal(38,12)), _col24 (type: decimal(38,12)), _col25 (type: decimal(38,12)), _col26 (type: decimal(38,12)), _col27 (type: decimal(38,12)), _col28 (type: decimal(38,12)), _col29 (type: decimal(38,12)), _col30 (type: decimal(38,12)), _col31 (type: decimal(38,12)), _col32 (type: decimal(38,2)), _col33 (type: decimal(38,2)), _col34 (type: decimal(38,2)), _col35 (type: decimal(38,2)), _col36 (type: decimal(38,2)), _col37 (type: decimal(38,2)), _col38 (type: decimal(38,2)), _col39 (type: decimal(38,2)), _col40 (type: decimal(38,2)), _col41 (type: decimal(38,2)), _col42 (type: decimal(38,2)), _col43 (type: decimal(38,2)) + Select Operator [SEL_72] + outputColumnNames:["_col0","_col1","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col2","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col3","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col4","_col40","_col41","_col42","_col43","_col5","_col6","_col8","_col9"] + Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE + Group By Operator [GBY_71] + | aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)","sum(VALUE._col24)","sum(VALUE._col25)","sum(VALUE._col26)","sum(VALUE._col27)","sum(VALUE._col28)","sum(VALUE._col29)","sum(VALUE._col30)","sum(VALUE._col31)","sum(VALUE._col32)","sum(VALUE._col33)","sum(VALUE._col34)","sum(VALUE._col35)"] + | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: string), KEY._col4 (type: string), KEY._col5 (type: string), KEY._col6 (type: string), KEY._col7 (type: int) + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] + | Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE + |<-Union 7 [SIMPLE_EDGE] + |<-Reducer 19 [CONTAINS] + | Reduce Output Operator [RS_70] + | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) + | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) + | sort order:++++++++ + | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col8 (type: decimal(38,2)), _col9 (type: decimal(38,2)), _col10 (type: decimal(38,2)), _col11 (type: decimal(38,2)), _col12 (type: decimal(38,2)), _col13 (type: decimal(38,2)), _col14 (type: decimal(38,2)), _col15 (type: decimal(38,2)), _col16 (type: decimal(38,2)), _col17 (type: decimal(38,2)), _col18 (type: decimal(38,2)), _col19 (type: decimal(38,2)), _col20 (type: decimal(38,12)), _col21 (type: decimal(38,12)), _col22 (type: decimal(38,12)), _col23 (type: decimal(38,12)), _col24 (type: decimal(38,12)), _col25 (type: decimal(38,12)), _col26 (type: decimal(38,12)), _col27 (type: decimal(38,12)), _col28 (type: decimal(38,12)), _col29 (type: decimal(38,12)), _col30 (type: decimal(38,12)), _col31 (type: decimal(38,12)), _col32 (type: decimal(38,2)), _col33 (type: decimal(38,2)), _col34 (type: decimal(38,2)), _col35 (type: decimal(38,2)), _col36 (type: decimal(38,2)), _col37 (type: decimal(38,2)), _col38 (type: decimal(38,2)), _col39 (type: decimal(38,2)), _col40 (type: decimal(38,2)), _col41 (type: decimal(38,2)), _col42 (type: decimal(38,2)), _col43 (type: decimal(38,2)) + | Group By Operator [GBY_69] + | aggregations:["sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)","sum(_col31)","sum(_col32)","sum(_col33)","sum(_col34)","sum(_col35)","sum(_col36)","sum(_col37)","sum(_col38)","sum(_col39)","sum(_col40)","sum(_col41)","sum(_col42)","sum(_col43)"] + | keys:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), 2002 (type: int) + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] + | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_67] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] + | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_65] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] + | Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE + | Group By Operator [GBY_64] + | | aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)"] + | | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: string), KEY._col4 (type: string), KEY._col5 (type: string), KEY._col6 (type: int) + | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] + | | Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE + | |<-Reducer 18 [SIMPLE_EDGE] + | Reduce Output Operator [RS_63] + | key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) + | Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) + | sort order:+++++++ + | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col7 (type: decimal(28,2)), _col8 (type: decimal(28,2)), _col9 (type: decimal(28,2)), _col10 (type: decimal(28,2)), _col11 (type: decimal(28,2)), _col12 (type: decimal(28,2)), _col13 (type: decimal(28,2)), _col14 (type: decimal(28,2)), _col15 (type: decimal(28,2)), _col16 (type: decimal(28,2)), _col17 (type: decimal(28,2)), _col18 (type: decimal(28,2)), _col19 (type: decimal(28,2)), _col20 (type: decimal(28,2)), _col21 (type: decimal(28,2)), _col22 (type: decimal(28,2)), _col23 (type: decimal(28,2)), _col24 (type: decimal(28,2)), _col25 (type: decimal(28,2)), _col26 (type: decimal(28,2)), _col27 (type: decimal(28,2)), _col28 (type: decimal(28,2)), _col29 (type: decimal(28,2)), _col30 (type: decimal(28,2)) + | Group By Operator [GBY_62] + | aggregations:["sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)"] + | keys:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), 2002 (type: int) + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] + | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_60] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] + | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + | Merge Join Operator [MERGEJOIN_122] + | | condition map:[{"":"Inner Join 0 to 1"}] + | | keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"} + | | outputColumnNames:["_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] + | | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + | |<-Map 23 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_58] + | | key expressions:_col0 (type: int) + | | Map-reduce partition columns:_col0 (type: int) + | | sort order:+ + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | Select Operator [SEL_47] + | | outputColumnNames:["_col0"] + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | Filter Operator [FIL_114] + | | predicate:((sm_carrier) IN ('DIAMOND', 'AIRBORNE') and sm_ship_mode_sk is not null) (type: boolean) + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | TableScan [TS_45] + | | alias:ship_mode + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | |<-Reducer 17 [SIMPLE_EDGE] + | Reduce Output Operator [RS_57] + | key expressions:_col2 (type: int) + | Map-reduce partition columns:_col2 (type: int) + | sort order:+ + | Statistics:Num rows: 47520 Data size: 22381920 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string), _col16 (type: int) + | Merge Join Operator [MERGEJOIN_121] + | | condition map:[{"":"Inner Join 0 to 1"}] + | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} + | | outputColumnNames:["_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] + | | Statistics:Num rows: 47520 Data size: 22381920 Basic stats: COMPLETE Column stats: NONE + | |<-Map 22 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_55] + | | key expressions:_col0 (type: int) + | | Map-reduce partition columns:_col0 (type: int) + | | sort order:+ + | | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE + | | Select Operator [SEL_44] + | | outputColumnNames:["_col0"] + | | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE + | | Filter Operator [FIL_113] + | | predicate:(t_time BETWEEN 49530 AND 78330 and t_time_sk is not null) (type: boolean) + | | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE + | | TableScan [TS_42] + | | alias:time_dim + | | Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE + | |<-Reducer 16 [SIMPLE_EDGE] + | Reduce Output Operator [RS_54] + | key expressions:_col1 (type: int) + | Map-reduce partition columns:_col1 (type: int) + | sort order:+ + | Statistics:Num rows: 40176 Data size: 44957392 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string), _col16 (type: int) + | Merge Join Operator [MERGEJOIN_120] + | | condition map:[{"":"Inner Join 0 to 1"}] + | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} + | | outputColumnNames:["_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] + | | Statistics:Num rows: 40176 Data size: 44957392 Basic stats: COMPLETE Column stats: NONE + | |<-Map 21 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_52] + | | key expressions:_col0 (type: int) + | | Map-reduce partition columns:_col0 (type: int) + | | sort order:+ + | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | | value expressions:_col2 (type: int) + | | Select Operator [SEL_41] + | | outputColumnNames:["_col0","_col2"] + | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | | Filter Operator [FIL_112] + | | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) + | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | | TableScan [TS_39] + | | alias:date_dim + | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE + | |<-Reducer 15 [SIMPLE_EDGE] + | Reduce Output Operator [RS_51] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 29 Data size: 30582 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col1 (type: int), _col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string) + | Merge Join Operator [MERGEJOIN_119] + | | condition map:[{"":"Inner Join 0 to 1"}] + | | keys:{"0":"_col3 (type: int)","1":"_col0 (type: int)"} + | | outputColumnNames:["_col0","_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13"] + | | Statistics:Num rows: 29 Data size: 30582 Basic stats: COMPLETE Column stats: NONE + | |<-Map 14 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_48] + | | key expressions:_col3 (type: int) + | | Map-reduce partition columns:_col3 (type: int) + | | sort order:+ + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | value expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)) + | | Select Operator [SEL_35] + | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | Filter Operator [FIL_110] + | | predicate:(((cs_warehouse_sk is not null and cs_sold_date_sk is not null) and cs_sold_time_sk is not null) and cs_ship_mode_sk is not null) (type: boolean) + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | TableScan [TS_33] + | | alias:catalog_sales + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | |<-Map 20 [SIMPLE_EDGE] + | Reduce Output Operator [RS_49] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col1 (type: string), _col2 (type: int), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string) + | Select Operator [SEL_38] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + | Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_111] + | predicate:w_warehouse_sk is not null (type: boolean) + | Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_36] + | alias:warehouse + | Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 6 [CONTAINS] + Reduce Output Operator [RS_70] + key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) + Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: int) + sort order:++++++++ Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - Select Operator [SEL_67] + value expressions:_col8 (type: decimal(38,2)), _col9 (type: decimal(38,2)), _col10 (type: decimal(38,2)), _col11 (type: decimal(38,2)), _col12 (type: decimal(38,2)), _col13 (type: decimal(38,2)), _col14 (type: decimal(38,2)), _col15 (type: decimal(38,2)), _col16 (type: decimal(38,2)), _col17 (type: decimal(38,2)), _col18 (type: decimal(38,2)), _col19 (type: decimal(38,2)), _col20 (type: decimal(38,12)), _col21 (type: decimal(38,12)), _col22 (type: decimal(38,12)), _col23 (type: decimal(38,12)), _col24 (type: decimal(38,12)), _col25 (type: decimal(38,12)), _col26 (type: decimal(38,12)), _col27 (type: decimal(38,12)), _col28 (type: decimal(38,12)), _col29 (type: decimal(38,12)), _col30 (type: decimal(38,12)), _col31 (type: decimal(38,12)), _col32 (type: decimal(38,2)), _col33 (type: decimal(38,2)), _col34 (type: decimal(38,2)), _col35 (type: decimal(38,2)), _col36 (type: decimal(38,2)), _col37 (type: decimal(38,2)), _col38 (type: decimal(38,2)), _col39 (type: decimal(38,2)), _col40 (type: decimal(38,2)), _col41 (type: decimal(38,2)), _col42 (type: decimal(38,2)), _col43 (type: decimal(38,2)) + Group By Operator [GBY_69] + aggregations:["sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)","sum(_col31)","sum(_col32)","sum(_col33)","sum(_col34)","sum(_col35)","sum(_col36)","sum(_col37)","sum(_col38)","sum(_col39)","sum(_col40)","sum(_col41)","sum(_col42)","sum(_col43)"] + keys:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), 2002 (type: int) outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - Select Operator [SEL_32] - outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31"] - Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE - Group By Operator [GBY_31] - | aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)"] - | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: string), KEY._col4 (type: string), KEY._col5 (type: string), KEY._col6 (type: int) - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] - | Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 5 [SIMPLE_EDGE] - Reduce Output Operator [RS_30] - key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) - Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) - sort order:+++++++ - Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - value expressions:_col7 (type: decimal(28,2)), _col8 (type: decimal(28,2)), _col9 (type: decimal(28,2)), _col10 (type: decimal(28,2)), _col11 (type: decimal(28,2)), _col12 (type: decimal(28,2)), _col13 (type: decimal(28,2)), _col14 (type: decimal(28,2)), _col15 (type: decimal(28,2)), _col16 (type: decimal(28,2)), _col17 (type: decimal(28,2)), _col18 (type: decimal(28,2)), _col19 (type: decimal(28,2)), _col20 (type: decimal(28,2)), _col21 (type: decimal(28,2)), _col22 (type: decimal(28,2)), _col23 (type: decimal(28,2)), _col24 (type: decimal(28,2)), _col25 (type: decimal(28,2)), _col26 (type: decimal(28,2)), _col27 (type: decimal(28,2)), _col28 (type: decimal(28,2)), _col29 (type: decimal(28,2)), _col30 (type: decimal(28,2)) - Group By Operator [GBY_29] - aggregations:["sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)"] - keys:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) - outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] + Select Operator [SEL_67] + outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] + Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + Select Operator [SEL_32] + outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] + Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE + Group By Operator [GBY_31] + | aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)"] + | keys:KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: string), KEY._col4 (type: string), KEY._col5 (type: string), KEY._col6 (type: int) + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] + | Statistics:Num rows: 26136 Data size: 12310056 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 5 [SIMPLE_EDGE] + Reduce Output Operator [RS_30] + key expressions:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) + Map-reduce partition columns:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: int) + sort order:+++++++ Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - Select Operator [SEL_27] + value expressions:_col7 (type: decimal(28,2)), _col8 (type: decimal(28,2)), _col9 (type: decimal(28,2)), _col10 (type: decimal(28,2)), _col11 (type: decimal(28,2)), _col12 (type: decimal(28,2)), _col13 (type: decimal(28,2)), _col14 (type: decimal(28,2)), _col15 (type: decimal(28,2)), _col16 (type: decimal(28,2)), _col17 (type: decimal(28,2)), _col18 (type: decimal(28,2)), _col19 (type: decimal(28,2)), _col20 (type: decimal(28,2)), _col21 (type: decimal(28,2)), _col22 (type: decimal(28,2)), _col23 (type: decimal(28,2)), _col24 (type: decimal(28,2)), _col25 (type: decimal(28,2)), _col26 (type: decimal(28,2)), _col27 (type: decimal(28,2)), _col28 (type: decimal(28,2)), _col29 (type: decimal(28,2)), _col30 (type: decimal(28,2)) + Group By Operator [GBY_29] + aggregations:["sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)"] + keys:_col0 (type: string), _col1 (type: int), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), 2002 (type: int) outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_118] - | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] - | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE - |<-Map 13 [SIMPLE_EDGE] - | Reduce Output Operator [RS_25] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Select Operator [SEL_14] - | outputColumnNames:["_col0"] - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Filter Operator [FIL_109] - | predicate:((sm_carrier) IN ('DIAMOND', 'AIRBORNE') and sm_ship_mode_sk is not null) (type: boolean) - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | TableScan [TS_12] - | alias:ship_mode - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - |<-Reducer 4 [SIMPLE_EDGE] - Reduce Output Operator [RS_24] - key expressions:_col2 (type: int) - Map-reduce partition columns:_col2 (type: int) - sort order:+ - Statistics:Num rows: 47520 Data size: 22381920 Basic stats: COMPLETE Column stats: NONE - value expressions:_col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string), _col16 (type: int) - Merge Join Operator [MERGEJOIN_117] - | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] - | Statistics:Num rows: 47520 Data size: 22381920 Basic stats: COMPLETE Column stats: NONE - |<-Map 12 [SIMPLE_EDGE] - | Reduce Output Operator [RS_22] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_11] - | outputColumnNames:["_col0"] - | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_108] - | predicate:(t_time BETWEEN 49530 AND 78330 and t_time_sk is not null) (type: boolean) - | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_9] - | alias:time_dim - | Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 3 [SIMPLE_EDGE] - Reduce Output Operator [RS_21] - key expressions:_col1 (type: int) - Map-reduce partition columns:_col1 (type: int) - sort order:+ - Statistics:Num rows: 40176 Data size: 44957392 Basic stats: COMPLETE Column stats: NONE - value expressions:_col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string), _col16 (type: int) - Merge Join Operator [MERGEJOIN_116] - | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] - | Statistics:Num rows: 40176 Data size: 44957392 Basic stats: COMPLETE Column stats: NONE - |<-Map 11 [SIMPLE_EDGE] - | Reduce Output Operator [RS_19] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col2 (type: int) - | Select Operator [SEL_8] - | outputColumnNames:["_col0","_col2"] - | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_107] - | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) - | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_6] - | alias:date_dim - | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 2 [SIMPLE_EDGE] - Reduce Output Operator [RS_18] - key expressions:_col0 (type: int) - Map-reduce partition columns:_col0 (type: int) - sort order:+ - Statistics:Num rows: 29 Data size: 30582 Basic stats: COMPLETE Column stats: NONE - value expressions:_col1 (type: int), _col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string) - Merge Join Operator [MERGEJOIN_115] - | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col3 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col0","_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13"] - | Statistics:Num rows: 29 Data size: 30582 Basic stats: COMPLETE Column stats: NONE - |<-Map 1 [SIMPLE_EDGE] - | Reduce Output Operator [RS_15] - | key expressions:_col3 (type: int) - | Map-reduce partition columns:_col3 (type: int) - | sort order:+ - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | value expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)) - | Select Operator [SEL_2] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Filter Operator [FIL_105] - | predicate:(((ws_warehouse_sk is not null and ws_sold_date_sk is not null) and ws_sold_time_sk is not null) and ws_ship_mode_sk is not null) (type: boolean) - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | TableScan [TS_0] - | alias:web_sales - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - |<-Map 10 [SIMPLE_EDGE] - Reduce Output Operator [RS_16] - key expressions:_col0 (type: int) - Map-reduce partition columns:_col0 (type: int) - sort order:+ - Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE - value expressions:_col1 (type: string), _col2 (type: int), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string) - Select Operator [SEL_5] - outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + Select Operator [SEL_27] + outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30"] + Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + Merge Join Operator [MERGEJOIN_118] + | condition map:[{"":"Inner Join 0 to 1"}] + | keys:{"0":"_col2 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] + | Statistics:Num rows: 52272 Data size: 24620112 Basic stats: COMPLETE Column stats: NONE + |<-Map 13 [SIMPLE_EDGE] + | Reduce Output Operator [RS_25] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | Select Operator [SEL_14] + | outputColumnNames:["_col0"] + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | Filter Operator [FIL_109] + | predicate:((sm_carrier) IN ('DIAMOND', 'AIRBORNE') and sm_ship_mode_sk is not null) (type: boolean) + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | TableScan [TS_12] + | alias:ship_mode + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + |<-Reducer 4 [SIMPLE_EDGE] + Reduce Output Operator [RS_24] + key expressions:_col2 (type: int) + Map-reduce partition columns:_col2 (type: int) + sort order:+ + Statistics:Num rows: 47520 Data size: 22381920 Basic stats: COMPLETE Column stats: NONE + value expressions:_col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string), _col16 (type: int) + Merge Join Operator [MERGEJOIN_117] + | condition map:[{"":"Inner Join 0 to 1"}] + | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] + | Statistics:Num rows: 47520 Data size: 22381920 Basic stats: COMPLETE Column stats: NONE + |<-Map 12 [SIMPLE_EDGE] + | Reduce Output Operator [RS_22] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_11] + | outputColumnNames:["_col0"] + | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_108] + | predicate:(t_time BETWEEN 49530 AND 78330 and t_time_sk is not null) (type: boolean) + | Statistics:Num rows: 43200 Data size: 20347200 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_9] + | alias:time_dim + | Statistics:Num rows: 86400 Data size: 40694400 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 3 [SIMPLE_EDGE] + Reduce Output Operator [RS_21] + key expressions:_col1 (type: int) + Map-reduce partition columns:_col1 (type: int) + sort order:+ + Statistics:Num rows: 40176 Data size: 44957392 Basic stats: COMPLETE Column stats: NONE + value expressions:_col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string), _col16 (type: int) + Merge Join Operator [MERGEJOIN_116] + | condition map:[{"":"Inner Join 0 to 1"}] + | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13","_col16"] + | Statistics:Num rows: 40176 Data size: 44957392 Basic stats: COMPLETE Column stats: NONE + |<-Map 11 [SIMPLE_EDGE] + | Reduce Output Operator [RS_19] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col2 (type: int) + | Select Operator [SEL_8] + | outputColumnNames:["_col0","_col2"] + | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_107] + | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) + | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_6] + | alias:date_dim + | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 2 [SIMPLE_EDGE] + Reduce Output Operator [RS_18] + key expressions:_col0 (type: int) + Map-reduce partition columns:_col0 (type: int) + sort order:+ + Statistics:Num rows: 29 Data size: 30582 Basic stats: COMPLETE Column stats: NONE + value expressions:_col1 (type: int), _col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)), _col8 (type: string), _col9 (type: int), _col10 (type: string), _col11 (type: string), _col12 (type: string), _col13 (type: string) + Merge Join Operator [MERGEJOIN_115] + | condition map:[{"":"Inner Join 0 to 1"}] + | keys:{"0":"_col3 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col0","_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11","_col12","_col13"] + | Statistics:Num rows: 29 Data size: 30582 Basic stats: COMPLETE Column stats: NONE + |<-Map 1 [SIMPLE_EDGE] + | Reduce Output Operator [RS_15] + | key expressions:_col3 (type: int) + | Map-reduce partition columns:_col3 (type: int) + | sort order:+ + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | value expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col4 (type: int), _col5 (type: decimal(7,2)), _col6 (type: decimal(7,2)) + | Select Operator [SEL_2] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | Filter Operator [FIL_105] + | predicate:(((ws_warehouse_sk is not null and ws_sold_date_sk is not null) and ws_sold_time_sk is not null) and ws_ship_mode_sk is not null) (type: boolean) + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | TableScan [TS_0] + | alias:web_sales + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + |<-Map 10 [SIMPLE_EDGE] + Reduce Output Operator [RS_16] + key expressions:_col0 (type: int) + Map-reduce partition columns:_col0 (type: int) + sort order:+ Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE - Filter Operator [FIL_106] - predicate:w_warehouse_sk is not null (type: boolean) + value expressions:_col1 (type: string), _col2 (type: int), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string) + Select Operator [SEL_5] + outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE - TableScan [TS_3] - alias:warehouse + Filter Operator [FIL_106] + predicate:w_warehouse_sk is not null (type: boolean) Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE + TableScan [TS_3] + alias:warehouse + Statistics:Num rows: 27 Data size: 27802 Basic stats: COMPLETE Column stats: NONE diff --git a/ql/src/test/results/clientpositive/perf/query75.q.out b/ql/src/test/results/clientpositive/perf/query75.q.out index d54000b..f3f9827 100644 --- a/ql/src/test/results/clientpositive/perf/query75.q.out +++ b/ql/src/test/results/clientpositive/perf/query75.q.out @@ -48,9 +48,9 @@ Stage-0 key expressions:_col8 (type: bigint) sort order:+ Statistics:Num rows: 169103 Data size: 242878993 Basic stats: COMPLETE Column stats: NONE - value expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: bigint), _col7 (type: bigint), _col9 (type: double) + value expressions:_col0 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int), _col5 (type: int), _col6 (type: bigint), _col7 (type: bigint), _col9 (type: double) Select Operator [SEL_146] - outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] + outputColumnNames:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] Statistics:Num rows: 169103 Data size: 242878993 Basic stats: COMPLETE Column stats: NONE Filter Operator [FIL_145] predicate:((CAST( _col5 AS decimal(17,2)) / CAST( _col12 AS decimal(17,2))) < 0.9) (type: boolean) @@ -58,7 +58,7 @@ Stage-0 Merge Join Operator [MERGEJOIN_253] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{"0":"_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int)","1":"_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int)"} - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col12","_col13"] + | outputColumnNames:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col12","_col13"] | Statistics:Num rows: 507310 Data size: 728638416 Basic stats: COMPLETE Column stats: NONE |<-Reducer 31 [SIMPLE_EDGE] | Reduce Output Operator [RS_143] @@ -394,326 +394,335 @@ Stage-0 Map-reduce partition columns:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) sort order:++++ Statistics:Num rows: 461191 Data size: 662398546 Basic stats: COMPLETE Column stats: NONE - value expressions:_col0 (type: int), _col5 (type: bigint), _col6 (type: double) - Group By Operator [GBY_69] - | aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"] - | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: int), KEY._col3 (type: int), KEY._col4 (type: int) - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - | Statistics:Num rows: 461191 Data size: 662398546 Basic stats: COMPLETE Column stats: NONE - |<-Union 5 [SIMPLE_EDGE] - |<-Reducer 15 [CONTAINS] - | Reduce Output Operator [RS_68] - | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) - | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) - | sort order:+++++ - | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col5 (type: bigint), _col6 (type: double) - | Group By Operator [GBY_67] - | aggregations:["sum(_col5)","sum(_col6)"] - | keys:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_41] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_240] - | | condition map:[{"":"Left Outer Join0 to 1"}] - | | keys:{"0":"_col2 (type: int), _col1 (type: int)","1":"_col1 (type: int), _col0 (type: int)"} - | | outputColumnNames:["_col3","_col4","_col6","_col7","_col8","_col10","_col12","_col15","_col16"] - | | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE - | |<-Map 18 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_39] - | | key expressions:_col1 (type: int), _col0 (type: int) - | | Map-reduce partition columns:_col1 (type: int), _col0 (type: int) - | | sort order:++ - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | value expressions:_col2 (type: int), _col3 (type: decimal(7,2)) - | | Select Operator [SEL_31] - | | outputColumnNames:["_col0","_col1","_col2","_col3"] - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_30] - | | alias:store_returns - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | |<-Reducer 14 [SIMPLE_EDGE] - | Reduce Output Operator [RS_38] - | key expressions:_col2 (type: int), _col1 (type: int) - | Map-reduce partition columns:_col2 (type: int), _col1 (type: int) - | sort order:++ - | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int), _col12 (type: int) - | Merge Join Operator [MERGEJOIN_239] - | | condition map:[{"":"Inner Join 0 to 1"}] - | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} - | | outputColumnNames:["_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10","_col12"] - | | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE - | |<-Map 17 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_36] - | | key expressions:_col0 (type: int) - | | Map-reduce partition columns:_col0 (type: int) - | | sort order:+ - | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | value expressions:2002 (type: int) - | | Select Operator [SEL_29] - | | outputColumnNames:["_col0"] - | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_217] - | | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) - | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_27] - | | alias:date_dim - | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - | |<-Reducer 13 [SIMPLE_EDGE] - | Reduce Output Operator [RS_35] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int) - | Merge Join Operator [MERGEJOIN_238] - | | condition map:[{"":"Inner Join 0 to 1"}] - | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} - | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10"] - | | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - | |<-Map 12 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_32] - | | key expressions:_col1 (type: int) - | | Map-reduce partition columns:_col1 (type: int) - | | sort order:+ - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | value expressions:_col0 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)) - | | Select Operator [SEL_23] - | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_215] - | | predicate:(ss_item_sk is not null and ss_sold_date_sk is not null) (type: boolean) - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_21] - | | alias:store_sales - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | |<-Map 16 [SIMPLE_EDGE] - | Reduce Output Operator [RS_33] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col5 (type: int) - | Select Operator [SEL_26] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col5"] - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_216] - | predicate:((((((i_category = 'Sports') and i_item_sk is not null) and i_category_id is not null) and i_manufact_id is not null) and i_class_id is not null) and i_brand_id is not null) (type: boolean) - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_24] - | alias:item - | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 22 [CONTAINS] - | Reduce Output Operator [RS_68] - | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) - | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) - | sort order:+++++ - | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col5 (type: bigint), _col6 (type: double) - | Group By Operator [GBY_67] - | aggregations:["sum(_col5)","sum(_col6)"] - | keys:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE - | Select Operator [SEL_64] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE - | Merge Join Operator [MERGEJOIN_243] - | | condition map:[{"":"Left Outer Join0 to 1"}] - | | keys:{"0":"_col2 (type: int), _col1 (type: int)","1":"_col1 (type: int), _col0 (type: int)"} - | | outputColumnNames:["_col3","_col4","_col6","_col7","_col8","_col10","_col12","_col15","_col16"] - | | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE - | |<-Map 25 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_62] - | | key expressions:_col1 (type: int), _col0 (type: int) - | | Map-reduce partition columns:_col1 (type: int), _col0 (type: int) - | | sort order:++ - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | value expressions:_col2 (type: int), _col3 (type: decimal(7,2)) - | | Select Operator [SEL_54] - | | outputColumnNames:["_col0","_col1","_col2","_col3"] - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_53] - | | alias:web_returns - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | |<-Reducer 21 [SIMPLE_EDGE] - | Reduce Output Operator [RS_61] - | key expressions:_col2 (type: int), _col1 (type: int) - | Map-reduce partition columns:_col2 (type: int), _col1 (type: int) - | sort order:++ - | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int), _col12 (type: int) - | Merge Join Operator [MERGEJOIN_242] - | | condition map:[{"":"Inner Join 0 to 1"}] - | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} - | | outputColumnNames:["_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10","_col12"] - | | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE - | |<-Map 24 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_59] - | | key expressions:_col0 (type: int) - | | Map-reduce partition columns:_col0 (type: int) - | | sort order:+ - | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | value expressions:2002 (type: int) - | | Select Operator [SEL_52] - | | outputColumnNames:["_col0"] - | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | Filter Operator [FIL_221] - | | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) - | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | | TableScan [TS_50] - | | alias:date_dim - | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - | |<-Reducer 20 [SIMPLE_EDGE] - | Reduce Output Operator [RS_58] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int) - | Merge Join Operator [MERGEJOIN_241] - | | condition map:[{"":"Inner Join 0 to 1"}] - | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} - | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10"] - | | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - | |<-Map 19 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_55] - | | key expressions:_col1 (type: int) - | | Map-reduce partition columns:_col1 (type: int) - | | sort order:+ - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | value expressions:_col0 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)) - | | Select Operator [SEL_46] - | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | Filter Operator [FIL_219] - | | predicate:(ws_item_sk is not null and ws_sold_date_sk is not null) (type: boolean) - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | | TableScan [TS_44] - | | alias:web_sales - | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | |<-Map 23 [SIMPLE_EDGE] - | Reduce Output Operator [RS_56] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col5 (type: int) - | Select Operator [SEL_49] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col5"] - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_220] - | predicate:((((((i_category = 'Sports') and i_item_sk is not null) and i_category_id is not null) and i_manufact_id is not null) and i_class_id is not null) and i_brand_id is not null) (type: boolean) - | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_47] - | alias:item - | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 4 [CONTAINS] - Reduce Output Operator [RS_68] - key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) - Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) - sort order:+++++ - Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE - value expressions:_col5 (type: bigint), _col6 (type: double) - Group By Operator [GBY_67] - aggregations:["sum(_col5)","sum(_col6)"] - keys:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) - outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + value expressions:_col5 (type: bigint), _col6 (type: double) + Select Operator [SEL_70] + outputColumnNames:["_col1","_col2","_col3","_col4","_col5","_col6"] + Statistics:Num rows: 461191 Data size: 662398546 Basic stats: COMPLETE Column stats: NONE + Group By Operator [GBY_69] + | aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"] + | keys:KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: int), KEY._col3 (type: int), KEY._col4 (type: int) + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + | Statistics:Num rows: 461191 Data size: 662398546 Basic stats: COMPLETE Column stats: NONE + |<-Union 5 [SIMPLE_EDGE] + |<-Reducer 15 [CONTAINS] + | Reduce Output Operator [RS_68] + | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) + | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) + | sort order:+++++ + | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col5 (type: bigint), _col6 (type: double) + | Group By Operator [GBY_67] + | aggregations:["sum(_col5)","sum(_col6)"] + | keys:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_65] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_41] + | outputColumnNames:["_col1","_col2","_col3","_col4","_col5","_col6"] + | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE + | Merge Join Operator [MERGEJOIN_240] + | | condition map:[{"":"Left Outer Join0 to 1"}] + | | keys:{"0":"_col2 (type: int), _col1 (type: int)","1":"_col1 (type: int), _col0 (type: int)"} + | | outputColumnNames:["_col3","_col4","_col6","_col7","_col8","_col10","_col15","_col16"] + | | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE + | |<-Map 18 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_39] + | | key expressions:_col1 (type: int), _col0 (type: int) + | | Map-reduce partition columns:_col1 (type: int), _col0 (type: int) + | | sort order:++ + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | value expressions:_col2 (type: int), _col3 (type: decimal(7,2)) + | | Select Operator [SEL_31] + | | outputColumnNames:["_col0","_col1","_col2","_col3"] + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | TableScan [TS_30] + | | alias:store_returns + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | |<-Reducer 14 [SIMPLE_EDGE] + | Reduce Output Operator [RS_38] + | key expressions:_col2 (type: int), _col1 (type: int) + | Map-reduce partition columns:_col2 (type: int), _col1 (type: int) + | sort order:++ + | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int) + | Merge Join Operator [MERGEJOIN_239] + | | condition map:[{"":"Inner Join 0 to 1"}] + | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} + | | outputColumnNames:["_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10"] + | | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE + | |<-Map 17 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_36] + | | key expressions:_col0 (type: int) + | | Map-reduce partition columns:_col0 (type: int) + | | sort order:+ + | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | | Select Operator [SEL_29] + | | outputColumnNames:["_col0"] + | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | | Filter Operator [FIL_217] + | | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) + | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | | TableScan [TS_27] + | | alias:date_dim + | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE + | |<-Reducer 13 [SIMPLE_EDGE] + | Reduce Output Operator [RS_35] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int) + | Merge Join Operator [MERGEJOIN_238] + | | condition map:[{"":"Inner Join 0 to 1"}] + | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} + | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10"] + | | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + | |<-Map 12 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_32] + | | key expressions:_col1 (type: int) + | | Map-reduce partition columns:_col1 (type: int) + | | sort order:+ + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | value expressions:_col0 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)) + | | Select Operator [SEL_23] + | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | Filter Operator [FIL_215] + | | predicate:(ss_item_sk is not null and ss_sold_date_sk is not null) (type: boolean) + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | TableScan [TS_21] + | | alias:store_sales + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | |<-Map 16 [SIMPLE_EDGE] + | Reduce Output Operator [RS_33] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col5 (type: int) + | Select Operator [SEL_26] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col5"] + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_216] + | predicate:((((((i_category = 'Sports') and i_item_sk is not null) and i_category_id is not null) and i_manufact_id is not null) and i_class_id is not null) and i_brand_id is not null) (type: boolean) + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_24] + | alias:item + | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 22 [CONTAINS] + | Reduce Output Operator [RS_68] + | key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) + | Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) + | sort order:+++++ + | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col5 (type: bigint), _col6 (type: double) + | Group By Operator [GBY_67] + | aggregations:["sum(_col5)","sum(_col6)"] + | keys:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_65] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + | Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_64] + | outputColumnNames:["_col1","_col2","_col3","_col4","_col5","_col6"] + | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE + | Merge Join Operator [MERGEJOIN_243] + | | condition map:[{"":"Left Outer Join0 to 1"}] + | | keys:{"0":"_col2 (type: int), _col1 (type: int)","1":"_col1 (type: int), _col0 (type: int)"} + | | outputColumnNames:["_col3","_col4","_col6","_col7","_col8","_col10","_col15","_col16"] + | | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE + | |<-Map 25 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_62] + | | key expressions:_col1 (type: int), _col0 (type: int) + | | Map-reduce partition columns:_col1 (type: int), _col0 (type: int) + | | sort order:++ + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | value expressions:_col2 (type: int), _col3 (type: decimal(7,2)) + | | Select Operator [SEL_54] + | | outputColumnNames:["_col0","_col1","_col2","_col3"] + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | TableScan [TS_53] + | | alias:web_returns + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | |<-Reducer 21 [SIMPLE_EDGE] + | Reduce Output Operator [RS_61] + | key expressions:_col2 (type: int), _col1 (type: int) + | Map-reduce partition columns:_col2 (type: int), _col1 (type: int) + | sort order:++ + | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int) + | Merge Join Operator [MERGEJOIN_242] + | | condition map:[{"":"Inner Join 0 to 1"}] + | | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} + | | outputColumnNames:["_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10"] + | | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE + | |<-Map 24 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_59] + | | key expressions:_col0 (type: int) + | | Map-reduce partition columns:_col0 (type: int) + | | sort order:+ + | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | | Select Operator [SEL_52] + | | outputColumnNames:["_col0"] + | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | | Filter Operator [FIL_221] + | | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) + | | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | | TableScan [TS_50] + | | alias:date_dim + | | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE + | |<-Reducer 20 [SIMPLE_EDGE] + | Reduce Output Operator [RS_58] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int) + | Merge Join Operator [MERGEJOIN_241] + | | condition map:[{"":"Inner Join 0 to 1"}] + | | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} + | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10"] + | | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + | |<-Map 19 [SIMPLE_EDGE] + | | Reduce Output Operator [RS_55] + | | key expressions:_col1 (type: int) + | | Map-reduce partition columns:_col1 (type: int) + | | sort order:+ + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | value expressions:_col0 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)) + | | Select Operator [SEL_46] + | | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | Filter Operator [FIL_219] + | | predicate:(ws_item_sk is not null and ws_sold_date_sk is not null) (type: boolean) + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | | TableScan [TS_44] + | | alias:web_sales + | | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | |<-Map 23 [SIMPLE_EDGE] + | Reduce Output Operator [RS_56] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) + | sort order:+ + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col5 (type: int) + | Select Operator [SEL_49] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col5"] + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_220] + | predicate:((((((i_category = 'Sports') and i_item_sk is not null) and i_category_id is not null) and i_manufact_id is not null) and i_class_id is not null) and i_brand_id is not null) (type: boolean) + | Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_47] + | alias:item + | Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 4 [CONTAINS] + Reduce Output Operator [RS_68] + key expressions:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) + Map-reduce partition columns:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) + sort order:+++++ Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE - Select Operator [SEL_20] + value expressions:_col5 (type: bigint), _col6 (type: double) + Group By Operator [GBY_67] + aggregations:["sum(_col5)","sum(_col6)"] + keys:_col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE - Merge Join Operator [MERGEJOIN_237] - | condition map:[{"":"Left Outer Join0 to 1"}] - | keys:{"0":"_col2 (type: int), _col1 (type: int)","1":"_col1 (type: int), _col0 (type: int)"} - | outputColumnNames:["_col3","_col4","_col6","_col7","_col8","_col10","_col12","_col15","_col16"] - | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE - |<-Map 11 [SIMPLE_EDGE] - | Reduce Output Operator [RS_18] - | key expressions:_col1 (type: int), _col0 (type: int) - | Map-reduce partition columns:_col1 (type: int), _col0 (type: int) - | sort order:++ - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | value expressions:_col2 (type: int), _col3 (type: decimal(7,2)) - | Select Operator [SEL_10] - | outputColumnNames:["_col0","_col1","_col2","_col3"] - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | TableScan [TS_9] - | alias:catalog_returns - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - |<-Reducer 3 [SIMPLE_EDGE] - Reduce Output Operator [RS_17] - key expressions:_col2 (type: int), _col1 (type: int) - Map-reduce partition columns:_col2 (type: int), _col1 (type: int) - sort order:++ - Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE - value expressions:_col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int), _col12 (type: int) - Merge Join Operator [MERGEJOIN_236] - | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10","_col12"] - | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE - |<-Map 10 [SIMPLE_EDGE] - | Reduce Output Operator [RS_15] - | key expressions:_col0 (type: int) - | Map-reduce partition columns:_col0 (type: int) - | sort order:+ - | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | value expressions:2002 (type: int) - | Select Operator [SEL_8] - | outputColumnNames:["_col0"] - | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | Filter Operator [FIL_213] - | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) - | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE - | TableScan [TS_6] - | alias:date_dim - | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE - |<-Reducer 2 [SIMPLE_EDGE] - Reduce Output Operator [RS_14] - key expressions:_col0 (type: int) - Map-reduce partition columns:_col0 (type: int) - sort order:+ - Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int) - Merge Join Operator [MERGEJOIN_235] + Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE + Select Operator [SEL_65] + outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + Statistics:Num rows: 922383 Data size: 1324798530 Basic stats: COMPLETE Column stats: NONE + Select Operator [SEL_20] + outputColumnNames:["_col1","_col2","_col3","_col4","_col5","_col6"] + Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE + Merge Join Operator [MERGEJOIN_237] + | condition map:[{"":"Left Outer Join0 to 1"}] + | keys:{"0":"_col2 (type: int), _col1 (type: int)","1":"_col1 (type: int), _col0 (type: int)"} + | outputColumnNames:["_col3","_col4","_col6","_col7","_col8","_col10","_col15","_col16"] + | Statistics:Num rows: 307461 Data size: 441599510 Basic stats: COMPLETE Column stats: NONE + |<-Map 11 [SIMPLE_EDGE] + | Reduce Output Operator [RS_18] + | key expressions:_col1 (type: int), _col0 (type: int) + | Map-reduce partition columns:_col1 (type: int), _col0 (type: int) + | sort order:++ + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | value expressions:_col2 (type: int), _col3 (type: decimal(7,2)) + | Select Operator [SEL_10] + | outputColumnNames:["_col0","_col1","_col2","_col3"] + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | TableScan [TS_9] + | alias:catalog_returns + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + |<-Reducer 3 [SIMPLE_EDGE] + Reduce Output Operator [RS_17] + key expressions:_col2 (type: int), _col1 (type: int) + Map-reduce partition columns:_col2 (type: int), _col1 (type: int) + sort order:++ + Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE + value expressions:_col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int) + Merge Join Operator [MERGEJOIN_236] | condition map:[{"":"Inner Join 0 to 1"}] - | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10"] - | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE - |<-Map 1 [SIMPLE_EDGE] - | Reduce Output Operator [RS_11] - | key expressions:_col1 (type: int) - | Map-reduce partition columns:_col1 (type: int) + | keys:{"0":"_col0 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10"] + | Statistics:Num rows: 279510 Data size: 401454092 Basic stats: COMPLETE Column stats: NONE + |<-Map 10 [SIMPLE_EDGE] + | Reduce Output Operator [RS_15] + | key expressions:_col0 (type: int) + | Map-reduce partition columns:_col0 (type: int) | sort order:+ - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | value expressions:_col0 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)) - | Select Operator [SEL_2] - | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | Filter Operator [FIL_211] - | predicate:(cs_item_sk is not null and cs_sold_date_sk is not null) (type: boolean) - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - | TableScan [TS_0] - | alias:catalog_sales - | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - |<-Map 9 [SIMPLE_EDGE] - Reduce Output Operator [RS_12] + | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | Select Operator [SEL_8] + | outputColumnNames:["_col0"] + | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | Filter Operator [FIL_213] + | predicate:((d_year = 2002) and d_date_sk is not null) (type: boolean) + | Statistics:Num rows: 36524 Data size: 40870356 Basic stats: COMPLETE Column stats: NONE + | TableScan [TS_6] + | alias:date_dim + | Statistics:Num rows: 73049 Data size: 81741831 Basic stats: COMPLETE Column stats: NONE + |<-Reducer 2 [SIMPLE_EDGE] + Reduce Output Operator [RS_14] key expressions:_col0 (type: int) Map-reduce partition columns:_col0 (type: int) sort order:+ - Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col5 (type: int) - Select Operator [SEL_5] - outputColumnNames:["_col0","_col1","_col2","_col3","_col5"] - Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - Filter Operator [FIL_212] - predicate:((((((i_category = 'Sports') and i_item_sk is not null) and i_category_id is not null) and i_manufact_id is not null) and i_class_id is not null) and i_brand_id is not null) (type: boolean) + Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)), _col6 (type: int), _col7 (type: int), _col8 (type: int), _col10 (type: int) + Merge Join Operator [MERGEJOIN_235] + | condition map:[{"":"Inner Join 0 to 1"}] + | keys:{"0":"_col1 (type: int)","1":"_col0 (type: int)"} + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col10"] + | Statistics:Num rows: 254100 Data size: 364958258 Basic stats: COMPLETE Column stats: NONE + |<-Map 1 [SIMPLE_EDGE] + | Reduce Output Operator [RS_11] + | key expressions:_col1 (type: int) + | Map-reduce partition columns:_col1 (type: int) + | sort order:+ + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | value expressions:_col0 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: decimal(7,2)) + | Select Operator [SEL_2] + | outputColumnNames:["_col0","_col1","_col2","_col3","_col4"] + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | Filter Operator [FIL_211] + | predicate:(cs_item_sk is not null and cs_sold_date_sk is not null) (type: boolean) + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + | TableScan [TS_0] + | alias:catalog_sales + | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE + |<-Map 9 [SIMPLE_EDGE] + Reduce Output Operator [RS_12] + key expressions:_col0 (type: int) + Map-reduce partition columns:_col0 (type: int) + sort order:+ Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE - TableScan [TS_3] - alias:item - Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE + value expressions:_col1 (type: int), _col2 (type: int), _col3 (type: int), _col5 (type: int) + Select Operator [SEL_5] + outputColumnNames:["_col0","_col1","_col2","_col3","_col5"] + Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + Filter Operator [FIL_212] + predicate:((((((i_category = 'Sports') and i_item_sk is not null) and i_category_id is not null) and i_manufact_id is not null) and i_class_id is not null) and i_brand_id is not null) (type: boolean) + Statistics:Num rows: 231000 Data size: 331780228 Basic stats: COMPLETE Column stats: NONE + TableScan [TS_3] + alias:item + Statistics:Num rows: 462000 Data size: 663560457 Basic stats: COMPLETE Column stats: NONE diff --git a/ql/src/test/results/clientpositive/pointlookup2.q.out b/ql/src/test/results/clientpositive/pointlookup2.q.out index a442425..1d7efe8 100644 --- a/ql/src/test/results/clientpositive/pointlookup2.q.out +++ b/ql/src/test/results/clientpositive/pointlookup2.q.out @@ -68,7 +68,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@pcr_t1 POSTHOOK: Input: default@pcr_t1@ds=2000-04-08 POSTHOOK: Output: default@pcr_t2 -POSTHOOK: Lineage: pcr_t2.ds SIMPLE [(pcr_t1)pcr_t1.FieldSchema(name:ds, type:string, comment:null), ] +POSTHOOK: Lineage: pcr_t2.ds SIMPLE [] POSTHOOK: Lineage: pcr_t2.key SIMPLE [(pcr_t1)pcr_t1.FieldSchema(name:key, type:int, comment:null), ] POSTHOOK: Lineage: pcr_t2.value SIMPLE [(pcr_t1)pcr_t1.FieldSchema(name:value, type:string, comment:null), ] PREHOOK: query: from pcr_t1 @@ -83,8 +83,8 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@pcr_t1 POSTHOOK: Input: default@pcr_t1@ds=2000-04-08 POSTHOOK: Output: default@pcr_t2 -POSTHOOK: Lineage: pcr_t2.ds SIMPLE [(pcr_t1)pcr_t1.FieldSchema(name:ds, type:string, comment:null), ] -POSTHOOK: Lineage: pcr_t2.key SIMPLE [(pcr_t1)pcr_t1.FieldSchema(name:key, type:int, comment:null), ] +POSTHOOK: Lineage: pcr_t2.ds SIMPLE [] +POSTHOOK: Lineage: pcr_t2.key SIMPLE [] POSTHOOK: Lineage: pcr_t2.value SIMPLE [(pcr_t1)pcr_t1.FieldSchema(name:value, type:string, comment:null), ] PREHOOK: query: explain extended select key, value, ds diff --git a/ql/src/test/results/clientpositive/quotedid_basic.q.out b/ql/src/test/results/clientpositive/quotedid_basic.q.out index 519f647..29736af 100644 --- a/ql/src/test/results/clientpositive/quotedid_basic.q.out +++ b/ql/src/test/results/clientpositive/quotedid_basic.q.out @@ -101,11 +101,11 @@ STAGE PLANS: predicate: (!@#$%^&*()_q = '1') (type: boolean) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: x+1 (type: string), y&y (type: string), '1' (type: string) - outputColumnNames: x+1, y&y, !@#$%^&*()_q + expressions: x+1 (type: string), y&y (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Group By Operator - keys: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + keys: _col0 (type: string), _col1 (type: string), '1' (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE @@ -120,13 +120,17 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - File Output Operator - compressed: false + Select Operator + expressions: _col0 (type: string), _col1 (type: string), '1' (type: string) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL 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 + 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.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe Stage: Stage-0 Fetch Operator @@ -156,11 +160,11 @@ STAGE PLANS: predicate: (!@#$%^&*()_q = '1') (type: boolean) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: x+1 (type: string), y&y (type: string), '1' (type: string) - outputColumnNames: x+1, y&y, !@#$%^&*()_q + expressions: x+1 (type: string), y&y (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Group By Operator - keys: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + keys: _col0 (type: string), _col1 (type: string), '1' (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE @@ -187,27 +191,27 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col2 (type: string), _col1 (type: string) + key expressions: '1' (type: string), _col1 (type: string) sort order: ++ - Map-reduce partition columns: _col2 (type: string) + Map-reduce partition columns: '1' (type: string) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE value expressions: _col0 (type: string) Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string), KEY.reducesinkkey0 (type: string) - outputColumnNames: _col0, _col1, _col2 + expressions: VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE PTF Operator Function definitions: Input definition input alias: ptf_0 - output shape: _col0: string, _col1: string, _col2: string + output shape: _col0: string, _col1: string type: WINDOWING Windowing table definition input alias: ptf_1 name: windowingtablefunction order by: _col1 - partition by: _col2 + partition by: '1' raw input shape: window functions: window function definition @@ -219,7 +223,7 @@ STAGE PLANS: isPivotResult: true Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string), rank_window_0 (type: int) + expressions: _col0 (type: string), _col1 (type: string), '1' (type: string), rank_window_0 (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE File Output Operator @@ -260,11 +264,11 @@ STAGE PLANS: predicate: (!@#$%^&*()_q = '1') (type: boolean) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: x+1 (type: string), y&y (type: string), '1' (type: string) - outputColumnNames: x+1, y&y, !@#$%^&*()_q + expressions: x+1 (type: string), y&y (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Group By Operator - keys: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + keys: _col0 (type: string), _col1 (type: string), '1' (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE @@ -291,27 +295,27 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col2 (type: string), _col1 (type: string) + key expressions: '1' (type: string), _col1 (type: string) sort order: ++ - Map-reduce partition columns: _col2 (type: string) + Map-reduce partition columns: '1' (type: string) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE value expressions: _col0 (type: string) Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string), KEY.reducesinkkey0 (type: string) - outputColumnNames: _col0, _col1, _col2 + expressions: VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE PTF Operator Function definitions: Input definition input alias: ptf_0 - output shape: _col0: string, _col1: string, _col2: string + output shape: _col0: string, _col1: string type: WINDOWING Windowing table definition input alias: ptf_1 name: windowingtablefunction order by: _col1 - partition by: _col2 + partition by: '1' raw input shape: window functions: window function definition @@ -323,7 +327,7 @@ STAGE PLANS: isPivotResult: true Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string), rank_window_0 (type: int) + expressions: _col0 (type: string), _col1 (type: string), '1' (type: string), rank_window_0 (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/quotedid_partition.q.out b/ql/src/test/results/clientpositive/quotedid_partition.q.out index d34a005..e40d0d0 100644 --- a/ql/src/test/results/clientpositive/quotedid_partition.q.out +++ b/ql/src/test/results/clientpositive/quotedid_partition.q.out @@ -46,11 +46,11 @@ STAGE PLANS: predicate: (x+1 = '10') (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: '10' (type: string), y&y (type: string), 'a' (type: string) - outputColumnNames: x+1, y&y, !@#$%^&*()_q + expressions: y&y (type: string) + outputColumnNames: _col1 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Group By Operator - keys: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + keys: '10' (type: string), _col1 (type: string), 'a' (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE @@ -65,13 +65,17 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 125 Data size: 1328 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false + Select Operator + expressions: '10' (type: string), _col1 (type: string), 'a' (type: string) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 125 Data size: 1328 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 + File Output Operator + compressed: false + Statistics: Num rows: 125 Data size: 1328 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 Stage: Stage-0 Fetch Operator diff --git a/ql/src/test/results/clientpositive/spark/bucket_map_join_tez1.q.out b/ql/src/test/results/clientpositive/spark/bucket_map_join_tez1.q.out index b5e7846..57a89d6 100644 --- a/ql/src/test/results/clientpositive/spark/bucket_map_join_tez1.q.out +++ b/ql/src/test/results/clientpositive/spark/bucket_map_join_tez1.q.out @@ -1567,7 +1567,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@srcbucket_mapjoin POSTHOOK: Input: default@srcbucket_mapjoin@ds=2008-04-08 POSTHOOK: Output: default@tab@ds=2008-04-08 -POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:key, type:int, comment:null), ] +POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [] POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).value SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:value, type:string, comment:null), ] PREHOOK: query: explain select count(*) @@ -1688,7 +1688,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@srcbucket_mapjoin POSTHOOK: Input: default@srcbucket_mapjoin@ds=2008-04-08 POSTHOOK: Output: default@tab@ds=2008-04-08 -POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:key, type:int, comment:null), ] +POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [] POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).value SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:value, type:string, comment:null), ] PREHOOK: query: explain select count(*) diff --git a/ql/src/test/results/clientpositive/spark/cross_product_check_1.q.out b/ql/src/test/results/clientpositive/spark/cross_product_check_1.q.out index 0656cd5..5e67607 100644 --- a/ql/src/test/results/clientpositive/spark/cross_product_check_1.q.out +++ b/ql/src/test/results/clientpositive/spark/cross_product_check_1.q.out @@ -324,8 +324,8 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[10][tables = [$hdt$_1, $hdt$_2]] in Work 'Reducer 4' is a cross product -Warning: Shuffle Join JOIN[19][tables = [$hdt$_0, $hdt$_1]] in Work 'Reducer 2' is a cross product +Warning: Shuffle Join JOIN[9][tables = [$hdt$_1, $hdt$_2]] in Work 'Reducer 4' is a cross product +Warning: Shuffle Join JOIN[18][tables = [$hdt$_0, $hdt$_1]] in Work 'Reducer 2' is a cross product PREHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 PREHOOK: type: QUERY POSTHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 diff --git a/ql/src/test/results/clientpositive/spark/cross_product_check_2.q.out b/ql/src/test/results/clientpositive/spark/cross_product_check_2.q.out index 2d6eb38..e8bcd7a 100644 --- a/ql/src/test/results/clientpositive/spark/cross_product_check_2.q.out +++ b/ql/src/test/results/clientpositive/spark/cross_product_check_2.q.out @@ -339,8 +339,8 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Map Join MAPJOIN[22][bigTable=?] in task 'Stage-1:MAPRED' is a cross product -Warning: Map Join MAPJOIN[23][bigTable=?] in task 'Stage-2:MAPRED' is a cross product +Warning: Map Join MAPJOIN[21][bigTable=?] in task 'Stage-1:MAPRED' is a cross product +Warning: Map Join MAPJOIN[22][bigTable=?] in task 'Stage-2:MAPRED' is a cross product PREHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 PREHOOK: type: QUERY POSTHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 diff --git a/ql/src/test/results/clientpositive/spark/dynamic_rdd_cache.q.out b/ql/src/test/results/clientpositive/spark/dynamic_rdd_cache.q.out index 9043fb1..1f26724 100644 --- a/ql/src/test/results/clientpositive/spark/dynamic_rdd_cache.q.out +++ b/ql/src/test/results/clientpositive/spark/dynamic_rdd_cache.q.out @@ -991,69 +991,69 @@ STAGE PLANS: outputColumnNames: _col2, _col4, _col5, _col6 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col4 (type: int), _col5 (type: int), _col6 (type: string), 3 (type: int), _col2 (type: int) - outputColumnNames: _col4, _col5, _col6, _col9, _col2 + expressions: _col6 (type: string), _col5 (type: int), _col4 (type: int), _col2 (type: int) + outputColumnNames: _col0, _col1, _col2, _col4 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Group By Operator - aggregations: stddev_samp(_col2), avg(_col2) - keys: _col4 (type: int), _col5 (type: int), _col6 (type: string), _col9 (type: int) + aggregations: avg(_col4), stddev_samp(_col4) + keys: _col0 (type: string), _col1 (type: int), _col2 (type: int), 3 (type: int) mode: hash outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int) + key expressions: _col0 (type: string), _col1 (type: int), _col2 (type: int), _col3 (type: int) sort order: ++++ - Map-reduce partition columns: _col0 (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int) + Map-reduce partition columns: _col0 (type: string), _col1 (type: int), _col2 (type: int), _col3 (type: int) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - value expressions: _col4 (type: struct), _col5 (type: struct) + value expressions: _col4 (type: struct), _col5 (type: struct) Reducer 5 Reduce Operator Tree: Group By Operator - aggregations: stddev_samp(VALUE._col0), avg(VALUE._col1) - keys: KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: string), KEY._col3 (type: int) + aggregations: avg(VALUE._col0), stddev_samp(VALUE._col1) + keys: KEY._col0 (type: string), KEY._col1 (type: int), KEY._col2 (type: int), KEY._col3 (type: int) mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col1 (type: int), _col0 (type: int), _col3 (type: int), _col4 (type: double), _col5 (type: double) - outputColumnNames: _col1, _col2, _col3, _col4, _col5 + expressions: _col1 (type: int), _col2 (type: int), _col4 (type: double), _col5 (type: double) + outputColumnNames: _col1, _col2, _col4, _col5 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Filter Operator - predicate: (CASE (_col5) WHEN (0) THEN (0) ELSE ((_col4 / _col5)) END > 1.0) (type: boolean) + predicate: (CASE (_col4) WHEN (0) THEN (0) ELSE ((_col5 / _col4)) END > 1.0) (type: boolean) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col1 (type: int), _col2 (type: int), _col3 (type: int), _col5 (type: double), CASE (_col5) WHEN (0) THEN (null) ELSE ((_col4 / _col5)) END (type: double) - outputColumnNames: _col1, _col2, _col3, _col4, _col5 + expressions: _col1 (type: int), _col2 (type: int), _col4 (type: double), CASE (_col4) WHEN (0) THEN (null) ELSE ((_col5 / _col4)) END (type: double) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Reduce Output Operator - key expressions: _col2 (type: int), _col1 (type: int) + key expressions: _col1 (type: int), _col0 (type: int) sort order: ++ - Map-reduce partition columns: _col2 (type: int), _col1 (type: int) + Map-reduce partition columns: _col1 (type: int), _col0 (type: int) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - value expressions: _col3 (type: int), _col4 (type: double), _col5 (type: double) + value expressions: _col2 (type: double), _col3 (type: double) Reducer 6 Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 keys: - 0 _col2 (type: int), _col1 (type: int) + 0 _col1 (type: int), _col0 (type: int) 1 _col2 (type: int), _col1 (type: int) - outputColumnNames: _col1, _col2, _col3, _col4, _col5, _col7, _col8, _col9, _col10, _col11 + outputColumnNames: _col0, _col1, _col2, _col3, _col5, _col6, _col7, _col8, _col9 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: double), _col5 (type: double), _col7 (type: int), _col8 (type: int), _col9 (type: int), _col10 (type: double), _col11 (type: double) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9 + expressions: _col0 (type: int), _col1 (type: int), _col2 (type: double), _col3 (type: double), _col5 (type: int), _col6 (type: int), _col7 (type: int), _col8 (type: double), _col9 (type: double) + outputColumnNames: _col0, _col1, _col3, _col4, _col5, _col6, _col7, _col8, _col9 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: int), _col2 (type: int), _col3 (type: double), _col4 (type: double), _col7 (type: int), _col8 (type: double), _col9 (type: double) + key expressions: _col0 (type: int), _col1 (type: int), 3 (type: int), _col3 (type: double), _col4 (type: double), _col7 (type: int), _col8 (type: double), _col9 (type: double) sort order: ++++++++ Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE value expressions: _col5 (type: int), _col6 (type: int) Reducer 7 Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int), KEY.reducesinkkey2 (type: int), KEY.reducesinkkey3 (type: double), KEY.reducesinkkey4 (type: double), VALUE._col0 (type: int), VALUE._col1 (type: int), KEY.reducesinkkey5 (type: int), KEY.reducesinkkey6 (type: double), KEY.reducesinkkey7 (type: double) + expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int), 3 (type: int), KEY.reducesinkkey3 (type: double), KEY.reducesinkkey4 (type: double), VALUE._col0 (type: int), VALUE._col1 (type: int), KEY.reducesinkkey5 (type: int), KEY.reducesinkkey6 (type: double), KEY.reducesinkkey7 (type: double) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/spark/groupby_sort_1_23.q.out b/ql/src/test/results/clientpositive/spark/groupby_sort_1_23.q.out index 239e803..fb75a98 100644 --- a/ql/src/test/results/clientpositive/spark/groupby_sort_1_23.q.out +++ b/ql/src/test/results/clientpositive/spark/groupby_sort_1_23.q.out @@ -989,7 +989,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int) + expressions: 1 (type: int), UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -1274,7 +1274,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -3650,7 +3650,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -3880,7 +3880,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int), UDFToInteger(_col4) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), 2 (type: int), UDFToInteger(_col4) (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -4114,7 +4114,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -4387,7 +4387,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 2 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/spark/groupby_sort_skew_1_23.q.out b/ql/src/test/results/clientpositive/spark/groupby_sort_skew_1_23.q.out index 8370bbe..b9fb6b1 100644 --- a/ql/src/test/results/clientpositive/spark/groupby_sort_skew_1_23.q.out +++ b/ql/src/test/results/clientpositive/spark/groupby_sort_skew_1_23.q.out @@ -1007,7 +1007,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int) + expressions: 1 (type: int), UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -1310,7 +1310,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -3776,7 +3776,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -4006,7 +4006,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), _col3 (type: int), UDFToInteger(_col4) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), 2 (type: int), UDFToInteger(_col4) (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -4240,7 +4240,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -4513,7 +4513,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) + expressions: UDFToInteger(_col0) (type: int), 2 (type: int), _col2 (type: string), UDFToInteger(_col3) (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/spark/union_remove_25.q.out b/ql/src/test/results/clientpositive/spark/union_remove_25.q.out index b771fe9..91aa1f2 100644 --- a/ql/src/test/results/clientpositive/spark/union_remove_25.q.out +++ b/ql/src/test/results/clientpositive/spark/union_remove_25.q.out @@ -444,7 +444,7 @@ STAGE PLANS: Statistics: Num rows: 1000 Data size: 10624 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: key (type: string), value (type: string), hr (type: string) - outputColumnNames: _col0, _col1, _col3 + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1000 Data size: 10624 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 1000 @@ -453,18 +453,18 @@ STAGE PLANS: sort order: Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string) + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string) Reducer 2 Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col3 (type: string) - outputColumnNames: _col0, _col1, _col3 + expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col2 (type: string) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 1000 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), UDFToLong(_col1) (type: bigint), '2008-04-08' (type: string), _col3 (type: string) + expressions: _col0 (type: string), UDFToLong(_col1) (type: bigint), '2008-04-08' (type: string), _col2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 2000 Data size: 20000 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -478,14 +478,14 @@ STAGE PLANS: Reducer 4 Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col3 (type: string) - outputColumnNames: _col0, _col1, _col3 + expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col2 (type: string) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 1000 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), UDFToLong(_col1) (type: bigint), '2008-04-08' (type: string), _col3 (type: string) + expressions: _col0 (type: string), UDFToLong(_col1) (type: bigint), '2008-04-08' (type: string), _col2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 2000 Data size: 20000 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/spark/union_view.q.out b/ql/src/test/results/clientpositive/spark/union_view.q.out index cce7710..492f71b 100644 --- a/ql/src/test/results/clientpositive/spark/union_view.q.out +++ b/ql/src/test/results/clientpositive/spark/union_view.q.out @@ -272,10 +272,10 @@ STAGE PLANS: Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '1' (type: string) + expressions: 86 (type: int), _col0 (type: string), '1' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -296,10 +296,10 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '1' (type: string) + expressions: 86 (type: int), _col0 (type: string), '1' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -320,10 +320,10 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '1' (type: string) + expressions: 86 (type: int), _col0 (type: string), '1' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -360,10 +360,10 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '2' (type: string) + expressions: 86 (type: int), _col0 (type: string), '2' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -384,10 +384,10 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '2' (type: string) + expressions: 86 (type: int), _col0 (type: string), '2' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -408,10 +408,10 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '2' (type: string) + expressions: 86 (type: int), _col0 (type: string), '2' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -448,10 +448,10 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '3' (type: string) + expressions: 86 (type: int), _col0 (type: string), '3' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -472,10 +472,10 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '3' (type: string) + expressions: 86 (type: int), _col0 (type: string), '3' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -496,10 +496,10 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '3' (type: string) + expressions: 86 (type: int), _col0 (type: string), '3' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -538,10 +538,10 @@ STAGE PLANS: Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string), ds (type: string) - outputColumnNames: _col1, _col2 + outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: string), _col2 (type: string) + expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 1250 Data size: 13280 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator @@ -560,10 +560,10 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string), ds (type: string) - outputColumnNames: _col1, _col2 + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: string), _col2 (type: string) + expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 1250 Data size: 13280 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator @@ -582,10 +582,10 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string), ds (type: string) - outputColumnNames: _col1, _col2 + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: string), _col2 (type: string) + expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 1250 Data size: 13280 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator @@ -931,10 +931,10 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '4' (type: string) + expressions: 86 (type: int), _col0 (type: string), '4' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -955,10 +955,10 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '4' (type: string) + expressions: 86 (type: int), _col0 (type: string), '4' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -979,10 +979,10 @@ STAGE PLANS: Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '4' (type: string) + expressions: 86 (type: int), _col0 (type: string), '4' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/subquery_notin.q.out b/ql/src/test/results/clientpositive/subquery_notin.q.out index ed86079..e157ff4 100644 --- a/ql/src/test/results/clientpositive/subquery_notin.q.out +++ b/ql/src/test/results/clientpositive/subquery_notin.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join JOIN[18][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[17][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: -- non agg, non corr explain select * @@ -151,7 +151,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[18][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[17][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: select * from src where src.key not in ( select key from src s1 where s1.key > '2') @@ -285,7 +285,7 @@ POSTHOOK: Input: default@src 199 val_199 199 val_199 2 val_2 -Warning: Shuffle Join JOIN[28][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[27][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: -- non agg, corr explain select p_mfgr, b.p_name, p_size @@ -530,7 +530,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[28][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[27][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: select p_mfgr, b.p_name, p_size from part b where b.p_name not in @@ -569,7 +569,7 @@ Manufacturer#4 almond azure aquamarine papaya violet 12 Manufacturer#5 almond antique blue firebrick mint 31 Manufacturer#5 almond aquamarine dodger light gainsboro 46 Manufacturer#5 almond azure blanched chiffon midnight 23 -Warning: Shuffle Join JOIN[39][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[38][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: -- agg, non corr explain select p_name, p_size @@ -851,7 +851,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[39][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[38][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: select p_name, p_size from part where part.p_size not in @@ -898,7 +898,7 @@ almond aquamarine sandy cyan gainsboro 18 almond aquamarine yellow dodger mint 7 almond azure aquamarine papaya violet 12 almond azure blanched chiffon midnight 23 -Warning: Shuffle Join JOIN[38][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[37][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: -- agg, corr explain select p_mfgr, p_name, p_size @@ -1212,7 +1212,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[38][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[37][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: select p_mfgr, p_name, p_size from part b where b.p_size not in (select min(p_size) @@ -1288,7 +1288,7 @@ POSTHOOK: Input: default@lineitem 139636 1 175839 1 182052 1 -Warning: Shuffle Join JOIN[18][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[17][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: -- alternate not in syntax select * from src diff --git a/ql/src/test/results/clientpositive/subquery_notin_having.q.java1.7.out b/ql/src/test/results/clientpositive/subquery_notin_having.q.java1.7.out index d6c6edc..8f17b6c 100644 --- a/ql/src/test/results/clientpositive/subquery_notin_having.q.java1.7.out +++ b/ql/src/test/results/clientpositive/subquery_notin_having.q.java1.7.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join JOIN[22][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product +Warning: Shuffle Join JOIN[21][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product PREHOOK: query: -- non agg, non corr -- JAVA_VERSION_SPECIFIC_OUTPUT @@ -188,7 +188,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[31][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product +Warning: Shuffle Join JOIN[30][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product PREHOOK: query: -- non agg, corr explain select b.p_mfgr, min(p_retailprice) @@ -445,7 +445,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[31][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product +Warning: Shuffle Join JOIN[30][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product PREHOOK: query: select b.p_mfgr, min(p_retailprice) from part b group by b.p_mfgr @@ -470,7 +470,7 @@ POSTHOOK: Input: default@part #### A masked pattern was here #### Manufacturer#1 1173.15 Manufacturer#2 1690.68 -Warning: Shuffle Join JOIN[32][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product +Warning: Shuffle Join JOIN[31][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product PREHOOK: query: -- agg, non corr explain select b.p_mfgr, min(p_retailprice) @@ -737,7 +737,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[32][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product +Warning: Shuffle Join JOIN[31][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-2:MAPRED' is a cross product PREHOOK: query: select b.p_mfgr, min(p_retailprice) from part b group by b.p_mfgr diff --git a/ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out b/ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out index ad5f72b..e34a401 100644 --- a/ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out +++ b/ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out @@ -775,7 +775,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join JOIN[28][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product +Warning: Shuffle Join JOIN[27][tables = [$hdt$_0, $hdt$_1]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: -- non agg, corr explain select p_mfgr, b.p_name, p_size diff --git a/ql/src/test/results/clientpositive/tez/bucket_map_join_tez1.q.out b/ql/src/test/results/clientpositive/tez/bucket_map_join_tez1.q.out index 9582334..df82393 100644 --- a/ql/src/test/results/clientpositive/tez/bucket_map_join_tez1.q.out +++ b/ql/src/test/results/clientpositive/tez/bucket_map_join_tez1.q.out @@ -1481,7 +1481,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@srcbucket_mapjoin POSTHOOK: Input: default@srcbucket_mapjoin@ds=2008-04-08 POSTHOOK: Output: default@tab@ds=2008-04-08 -POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:key, type:int, comment:null), ] +POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [] POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).value SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:value, type:string, comment:null), ] PREHOOK: query: explain select count(*) @@ -1594,7 +1594,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@srcbucket_mapjoin POSTHOOK: Input: default@srcbucket_mapjoin@ds=2008-04-08 POSTHOOK: Output: default@tab@ds=2008-04-08 -POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:key, type:int, comment:null), ] +POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).key SIMPLE [] POSTHOOK: Lineage: tab PARTITION(ds=2008-04-08).value SIMPLE [(srcbucket_mapjoin)srcbucket_mapjoin.FieldSchema(name:value, type:string, comment:null), ] PREHOOK: query: explain select count(*) diff --git a/ql/src/test/results/clientpositive/tez/cross_product_check_1.q.out b/ql/src/test/results/clientpositive/tez/cross_product_check_1.q.out index ca44973..d5530a5 100644 --- a/ql/src/test/results/clientpositive/tez/cross_product_check_1.q.out +++ b/ql/src/test/results/clientpositive/tez/cross_product_check_1.q.out @@ -324,8 +324,8 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join MERGEJOIN[22][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 4' is a cross product -Warning: Shuffle Join MERGEJOIN[23][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product +Warning: Shuffle Join MERGEJOIN[21][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 4' is a cross product +Warning: Shuffle Join MERGEJOIN[22][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product PREHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 PREHOOK: type: QUERY POSTHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 diff --git a/ql/src/test/results/clientpositive/tez/cross_product_check_2.q.out b/ql/src/test/results/clientpositive/tez/cross_product_check_2.q.out index ecd7f6b..45c4e3f 100644 --- a/ql/src/test/results/clientpositive/tez/cross_product_check_2.q.out +++ b/ql/src/test/results/clientpositive/tez/cross_product_check_2.q.out @@ -301,8 +301,8 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Map Join MAPJOIN[22][bigTable=?] in task 'Map 2' is a cross product -Warning: Map Join MAPJOIN[23][bigTable=?] in task 'Reducer 3' is a cross product +Warning: Map Join MAPJOIN[21][bigTable=?] in task 'Map 2' is a cross product +Warning: Map Join MAPJOIN[22][bigTable=?] in task 'Reducer 3' is a cross product PREHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 PREHOOK: type: QUERY POSTHOOK: query: explain select * from A join (select d1.key from B d1 join B d2 where 1 = 1 group by d1.key) od1 diff --git a/ql/src/test/results/clientpositive/tez/dynpart_sort_optimization2.q.out b/ql/src/test/results/clientpositive/tez/dynpart_sort_optimization2.q.out index 346e52f..8ef2b06 100644 --- a/ql/src/test/results/clientpositive/tez/dynpart_sort_optimization2.q.out +++ b/ql/src/test/results/clientpositive/tez/dynpart_sort_optimization2.q.out @@ -1630,7 +1630,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int), _col0 (type: string) + expressions: UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int), 'day' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -1724,6 +1724,7 @@ STAGE PLANS: Tez Edges: Reducer 2 <- Map 1 (SIMPLE_EDGE) + Reducer 3 <- Reducer 2 (SIMPLE_EDGE) #### A masked pattern was here #### Vertices: Map 1 @@ -1744,7 +1745,7 @@ STAGE PLANS: Reduce Output Operator key expressions: _col0 (type: string), _col1 (type: string) sort order: ++ - Map-reduce partition columns: _col0 (type: string) + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE value expressions: _col2 (type: bigint) Reducer 2 @@ -1757,17 +1758,30 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int), _col0 (type: string) + expressions: UDFToInteger(_col1) (type: int), UDFToInteger(_col2) (type: int), 'day' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false + Reduce Output Operator + key expressions: _col2 (type: string) + sort order: + + Map-reduce partition columns: _col2 (type: string) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE - table: - input format: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat - output format: org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat - serde: org.apache.hadoop.hive.ql.io.orc.OrcSerde - name: default.hive13_dp1 + value expressions: _col0 (type: int), _col1 (type: int), _col2 (type: string) + Reducer 3 + Execution mode: vectorized + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: int), VALUE._col1 (type: int), VALUE._col2 (type: string) + 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.hive.ql.io.orc.OrcInputFormat + output format: org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat + serde: org.apache.hadoop.hive.ql.io.orc.OrcSerde + name: default.hive13_dp1 Stage: Stage-2 Dependency Collection diff --git a/ql/src/test/results/clientpositive/tez/explainuser_1.q.out b/ql/src/test/results/clientpositive/tez/explainuser_1.q.out index 78c68c3..8c78fd9 100644 --- a/ql/src/test/results/clientpositive/tez/explainuser_1.q.out +++ b/ql/src/test/results/clientpositive/tez/explainuser_1.q.out @@ -2978,61 +2978,61 @@ Stage-0 limit:-1 Stage-1 Reducer 2 - File Output Operator [FS_15] + File Output Operator [FS_14] compressed:false Statistics:Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE 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"} - Select Operator [SEL_14] + Select Operator [SEL_13] outputColumnNames:["_col0","_col1"] Statistics:Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_13] + Filter Operator [FIL_12] predicate:_col3 is null (type: boolean) Statistics:Num rows: 1 Data size: 269 Basic stats: COMPLETE Column stats: COMPLETE - Merge Join Operator [MERGEJOIN_18] + Merge Join Operator [MERGEJOIN_17] | condition map:[{"":"Left Outer Join0 to 1"}] | keys:{"0":"_col1 (type: string)","1":"_col1 (type: string)"} | outputColumnNames:["_col0","_col1","_col3"] | Statistics:Num rows: 193 Data size: 51917 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 1 [SIMPLE_EDGE] - | Reduce Output Operator [RS_10] + | Reduce Output Operator [RS_9] | key expressions:_col1 (type: string) | Map-reduce partition columns:_col1 (type: string) | sort order:+ | Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE | value expressions:_col0 (type: string) - | Select Operator [SEL_2] + | Select Operator [SEL_1] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE | TableScan [TS_0] | alias:b | Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 4 [SIMPLE_EDGE] - Reduce Output Operator [RS_11] + Reduce Output Operator [RS_10] key expressions:_col1 (type: string) Map-reduce partition columns:_col1 (type: string) sort order:+ Statistics:Num rows: 83 Data size: 14774 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator [SEL_9] + Select Operator [SEL_8] outputColumnNames:["_col1"] Statistics:Num rows: 83 Data size: 14774 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator [GBY_8] + Group By Operator [GBY_7] | keys:KEY._col0 (type: string), KEY._col1 (type: string) | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 83 Data size: 14774 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 3 [SIMPLE_EDGE] - Reduce Output Operator [RS_7] + Reduce Output Operator [RS_6] key expressions:_col0 (type: string), _col1 (type: string) Map-reduce partition columns:_col0 (type: string), _col1 (type: string) sort order:++ Statistics:Num rows: 83 Data size: 14774 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator [GBY_6] + Group By Operator [GBY_5] keys:key (type: string), value (type: string) outputColumnNames:["_col0","_col1"] Statistics:Num rows: 83 Data size: 14774 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_17] + Filter Operator [FIL_16] predicate:(value > 'val_2') (type: boolean) Statistics:Num rows: 166 Data size: 29548 Basic stats: COMPLETE Column stats: COMPLETE - TableScan [TS_3] + TableScan [TS_2] alias:b Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE @@ -3065,57 +3065,57 @@ Stage-0 limit:-1 Stage-1 Reducer 3 - File Output Operator [FS_15] + File Output Operator [FS_14] compressed:false Statistics:Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE 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"} - Select Operator [SEL_14] + Select Operator [SEL_13] outputColumnNames:["_col0","_col1"] Statistics:Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_13] + Filter Operator [FIL_12] predicate:_col3 is null (type: boolean) Statistics:Num rows: 1 Data size: 265 Basic stats: COMPLETE Column stats: COMPLETE - Merge Join Operator [MERGEJOIN_18] + Merge Join Operator [MERGEJOIN_17] | condition map:[{"":"Left Outer Join0 to 1"}] | keys:{"0":"_col1 (type: string), _col0 (type: string)","1":"_col0 (type: string), _col1 (type: string)"} | outputColumnNames:["_col0","_col1","_col3"] | Statistics:Num rows: 1 Data size: 265 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 4 [SIMPLE_EDGE] - | Reduce Output Operator [RS_11] + | Reduce Output Operator [RS_10] | key expressions:_col0 (type: string), _col1 (type: string) | Map-reduce partition columns:_col0 (type: string), _col1 (type: string) | sort order:++ | Statistics:Num rows: 166 Data size: 29548 Basic stats: COMPLETE Column stats: COMPLETE - | Select Operator [SEL_9] + | Select Operator [SEL_8] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 166 Data size: 29548 Basic stats: COMPLETE Column stats: COMPLETE - | Filter Operator [FIL_17] + | Filter Operator [FIL_16] | predicate:(value > 'val_12') (type: boolean) | Statistics:Num rows: 166 Data size: 29548 Basic stats: COMPLETE Column stats: COMPLETE - | TableScan [TS_7] + | TableScan [TS_6] | alias:b | Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 2 [SIMPLE_EDGE] - Reduce Output Operator [RS_10] + Reduce Output Operator [RS_9] key expressions:_col1 (type: string), _col0 (type: string) Map-reduce partition columns:_col1 (type: string), _col0 (type: string) sort order:++ Statistics:Num rows: 250 Data size: 44500 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator [GBY_5] + Group By Operator [GBY_4] | keys:KEY._col0 (type: string), KEY._col1 (type: string) | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 250 Data size: 44500 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 1 [SIMPLE_EDGE] - Reduce Output Operator [RS_4] + Reduce Output Operator [RS_3] key expressions:_col0 (type: string), _col1 (type: string) Map-reduce partition columns:_col0 (type: string), _col1 (type: string) sort order:++ Statistics:Num rows: 250 Data size: 44500 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator [GBY_3] + Group By Operator [GBY_2] keys:key (type: string), value (type: string) outputColumnNames:["_col0","_col1"] Statistics:Num rows: 250 Data size: 44500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator [SEL_2] + Select Operator [SEL_1] outputColumnNames:["key","value"] Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE TableScan [TS_0] @@ -3715,96 +3715,96 @@ Stage-0 limit:-1 Stage-1 Reducer 4 - File Output Operator [FS_26] + File Output Operator [FS_25] compressed:false Statistics:Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE 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"} - Select Operator [SEL_25] + Select Operator [SEL_24] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 3 [SIMPLE_EDGE] - Reduce Output Operator [RS_24] + Reduce Output Operator [RS_23] key expressions:_col0 (type: string) sort order:+ Statistics:Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE value expressions:_col1 (type: string) - Select Operator [SEL_23] + Select Operator [SEL_22] outputColumnNames:["_col0","_col1"] Statistics:Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_22] + Filter Operator [FIL_21] predicate:_col3 is null (type: boolean) Statistics:Num rows: 1 Data size: 265 Basic stats: COMPLETE Column stats: COMPLETE - Merge Join Operator [MERGEJOIN_31] + Merge Join Operator [MERGEJOIN_30] | condition map:[{"":"Left Outer Join0 to 1"}] | keys:{"0":"_col0 (type: string)","1":"_col0 (type: string)"} | outputColumnNames:["_col0","_col1","_col3"] | Statistics:Num rows: 404 Data size: 107060 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 7 [SIMPLE_EDGE] - | Reduce Output Operator [RS_20] + | Reduce Output Operator [RS_19] | key expressions:_col0 (type: string) | Map-reduce partition columns:_col0 (type: string) | sort order:+ | Statistics:Num rows: 166 Data size: 14442 Basic stats: COMPLETE Column stats: COMPLETE - | Select Operator [SEL_14] + | Select Operator [SEL_13] | outputColumnNames:["_col0"] | Statistics:Num rows: 166 Data size: 14442 Basic stats: COMPLETE Column stats: COMPLETE - | Filter Operator [FIL_29] + | Filter Operator [FIL_28] | predicate:(key > '2') (type: boolean) | Statistics:Num rows: 166 Data size: 14442 Basic stats: COMPLETE Column stats: COMPLETE - | TableScan [TS_12] + | TableScan [TS_11] | alias:src_cbo | Statistics:Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 2 [SIMPLE_EDGE] - Reduce Output Operator [RS_19] + Reduce Output Operator [RS_18] key expressions:_col0 (type: string) Map-reduce partition columns:_col0 (type: string) sort order:+ Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE value expressions:_col1 (type: string) - Merge Join Operator [MERGEJOIN_30] + Merge Join Operator [MERGEJOIN_29] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{} | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 1 [SIMPLE_EDGE] - | Reduce Output Operator [RS_16] + | Reduce Output Operator [RS_15] | sort order: | Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE | value expressions:_col0 (type: string), _col1 (type: string) - | Select Operator [SEL_2] + | Select Operator [SEL_1] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE | TableScan [TS_0] | alias:src_cbo | Statistics:Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 6 [SIMPLE_EDGE] - Reduce Output Operator [RS_17] + Reduce Output Operator [RS_16] sort order: Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator [SEL_11] + Select Operator [SEL_10] Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_10] + Filter Operator [FIL_9] predicate:(_col0 = 0) (type: boolean) Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator [GBY_8] + Group By Operator [GBY_7] | aggregations:["count(VALUE._col0)"] | outputColumnNames:["_col0"] | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 5 [SIMPLE_EDGE] - Reduce Output Operator [RS_7] + Reduce Output Operator [RS_6] sort order: Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE value expressions:_col0 (type: bigint) - Group By Operator [GBY_6] + Group By Operator [GBY_5] aggregations:["count()"] outputColumnNames:["_col0"] Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator [SEL_5] + Select Operator [SEL_4] Statistics:Num rows: 1 Data size: 87 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_28] + Filter Operator [FIL_27] predicate:((key > '2') and key is null) (type: boolean) Statistics:Num rows: 1 Data size: 87 Basic stats: COMPLETE Column stats: COMPLETE - TableScan [TS_3] + TableScan [TS_2] alias:src_cbo Statistics:Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE @@ -3836,87 +3836,87 @@ Stage-0 limit:-1 Stage-1 Reducer 3 - File Output Operator [FS_24] + File Output Operator [FS_23] compressed:false Statistics:Num rows: 1 Data size: 223 Basic stats: COMPLETE Column stats: COMPLETE 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"} - Select Operator [SEL_23] + Select Operator [SEL_22] outputColumnNames:["_col0","_col1","_col2"] Statistics:Num rows: 1 Data size: 223 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_22] + Filter Operator [FIL_21] predicate:_col4 is null (type: boolean) Statistics:Num rows: 1 Data size: 344 Basic stats: COMPLETE Column stats: COMPLETE - Merge Join Operator [MERGEJOIN_29] + Merge Join Operator [MERGEJOIN_28] | condition map:[{"":"Left Outer Join0 to 1"}] | keys:{"0":"_col0 (type: string), _col1 (type: string)","1":"_col0 (type: string), _col1 (type: string)"} | outputColumnNames:["_col0","_col1","_col2","_col4"] | Statistics:Num rows: 1 Data size: 344 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 6 [SIMPLE_EDGE] - | Reduce Output Operator [RS_20] + | Reduce Output Operator [RS_19] | key expressions:_col0 (type: string), _col1 (type: string) | Map-reduce partition columns:_col0 (type: string), _col1 (type: string) | sort order:++ | Statistics:Num rows: 8 Data size: 1752 Basic stats: COMPLETE Column stats: COMPLETE - | Select Operator [SEL_14] + | Select Operator [SEL_13] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 8 Data size: 1752 Basic stats: COMPLETE Column stats: COMPLETE - | Filter Operator [FIL_27] + | Filter Operator [FIL_26] | predicate:(p_size < 10) (type: boolean) | Statistics:Num rows: 8 Data size: 1784 Basic stats: COMPLETE Column stats: COMPLETE - | TableScan [TS_12] + | TableScan [TS_11] | alias:b | Statistics:Num rows: 26 Data size: 5798 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 2 [SIMPLE_EDGE] - Reduce Output Operator [RS_19] + Reduce Output Operator [RS_18] key expressions:_col0 (type: string), _col1 (type: string) Map-reduce partition columns:_col0 (type: string), _col1 (type: string) sort order:++ Statistics:Num rows: 26 Data size: 5798 Basic stats: COMPLETE Column stats: COMPLETE value expressions:_col2 (type: int) - Merge Join Operator [MERGEJOIN_28] + Merge Join Operator [MERGEJOIN_27] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{} | outputColumnNames:["_col0","_col1","_col2"] | Statistics:Num rows: 26 Data size: 5798 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 1 [SIMPLE_EDGE] - | Reduce Output Operator [RS_16] + | Reduce Output Operator [RS_15] | sort order: | Statistics:Num rows: 26 Data size: 5798 Basic stats: COMPLETE Column stats: COMPLETE | value expressions:_col0 (type: string), _col1 (type: string), _col2 (type: int) - | Select Operator [SEL_2] + | Select Operator [SEL_1] | outputColumnNames:["_col0","_col1","_col2"] | Statistics:Num rows: 26 Data size: 5798 Basic stats: COMPLETE Column stats: COMPLETE | TableScan [TS_0] | alias:b | Statistics:Num rows: 26 Data size: 5798 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 5 [SIMPLE_EDGE] - Reduce Output Operator [RS_17] + Reduce Output Operator [RS_16] sort order: Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator [SEL_11] + Select Operator [SEL_10] Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_10] + Filter Operator [FIL_9] predicate:(_col0 = 0) (type: boolean) Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator [GBY_8] + Group By Operator [GBY_7] | aggregations:["count(VALUE._col0)"] | outputColumnNames:["_col0"] | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 4 [SIMPLE_EDGE] - Reduce Output Operator [RS_7] + Reduce Output Operator [RS_6] sort order: Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE value expressions:_col0 (type: bigint) - Group By Operator [GBY_6] + Group By Operator [GBY_5] aggregations:["count()"] outputColumnNames:["_col0"] Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator [SEL_5] + Select Operator [SEL_4] Statistics:Num rows: 1 Data size: 223 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_26] + Filter Operator [FIL_25] predicate:((p_size < 10) and (p_name is null or p_mfgr is null)) (type: boolean) Statistics:Num rows: 1 Data size: 223 Basic stats: COMPLETE Column stats: COMPLETE - TableScan [TS_3] + TableScan [TS_2] alias:b Statistics:Num rows: 26 Data size: 5798 Basic stats: COMPLETE Column stats: COMPLETE @@ -3950,113 +3950,113 @@ Stage-0 limit:-1 Stage-1 Reducer 4 - File Output Operator [FS_37] + File Output Operator [FS_36] compressed:false Statistics:Num rows: 1 Data size: 125 Basic stats: COMPLETE Column stats: COMPLETE 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"} - Select Operator [SEL_36] + Select Operator [SEL_35] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 1 Data size: 125 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 3 [SIMPLE_EDGE] - Reduce Output Operator [RS_35] + Reduce Output Operator [RS_34] key expressions:_col0 (type: string) sort order:+ Statistics:Num rows: 1 Data size: 125 Basic stats: COMPLETE Column stats: COMPLETE value expressions:_col1 (type: int) - Select Operator [SEL_34] + Select Operator [SEL_33] outputColumnNames:["_col0","_col1"] Statistics:Num rows: 1 Data size: 125 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_33] + Filter Operator [FIL_32] predicate:_col3 is null (type: boolean) Statistics:Num rows: 1 Data size: 133 Basic stats: COMPLETE Column stats: COMPLETE - Merge Join Operator [MERGEJOIN_43] + Merge Join Operator [MERGEJOIN_42] | condition map:[{"":"Left Outer Join0 to 1"}] | keys:{"0":"UDFToDouble(_col1) (type: double)","1":"_col0 (type: double)"} | outputColumnNames:["_col0","_col1","_col3"] | Statistics:Num rows: 1 Data size: 133 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 2 [SIMPLE_EDGE] - | Reduce Output Operator [RS_30] + | Reduce Output Operator [RS_29] | key expressions:UDFToDouble(_col1) (type: double) | Map-reduce partition columns:UDFToDouble(_col1) (type: double) | sort order:+ | Statistics:Num rows: 26 Data size: 3250 Basic stats: COMPLETE Column stats: COMPLETE | value expressions:_col0 (type: string), _col1 (type: int) - | Merge Join Operator [MERGEJOIN_42] + | Merge Join Operator [MERGEJOIN_41] | | condition map:[{"":"Inner Join 0 to 1"}] | | keys:{} | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 26 Data size: 3250 Basic stats: COMPLETE Column stats: COMPLETE | |<-Map 1 [SIMPLE_EDGE] - | | Reduce Output Operator [RS_27] + | | Reduce Output Operator [RS_26] | | sort order: | | Statistics:Num rows: 26 Data size: 3250 Basic stats: COMPLETE Column stats: COMPLETE | | value expressions:_col0 (type: string), _col1 (type: int) - | | Select Operator [SEL_2] + | | Select Operator [SEL_1] | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 26 Data size: 3250 Basic stats: COMPLETE Column stats: COMPLETE | | TableScan [TS_0] | | alias:part | | Statistics:Num rows: 26 Data size: 3250 Basic stats: COMPLETE Column stats: COMPLETE | |<-Reducer 6 [SIMPLE_EDGE] - | Reduce Output Operator [RS_28] + | Reduce Output Operator [RS_27] | sort order: | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - | Select Operator [SEL_18] + | Select Operator [SEL_17] | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - | Filter Operator [FIL_17] + | Filter Operator [FIL_16] | predicate:(_col0 = 0) (type: boolean) | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - | Group By Operator [GBY_15] + | Group By Operator [GBY_14] | aggregations:["count()"] | outputColumnNames:["_col0"] | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - | Select Operator [SEL_11] + | Select Operator [SEL_10] | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - | Filter Operator [FIL_10] + | Filter Operator [FIL_9] | predicate:_col0 is null (type: boolean) | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - | Group By Operator [GBY_8] + | Group By Operator [GBY_7] | | aggregations:["avg(VALUE._col0)"] | | outputColumnNames:["_col0"] | | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE | |<-Map 5 [SIMPLE_EDGE] - | Reduce Output Operator [RS_7] + | Reduce Output Operator [RS_6] | sort order: | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: COMPLETE | value expressions:_col0 (type: struct) - | Group By Operator [GBY_6] + | Group By Operator [GBY_5] | aggregations:["avg(p_size)"] | outputColumnNames:["_col0"] | Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: COMPLETE - | Filter Operator [FIL_39] + | Filter Operator [FIL_38] | predicate:(p_size < 10) (type: boolean) | Statistics:Num rows: 8 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE - | TableScan [TS_3] + | TableScan [TS_2] | alias:part | Statistics:Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 8 [SIMPLE_EDGE] - Reduce Output Operator [RS_31] + Reduce Output Operator [RS_30] key expressions:_col0 (type: double) Map-reduce partition columns:_col0 (type: double) sort order:+ Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator [GBY_24] + Group By Operator [GBY_23] | aggregations:["avg(VALUE._col0)"] | outputColumnNames:["_col0"] | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 7 [SIMPLE_EDGE] - Reduce Output Operator [RS_23] + Reduce Output Operator [RS_22] sort order: Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: COMPLETE value expressions:_col0 (type: struct) - Group By Operator [GBY_22] + Group By Operator [GBY_21] aggregations:["avg(p_size)"] outputColumnNames:["_col0"] Statistics:Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: COMPLETE - Filter Operator [FIL_41] + Filter Operator [FIL_40] predicate:(p_size < 10) (type: boolean) Statistics:Num rows: 8 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE - TableScan [TS_19] + TableScan [TS_18] alias:part Statistics:Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE @@ -4096,149 +4096,149 @@ Stage-0 limit:-1 Stage-1 Reducer 5 - File Output Operator [FS_39] + File Output Operator [FS_38] compressed:false Statistics:Num rows: 1 Data size: 106 Basic stats: COMPLETE Column stats: COMPLETE 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"} - Select Operator [SEL_38] + Select Operator [SEL_37] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 1 Data size: 106 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 4 [SIMPLE_EDGE] - Reduce Output Operator [RS_37] + Reduce Output Operator [RS_36] key expressions:_col0 (type: string) sort order:+ Statistics:Num rows: 1 Data size: 106 Basic stats: COMPLETE Column stats: COMPLETE value expressions:_col1 (type: double) - Select Operator [SEL_36] + Select Operator [SEL_35] outputColumnNames:["_col0","_col1"] Statistics:Num rows: 1 Data size: 106 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_35] + Filter Operator [FIL_34] predicate:_col3 is null (type: boolean) Statistics:Num rows: 1 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE - Merge Join Operator [MERGEJOIN_44] + Merge Join Operator [MERGEJOIN_43] | condition map:[{"":"Left Outer Join0 to 1"}] | keys:{"0":"_col0 (type: string), _col1 (type: double)","1":"_col0 (type: string), _col1 (type: double)"} | outputColumnNames:["_col0","_col1","_col3"] | Statistics:Num rows: 1 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 10 [SIMPLE_EDGE] - | Reduce Output Operator [RS_33] + | Reduce Output Operator [RS_32] | key expressions:_col0 (type: string), _col1 (type: double) | Map-reduce partition columns:_col0 (type: string), _col1 (type: double) | sort order:++ | Statistics:Num rows: 1 Data size: 106 Basic stats: COMPLETE Column stats: COMPLETE - | Select Operator [SEL_27] + | Select Operator [SEL_26] | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 1 Data size: 106 Basic stats: COMPLETE Column stats: COMPLETE - | Filter Operator [FIL_41] + | Filter Operator [FIL_40] | predicate:((_col2 - _col1) > 600.0) (type: boolean) | Statistics:Num rows: 1 Data size: 114 Basic stats: COMPLETE Column stats: COMPLETE - | Group By Operator [GBY_25] + | Group By Operator [GBY_24] | | aggregations:["min(VALUE._col0)","max(VALUE._col1)"] | | keys:KEY._col0 (type: string) | | outputColumnNames:["_col0","_col1","_col2"] | | Statistics:Num rows: 5 Data size: 570 Basic stats: COMPLETE Column stats: COMPLETE | |<-Map 9 [SIMPLE_EDGE] - | Reduce Output Operator [RS_24] + | Reduce Output Operator [RS_23] | key expressions:_col0 (type: string) | Map-reduce partition columns:_col0 (type: string) | sort order:+ | Statistics:Num rows: 5 Data size: 570 Basic stats: COMPLETE Column stats: COMPLETE | value expressions:_col1 (type: double), _col2 (type: double) - | Group By Operator [GBY_23] + | Group By Operator [GBY_22] | aggregations:["min(p_retailprice)","max(p_retailprice)"] | keys:p_mfgr (type: string) | outputColumnNames:["_col0","_col1","_col2"] | Statistics:Num rows: 5 Data size: 570 Basic stats: COMPLETE Column stats: COMPLETE - | TableScan [TS_21] + | TableScan [TS_20] | alias:b | Statistics:Num rows: 26 Data size: 2756 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 3 [SIMPLE_EDGE] - Reduce Output Operator [RS_32] + Reduce Output Operator [RS_31] key expressions:_col0 (type: string), _col1 (type: double) Map-reduce partition columns:_col0 (type: string), _col1 (type: double) sort order:++ Statistics:Num rows: 5 Data size: 530 Basic stats: COMPLETE Column stats: COMPLETE - Merge Join Operator [MERGEJOIN_43] + Merge Join Operator [MERGEJOIN_42] | condition map:[{"":"Inner Join 0 to 1"}] | keys:{} | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 5 Data size: 530 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 2 [SIMPLE_EDGE] - | Reduce Output Operator [RS_29] + | Reduce Output Operator [RS_28] | sort order: | Statistics:Num rows: 5 Data size: 530 Basic stats: COMPLETE Column stats: COMPLETE | value expressions:_col0 (type: string), _col1 (type: double) - | Group By Operator [GBY_5] + | Group By Operator [GBY_4] | | aggregations:["min(VALUE._col0)"] | | keys:KEY._col0 (type: string) | | outputColumnNames:["_col0","_col1"] | | Statistics:Num rows: 5 Data size: 530 Basic stats: COMPLETE Column stats: COMPLETE | |<-Map 1 [SIMPLE_EDGE] - | Reduce Output Operator [RS_4] + | Reduce Output Operator [RS_3] | key expressions:_col0 (type: string) | Map-reduce partition columns:_col0 (type: string) | sort order:+ | Statistics:Num rows: 5 Data size: 530 Basic stats: COMPLETE Column stats: COMPLETE | value expressions:_col1 (type: double) - | Group By Operator [GBY_3] + | Group By Operator [GBY_2] | aggregations:["min(p_retailprice)"] | keys:p_mfgr (type: string) | outputColumnNames:["_col0","_col1"] | Statistics:Num rows: 5 Data size: 530 Basic stats: COMPLETE Column stats: COMPLETE - | Select Operator [SEL_2] + | Select Operator [SEL_1] | outputColumnNames:["p_mfgr","p_retailprice"] | Statistics:Num rows: 26 Data size: 2756 Basic stats: COMPLETE Column stats: COMPLETE | TableScan [TS_0] | alias:b | Statistics:Num rows: 26 Data size: 2756 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 8 [SIMPLE_EDGE] - Reduce Output Operator [RS_30] + Reduce Output Operator [RS_29] sort order: Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator [SEL_20] + Select Operator [SEL_19] Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_19] + Filter Operator [FIL_18] predicate:(_col0 = 0) (type: boolean) Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator [GBY_17] + Group By Operator [GBY_16] | aggregations:["count(VALUE._col0)"] | outputColumnNames:["_col0"] | Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE |<-Reducer 7 [SIMPLE_EDGE] - Reduce Output Operator [RS_16] + Reduce Output Operator [RS_15] sort order: Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE value expressions:_col0 (type: bigint) - Group By Operator [GBY_15] + Group By Operator [GBY_14] aggregations:["count()"] outputColumnNames:["_col0"] Statistics:Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator [SEL_13] + Select Operator [SEL_12] Statistics:Num rows: 1 Data size: 114 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator [FIL_12] + Filter Operator [FIL_11] predicate:(((_col2 - _col1) > 600.0) and (_col0 is null or _col1 is null)) (type: boolean) Statistics:Num rows: 1 Data size: 114 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator [GBY_11] + Group By Operator [GBY_10] | aggregations:["min(VALUE._col0)","max(VALUE._col1)"] | keys:KEY._col0 (type: string) | outputColumnNames:["_col0","_col1","_col2"] | Statistics:Num rows: 5 Data size: 570 Basic stats: COMPLETE Column stats: COMPLETE |<-Map 6 [SIMPLE_EDGE] - Reduce Output Operator [RS_10] + Reduce Output Operator [RS_9] key expressions:_col0 (type: string) Map-reduce partition columns:_col0 (type: string) sort order:+ Statistics:Num rows: 5 Data size: 570 Basic stats: COMPLETE Column stats: COMPLETE value expressions:_col1 (type: double), _col2 (type: double) - Group By Operator [GBY_9] + Group By Operator [GBY_8] aggregations:["min(p_retailprice)","max(p_retailprice)"] keys:p_mfgr (type: string) outputColumnNames:["_col0","_col1","_col2"] Statistics:Num rows: 5 Data size: 570 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator [SEL_8] + Select Operator [SEL_7] outputColumnNames:["p_mfgr","p_retailprice"] Statistics:Num rows: 26 Data size: 2756 Basic stats: COMPLETE Column stats: COMPLETE - TableScan [TS_7] + TableScan [TS_6] alias:b Statistics:Num rows: 26 Data size: 2756 Basic stats: COMPLETE Column stats: COMPLETE diff --git a/ql/src/test/results/clientpositive/tez/vector_decimal_round.q.out b/ql/src/test/results/clientpositive/tez/vector_decimal_round.q.out index 9a5d047..5bc04d7 100644 --- a/ql/src/test/results/clientpositive/tez/vector_decimal_round.q.out +++ b/ql/src/test/results/clientpositive/tez/vector_decimal_round.q.out @@ -118,7 +118,7 @@ STAGE PLANS: outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 3 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: round(_col0, (- 1)) (type: decimal(11,0)) + key expressions: round(_col0, -1) (type: decimal(11,0)) sort order: + Statistics: Num rows: 1 Data size: 3 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: decimal(10,0)) @@ -268,7 +268,7 @@ STAGE PLANS: outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 3 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: round(_col0, (- 1)) (type: decimal(11,0)) + key expressions: round(_col0, -1) (type: decimal(11,0)) sort order: + Statistics: Num rows: 1 Data size: 3 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: decimal(10,0)) @@ -419,7 +419,7 @@ STAGE PLANS: outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: round(_col0, (- 1)) (type: decimal(11,0)) + key expressions: round(_col0, -1) (type: decimal(11,0)) sort order: + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: decimal(10,0)) diff --git a/ql/src/test/results/clientpositive/udf1.q.out b/ql/src/test/results/clientpositive/udf1.q.out index dffbccf..b3b694b 100644 --- a/ql/src/test/results/clientpositive/udf1.q.out +++ b/ql/src/test/results/clientpositive/udf1.q.out @@ -137,26 +137,26 @@ POSTHOOK: query: FROM src INSERT OVERWRITE TABLE dest1 SELECT 'a' LIKE '%a%', 'b POSTHOOK: type: QUERY POSTHOOK: Input: default@src POSTHOOK: Output: default@dest1 -POSTHOOK: Lineage: dest1.c1 EXPRESSION [] -POSTHOOK: Lineage: dest1.c10 EXPRESSION [] -POSTHOOK: Lineage: dest1.c11 EXPRESSION [] -POSTHOOK: Lineage: dest1.c12 EXPRESSION [] -POSTHOOK: Lineage: dest1.c13 EXPRESSION [] -POSTHOOK: Lineage: dest1.c14 EXPRESSION [] -POSTHOOK: Lineage: dest1.c15 EXPRESSION [] -POSTHOOK: Lineage: dest1.c16 EXPRESSION [] -POSTHOOK: Lineage: dest1.c17 EXPRESSION [] -POSTHOOK: Lineage: dest1.c18 EXPRESSION [] -POSTHOOK: Lineage: dest1.c19 EXPRESSION [] -POSTHOOK: Lineage: dest1.c2 EXPRESSION [] -POSTHOOK: Lineage: dest1.c20 EXPRESSION [] -POSTHOOK: Lineage: dest1.c3 EXPRESSION [] -POSTHOOK: Lineage: dest1.c4 EXPRESSION [] -POSTHOOK: Lineage: dest1.c5 EXPRESSION [] -POSTHOOK: Lineage: dest1.c6 EXPRESSION [] -POSTHOOK: Lineage: dest1.c7 EXPRESSION [] -POSTHOOK: Lineage: dest1.c8 EXPRESSION [] -POSTHOOK: Lineage: dest1.c9 EXPRESSION [] +POSTHOOK: Lineage: dest1.c1 SIMPLE [] +POSTHOOK: Lineage: dest1.c10 SIMPLE [] +POSTHOOK: Lineage: dest1.c11 SIMPLE [] +POSTHOOK: Lineage: dest1.c12 SIMPLE [] +POSTHOOK: Lineage: dest1.c13 SIMPLE [] +POSTHOOK: Lineage: dest1.c14 SIMPLE [] +POSTHOOK: Lineage: dest1.c15 SIMPLE [] +POSTHOOK: Lineage: dest1.c16 SIMPLE [] +POSTHOOK: Lineage: dest1.c17 SIMPLE [] +POSTHOOK: Lineage: dest1.c18 SIMPLE [] +POSTHOOK: Lineage: dest1.c19 SIMPLE [] +POSTHOOK: Lineage: dest1.c2 SIMPLE [] +POSTHOOK: Lineage: dest1.c20 SIMPLE [] +POSTHOOK: Lineage: dest1.c3 SIMPLE [] +POSTHOOK: Lineage: dest1.c4 SIMPLE [] +POSTHOOK: Lineage: dest1.c5 SIMPLE [] +POSTHOOK: Lineage: dest1.c6 SIMPLE [] +POSTHOOK: Lineage: dest1.c7 SIMPLE [] +POSTHOOK: Lineage: dest1.c8 SIMPLE [] +POSTHOOK: Lineage: dest1.c9 SIMPLE [] PREHOOK: query: SELECT dest1.* FROM dest1 PREHOOK: type: QUERY PREHOOK: Input: default@dest1 diff --git a/ql/src/test/results/clientpositive/udf_10_trims.q.out b/ql/src/test/results/clientpositive/udf_10_trims.q.out index 2f79723..3a5303a 100644 --- a/ql/src/test/results/clientpositive/udf_10_trims.q.out +++ b/ql/src/test/results/clientpositive/udf_10_trims.q.out @@ -117,4 +117,4 @@ WHERE src.key = 86 POSTHOOK: type: QUERY POSTHOOK: Input: default@src POSTHOOK: Output: default@dest1 -POSTHOOK: Lineage: dest1.c1 EXPRESSION [] +POSTHOOK: Lineage: dest1.c1 SIMPLE [] diff --git a/ql/src/test/results/clientpositive/udf_folder_constants.q.out b/ql/src/test/results/clientpositive/udf_folder_constants.q.out index 3830daf..ef07420 100644 --- a/ql/src/test/results/clientpositive/udf_folder_constants.q.out +++ b/ql/src/test/results/clientpositive/udf_folder_constants.q.out @@ -63,12 +63,12 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: month (type: int) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col1 (type: int) + key expressions: _col0 (type: int) sort order: + - Map-reduce partition columns: _col1 (type: int) + Map-reduce partition columns: _col0 (type: int) Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: NONE TableScan alias: b @@ -90,7 +90,7 @@ STAGE PLANS: condition map: Inner Join 0 to 1 keys: - 0 _col1 (type: int) + 0 _col0 (type: int) 1 _col0 (type: int) Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git a/ql/src/test/results/clientpositive/union_remove_25.q.out b/ql/src/test/results/clientpositive/union_remove_25.q.out index c98d4c8..d82fcfc 100644 --- a/ql/src/test/results/clientpositive/union_remove_25.q.out +++ b/ql/src/test/results/clientpositive/union_remove_25.q.out @@ -467,7 +467,7 @@ STAGE PLANS: Statistics: Num rows: 1000 Data size: 10624 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: key (type: string), value (type: string), hr (type: string) - outputColumnNames: _col0, _col1, _col3 + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1000 Data size: 10624 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 1000 @@ -476,17 +476,17 @@ STAGE PLANS: sort order: Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string) + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string) Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col3 (type: string) - outputColumnNames: _col0, _col1, _col3 + expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col2 (type: string) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 1000 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), UDFToLong(_col1) (type: bigint), '2008-04-08' (type: string), _col3 (type: string) + expressions: _col0 (type: string), UDFToLong(_col1) (type: bigint), '2008-04-08' (type: string), _col2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -519,7 +519,7 @@ STAGE PLANS: Statistics: Num rows: 1000 Data size: 10624 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: key (type: string), value (type: string), hr (type: string) - outputColumnNames: _col0, _col1, _col3 + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1000 Data size: 10624 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 1000 @@ -528,17 +528,17 @@ STAGE PLANS: sort order: Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string) + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string) Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col3 (type: string) - outputColumnNames: _col0, _col1, _col3 + expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col2 (type: string) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 1000 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), UDFToLong(_col1) (type: bigint), '2008-04-08' (type: string), _col3 (type: string) + expressions: _col0 (type: string), UDFToLong(_col1) (type: bigint), '2008-04-08' (type: string), _col2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1000 Data size: 10000 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/union_view.q.out b/ql/src/test/results/clientpositive/union_view.q.out index 66ca51b..1d93159 100644 --- a/ql/src/test/results/clientpositive/union_view.q.out +++ b/ql/src/test/results/clientpositive/union_view.q.out @@ -358,12 +358,12 @@ STAGE PLANS: Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Union Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '1' (type: string) + expressions: 86 (type: int), _col0 (type: string), '1' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -382,12 +382,12 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Union Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '1' (type: string) + expressions: 86 (type: int), _col0 (type: string), '1' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -406,12 +406,12 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Union Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '1' (type: string) + expressions: 86 (type: int), _col0 (type: string), '1' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -471,12 +471,12 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Union Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '2' (type: string) + expressions: 86 (type: int), _col0 (type: string), '2' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -495,12 +495,12 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Union Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '2' (type: string) + expressions: 86 (type: int), _col0 (type: string), '2' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -519,12 +519,12 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Union Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '2' (type: string) + expressions: 86 (type: int), _col0 (type: string), '2' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -584,12 +584,12 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Union Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '3' (type: string) + expressions: 86 (type: int), _col0 (type: string), '3' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -608,12 +608,12 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Union Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '3' (type: string) + expressions: 86 (type: int), _col0 (type: string), '3' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -632,12 +632,12 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Union Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '3' (type: string) + expressions: 86 (type: int), _col0 (type: string), '3' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 502 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -701,12 +701,12 @@ STAGE PLANS: Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string), ds (type: string) - outputColumnNames: _col1, _col2 + outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Union Statistics: Num rows: 1250 Data size: 13280 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: string), _col2 (type: string) + expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 1250 Data size: 13280 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator @@ -723,12 +723,12 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string), ds (type: string) - outputColumnNames: _col1, _col2 + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Union Statistics: Num rows: 1250 Data size: 13280 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: string), _col2 (type: string) + expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 1250 Data size: 13280 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator @@ -745,12 +745,12 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string), ds (type: string) - outputColumnNames: _col1, _col2 + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Union Statistics: Num rows: 1250 Data size: 13280 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: string), _col2 (type: string) + expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 1250 Data size: 13280 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator @@ -1226,12 +1226,12 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Union Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '4' (type: string) + expressions: 86 (type: int), _col0 (type: string), '4' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -1250,12 +1250,12 @@ STAGE PLANS: Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Union Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '4' (type: string) + expressions: 86 (type: int), _col0 (type: string), '4' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -1274,12 +1274,12 @@ STAGE PLANS: Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) - outputColumnNames: _col1 + outputColumnNames: _col0 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Union Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 86 (type: int), _col1 (type: string), '4' (type: string) + expressions: 86 (type: int), _col0 (type: string), '4' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 252 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git a/ql/src/test/results/clientpositive/vector_decimal_round.q.out b/ql/src/test/results/clientpositive/vector_decimal_round.q.out index 25e5cfa..ec6226e 100644 --- a/ql/src/test/results/clientpositive/vector_decimal_round.q.out +++ b/ql/src/test/results/clientpositive/vector_decimal_round.q.out @@ -106,7 +106,7 @@ STAGE PLANS: outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 3 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: round(_col0, (- 1)) (type: decimal(11,0)) + key expressions: round(_col0, -1) (type: decimal(11,0)) sort order: + Statistics: Num rows: 1 Data size: 3 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: decimal(10,0)) @@ -242,7 +242,7 @@ STAGE PLANS: outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 3 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: round(_col0, (- 1)) (type: decimal(11,0)) + key expressions: round(_col0, -1) (type: decimal(11,0)) sort order: + Statistics: Num rows: 1 Data size: 3 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: decimal(10,0)) @@ -379,7 +379,7 @@ STAGE PLANS: outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: round(_col0, (- 1)) (type: decimal(11,0)) + key expressions: round(_col0, -1) (type: decimal(11,0)) sort order: + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: decimal(10,0))