diff --git common/src/java/org/apache/hadoop/hive/conf/HiveConf.java common/src/java/org/apache/hadoop/hive/conf/HiveConf.java index 8104e84..d988fba 100644 --- common/src/java/org/apache/hadoop/hive/conf/HiveConf.java +++ common/src/java/org/apache/hadoop/hive/conf/HiveConf.java @@ -986,6 +986,8 @@ HIVE_VECTORIZATION_GROUPBY_MAXENTRIES("hive.vectorized.groupby.maxentries", 1000000), HIVE_VECTORIZATION_GROUPBY_FLUSH_PERCENT("hive.vectorized.groupby.flush.percent", (float) 0.1), + // Constant propagation optimizer + HIVEOPTCONSTANTPROPAGATION("hive.optimize.constant.propagation", true), HIVE_TYPE_CHECK_ON_INSERT("hive.typecheck.on.insert", true), diff --git contrib/src/test/results/clientpositive/udf_example_add.q.out contrib/src/test/results/clientpositive/udf_example_add.q.out index 4510ba4..5a2d37a 100644 --- contrib/src/test/results/clientpositive/udf_example_add.q.out +++ contrib/src/test/results/clientpositive/udf_example_add.q.out @@ -36,7 +36,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: example_add(1, 2) (type: int), example_add(1, 2, 3) (type: int), example_add(1, 2, 3, 4) (type: int), example_add(1.1, 2.2) (type: double), example_add(1.1, 2.2, 3.3) (type: double), example_add(1.1, 2.2, 3.3, 4.4) (type: double), example_add(1, 2, 3, 4.4) (type: double) + expressions: 3 (type: int), 6 (type: int), 10 (type: int), 3.3000000000000003 (type: double), 6.6 (type: double), 11.0 (type: double), 10.4 (type: double) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit diff --git contrib/src/test/results/clientpositive/udf_example_format.q.out contrib/src/test/results/clientpositive/udf_example_format.q.out index 83e508a..24e3670 100644 --- contrib/src/test/results/clientpositive/udf_example_format.q.out +++ contrib/src/test/results/clientpositive/udf_example_format.q.out @@ -30,7 +30,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: example_format('abc') (type: string), example_format('%1$s', 1.1) (type: string), example_format('%1$s %2$e', 1.1, 1.2) (type: string), example_format('%1$x %2$o %3$d', 10, 10, 10) (type: string) + expressions: 'abc' (type: string), '1.1' (type: string), '1.1 1.200000e+00' (type: string), 'a 12 10' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/ColumnInfo.java ql/src/java/org/apache/hadoop/hive/ql/exec/ColumnInfo.java index feb8558..e40da12 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/ColumnInfo.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/ColumnInfo.java @@ -220,4 +220,8 @@ public boolean equals(Object obj) { return true; } + + public void setObjectinspector(ObjectInspector writableObjectInspector) { + this.objectInspector = writableObjectInspector; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/ExprNodeEvaluator.java ql/src/java/org/apache/hadoop/hive/ql/exec/ExprNodeEvaluator.java index 5cd9bde..dc5f5bc 100755 --- ql/src/java/org/apache/hadoop/hive/ql/exec/ExprNodeEvaluator.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/ExprNodeEvaluator.java @@ -104,4 +104,9 @@ public boolean isStateful() { public ExprNodeEvaluator[] getChildren() { return null; } + + @Override + public String toString() { + return "ExprNodeEvaluator[" + expr + "]"; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/ColumnPrunerProcFactory.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/ColumnPrunerProcFactory.java index 2a8fb2b..78f36ef 100644 --- ql/src/java/org/apache/hadoop/hive/ql/optimizer/ColumnPrunerProcFactory.java +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/ColumnPrunerProcFactory.java @@ -54,8 +54,10 @@ import org.apache.hadoop.hive.ql.parse.SemanticException; import org.apache.hadoop.hive.ql.plan.AggregationDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeDescUtils; +import org.apache.hadoop.hive.ql.plan.ExprNodeNullDesc; import org.apache.hadoop.hive.ql.plan.GroupByDesc; import org.apache.hadoop.hive.ql.plan.JoinDesc; import org.apache.hadoop.hive.ql.plan.MapJoinDesc; @@ -693,6 +695,12 @@ private static void pruneReduceSinkOperator(boolean[] retainFlags, nm = oldRR.reverseLookup(outputCol); } + // In case there are multiple columns referenced to the same column name, we won't + // do row resolve once more because the ColumnInfo in row resolver is already removed + if (nm == null) { + continue; + } + // Only remove information of a column if it is not a key, // i.e. this column is not appearing in keyExprs of the RS if (ExprNodeDescUtils.indexOf(outputColExpr, keyExprs) == -1) { @@ -823,16 +831,17 @@ private static void pruneJoinOperator(NodeProcessorCtx ctx, List> childOperators = op .getChildOperators(); + LOG.info("JOIN " + op.getIdentifier() + " oldExprs: " + conf.getExprs()); List childColLists = cppCtx.genColLists(op); if (childColLists == null) { return; } - Map> prunedColLists = new HashMap>(); - for (byte tag : conf.getTagOrder()) { - prunedColLists.put(tag, new ArrayList()); - } + Map> prunedColLists = new HashMap>(); + for (byte tag : conf.getTagOrder()) { + prunedColLists.put(tag, new ArrayList()); + } //add the columns in join filters Set>> filters = @@ -930,6 +939,7 @@ private static void pruneJoinOperator(NodeProcessorCtx ctx, rs.add(col); } + LOG.info("JOIN " + op.getIdentifier() + " newExprs: " + conf.getExprs()); op.setColumnExprMap(newColExprMap); conf.setOutputColumnNames(outputCols); op.getSchema().setSignature(rs); diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagate.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagate.java new file mode 100644 index 0000000..a10e49c --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagate.java @@ -0,0 +1,174 @@ +/** + * 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; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.hive.conf.HiveConf.ConfVars; +import org.apache.hadoop.hive.ql.exec.FileSinkOperator; +import org.apache.hadoop.hive.ql.exec.FilterOperator; +import org.apache.hadoop.hive.ql.exec.GroupByOperator; +import org.apache.hadoop.hive.ql.exec.JoinOperator; +import org.apache.hadoop.hive.ql.exec.Operator; +import org.apache.hadoop.hive.ql.exec.ReduceSinkOperator; +import org.apache.hadoop.hive.ql.exec.ScriptOperator; +import org.apache.hadoop.hive.ql.exec.SelectOperator; +import org.apache.hadoop.hive.ql.exec.TableScanOperator; +import org.apache.hadoop.hive.ql.exec.UnionOperator; +import org.apache.hadoop.hive.ql.lib.DefaultGraphWalker; +import org.apache.hadoop.hive.ql.lib.DefaultRuleDispatcher; +import org.apache.hadoop.hive.ql.lib.Dispatcher; +import org.apache.hadoop.hive.ql.lib.GraphWalker; +import org.apache.hadoop.hive.ql.lib.Node; +import org.apache.hadoop.hive.ql.lib.NodeProcessor; +import org.apache.hadoop.hive.ql.lib.Rule; +import org.apache.hadoop.hive.ql.lib.RuleRegExp; +import org.apache.hadoop.hive.ql.parse.OpParseContext; +import org.apache.hadoop.hive.ql.parse.ParseContext; +import org.apache.hadoop.hive.ql.parse.SemanticException; +import org.apache.hadoop.hive.ql.plan.OperatorDesc; + +/** + * Implementation of one of the rule-based optimization steps. ConstantPropagate traverse the DAG + * from root to child. For each conditional expression, process as follows: + * + * 1. Fold constant expression: if the expression is a UDF and all parameters are constant. + * + * 2. Shortcut expression: if the expression is a logical operator and it can be shortcut by + * some constants of its parameters. + * + * 3. Propagate expression: if the expression is an assignment like column=constant, the expression + * will be propagate to parents to see if further folding operation is possible. + */ +public class ConstantPropagate implements Transform { + + private static final Log LOG = LogFactory.getLog(ConstantPropagate.class); + protected ParseContext pGraphContext; + private Map, OpParseContext> opToParseCtxMap; + + public ConstantPropagate() {} + + /** + * Transform the query tree. + * + * @param pactx + * the current parse context + */ + @Override + public ParseContext transform(ParseContext pactx) throws SemanticException { + if (pactx.getConf().getBoolVar(ConfVars.HIVE_VECTORIZATION_ENABLED)) { + // Constant propagate is currently conflict with vectorizer, disabling constant propagate + // if the later is enabled. + return pactx; + } + if (pactx.getConf().getBoolVar(ConfVars.HIVEOPTINDEXFILTER)) { + return pactx; + } + pGraphContext = pactx; + opToParseCtxMap = pGraphContext.getOpParseCtx(); + + // generate pruned column list for all relevant operators + ConstantPropagateProcCtx cppCtx = new ConstantPropagateProcCtx(opToParseCtxMap); + + // create a walker which walks the tree in a DFS manner while maintaining + // the operator stack. The dispatcher + // generates the plan from the operator tree + Map opRules = new LinkedHashMap(); + + opRules.put(new RuleRegExp("R1", FilterOperator.getOperatorName() + "%"), + ConstantPropagateProcFactory.getFilterProc()); + opRules.put(new RuleRegExp("R2", GroupByOperator.getOperatorName() + "%"), + ConstantPropagateProcFactory.getGroupByProc()); + opRules.put(new RuleRegExp("R3", SelectOperator.getOperatorName() + "%"), + ConstantPropagateProcFactory.getSelectProc()); + opRules.put(new RuleRegExp("R4", FileSinkOperator.getOperatorName() + "%"), + ConstantPropagateProcFactory.getFileSinkProc()); + opRules.put(new RuleRegExp("R5", ReduceSinkOperator.getOperatorName() + "%"), + ConstantPropagateProcFactory.getReduceSinkProc()); + opRules.put(new RuleRegExp("R6", JoinOperator.getOperatorName() + "%"), + ConstantPropagateProcFactory.getJoinProc()); + opRules.put(new RuleRegExp("R7", TableScanOperator.getOperatorName() + "%"), + ConstantPropagateProcFactory.getTableScanProc()); + opRules.put(new RuleRegExp("R8", ScriptOperator.getOperatorName() + "%"), + ConstantPropagateProcFactory.getStopProc()); + + // The dispatcher fires the processor corresponding to the closest matching + // rule and passes the context along + Dispatcher disp = new DefaultRuleDispatcher(ConstantPropagateProcFactory + .getDefaultProc(), opRules, cppCtx); + GraphWalker ogw = new ConstantPropagateWalker(disp); + + // Create a list of operator nodes to start the walking. + ArrayList topNodes = new ArrayList(); + topNodes.addAll(pGraphContext.getTopOps().values()); + ogw.startWalking(topNodes, null); + for (Operator opToDelete : cppCtx.getOpToDelete()) { + if (opToDelete.getParentOperators() == null || opToDelete.getParentOperators().size() != 1) { + throw new RuntimeException("Error pruning operator " + opToDelete + + ". It should have only 1 parent."); + } + opToDelete.getParentOperators().get(0).removeChildAndAdoptItsChildren(opToDelete); + } + return pGraphContext; + } + + + /** + * Walks the op tree in root first order. + */ + public static class ConstantPropagateWalker extends DefaultGraphWalker { + + public ConstantPropagateWalker(Dispatcher disp) { + super(disp); + } + + @Override + public void walk(Node nd) throws SemanticException { + + List parents = ((Operator) nd).getParentOperators(); + if ((parents == null) + || getDispatchedList().containsAll(parents)) { + opStack.push(nd); + + // all children are done or no need to walk the children + dispatch(nd, opStack); + opStack.pop(); + } else { + getToWalk().removeAll(parents); + getToWalk().add(0, nd); + getToWalk().addAll(0, parents); + return; + } + + // move all the children to the front of queue + List children = nd.getChildren(); + if (children != null) { + getToWalk().removeAll(children); + getToWalk().addAll(children); + } + } + } + +} diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcCtx.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcCtx.java new file mode 100644 index 0000000..62b5e6b --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcCtx.java @@ -0,0 +1,203 @@ +/** + * 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; + + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.hive.ql.exec.ColumnInfo; +import org.apache.hadoop.hive.ql.exec.Operator; +import org.apache.hadoop.hive.ql.exec.UnionOperator; +import org.apache.hadoop.hive.ql.lib.NodeProcessorCtx; +import org.apache.hadoop.hive.ql.parse.OpParseContext; +import org.apache.hadoop.hive.ql.parse.RowResolver; +import org.apache.hadoop.hive.ql.parse.SemanticException; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.OperatorDesc; + +/** + * This class implements the processor context for Constant Propagate. + * + * ConstantPropagateProcCtx keeps track of propagated constants in a column->const map for each + * operator, enabling constants to be revolved across operators. + */ +public class ConstantPropagateProcCtx implements NodeProcessorCtx { + + private static final org.apache.commons.logging.Log LOG = LogFactory + .getLog(ConstantPropagateProcCtx.class); + + private final Map, Map> opToConstantExprs; + private final Map, OpParseContext> opToParseCtx; + private final List> opToDelete; + + public ConstantPropagateProcCtx(Map, OpParseContext> opToParseCtx) { + opToConstantExprs = + new HashMap, Map>(); + opToDelete = new ArrayList>(); + this.opToParseCtx = opToParseCtx; + } + + public Map, Map> getOpToConstantExprs() { + return opToConstantExprs; + } + + + public Map, OpParseContext> getOpToParseCtxMap() { + return opToParseCtx; + } + + /** + * Resolve a ColumnInfo based on given RowResolver. + * + * @param ci + * @param rr + * @return + * @throws SemanticException + */ + private ColumnInfo resolve(ColumnInfo ci, RowResolver rr) throws SemanticException { + // Resolve new ColumnInfo from + String alias = ci.getAlias(); + if (alias == null) { + alias = ci.getInternalName(); + } + String tblAlias = ci.getTabAlias(); + ColumnInfo rci = rr.get(tblAlias, alias); + if (rci == null) { + if (rr.getRslvMap().size() == 1) { + rci = rr.get(null, alias); + } + if (rci == null) { + return null; + } + } + String[] tmp = rr.reverseLookup(rci.getInternalName()); + rci.setTabAlias(tmp[0]); + rci.setAlias(tmp[1]); + LOG.debug("Resolved " + rci.getTabAlias() + "." + rci.getAlias() + + " from " + ci + " with rr: " + rr); + return rci; + } + + /** + * Get propagated constant map from parents. + * + * Traverse all parents of current operator, if there is propagated constant (determined by + * assignment expression like column=constant value), resolve the column using RowResolver and add + * it to current constant map. + * + * @param op + * operator getting the propagated constants. + * @return map of ColumnInfo to ExprNodeDesc. The values of that map must be either + * ExprNodeConstantDesc or ExprNodeNullDesc. + */ + public Map getPropagatedConstants( + Operator op) { + Map constants = new HashMap(); + OpParseContext parseCtx = opToParseCtx.get(op); + if (parseCtx == null) { + return constants; + } + RowResolver rr = parseCtx.getRowResolver(); + LOG.debug("Current rr of op:" + op + " is " + rr); + try { + if (op.getParentOperators() == null) { + return constants; + } + + if (op instanceof UnionOperator) { + // find intersection + Map intersection = null; + for (Operator parent : op.getParentOperators()) { + LOG.debug("Constant of op " + parent.getOperatorId() + " " + opToConstantExprs.get(parent)); + if (intersection == null) { + intersection = new HashMap(); + intersection.putAll(opToConstantExprs.get(parent)); + } else { + Iterator> itr = intersection.entrySet().iterator(); + while (itr.hasNext()) { + Entry e = itr.next(); + boolean found = false; + for (Entry f : opToConstantExprs.get(parent).entrySet()) { + if (e.getKey().getInternalName().equals(f.getKey().getInternalName())) { + if (e.getValue().isSame(f.getValue())) { + found = true; + } + break; + } + } + if (!found) { + itr.remove(); + } + } + } + if (intersection.isEmpty()) { + return intersection; + } + } + LOG.debug("Propagated union constants:" + intersection); + return intersection; + } + + for (Operator parent : op.getParentOperators()) { + Map c = opToConstantExprs.get(parent); + for (Entry e : c.entrySet()) { + ColumnInfo ci = e.getKey(); + ExprNodeDesc constant = e.getValue(); + + ColumnInfo rci = resolve(ci, rr); + if (rci != null) { + constants.put(rci, constant); + } else { + LOG.debug("Can't resolve " + ci.getTabAlias() + "." + ci.getAlias() + " from rr:" + rr); + } + } + + } + LOG.debug("Offerring constants " + constants.keySet() + + " to operator " + op.toString()); + return constants; + } catch (SemanticException e) { + LOG.error(e.getMessage(), e); + throw new RuntimeException(e); + } + } + + public RowResolver getRowResolver(Operator op) { + OpParseContext parseCtx = opToParseCtx.get(op); + if (parseCtx == null) { + return null; + } + return parseCtx.getRowResolver(); + } + + public void addOpToDelete(Operator op) { + opToDelete.add(op); + } + + public List> getOpToDelete() { + return opToDelete; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcFactory.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcFactory.java new file mode 100644 index 0000000..f028dc6 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcFactory.java @@ -0,0 +1,962 @@ +/** + * 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; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.Stack; + +import org.apache.commons.lang.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.hive.common.JavaUtils; +import org.apache.hadoop.hive.ql.exec.ColumnInfo; +import org.apache.hadoop.hive.ql.exec.FileSinkOperator; +import org.apache.hadoop.hive.ql.exec.FilterOperator; +import org.apache.hadoop.hive.ql.exec.GroupByOperator; +import org.apache.hadoop.hive.ql.exec.JoinOperator; +import org.apache.hadoop.hive.ql.exec.Operator; +import org.apache.hadoop.hive.ql.exec.ReduceSinkOperator; +import org.apache.hadoop.hive.ql.exec.RowSchema; +import org.apache.hadoop.hive.ql.exec.SelectOperator; +import org.apache.hadoop.hive.ql.exec.TableScanOperator; +import org.apache.hadoop.hive.ql.exec.UDF; +import org.apache.hadoop.hive.ql.lib.Node; +import org.apache.hadoop.hive.ql.lib.NodeProcessor; +import org.apache.hadoop.hive.ql.lib.NodeProcessorCtx; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.parse.RowResolver; +import org.apache.hadoop.hive.ql.parse.SemanticException; +import org.apache.hadoop.hive.ql.plan.DynamicPartitionCtx; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +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.apache.hadoop.hive.ql.plan.ExprNodeNullDesc; +import org.apache.hadoop.hive.ql.plan.FileSinkDesc; +import org.apache.hadoop.hive.ql.plan.GroupByDesc; +import org.apache.hadoop.hive.ql.plan.JoinCondDesc; +import org.apache.hadoop.hive.ql.plan.JoinDesc; +import org.apache.hadoop.hive.ql.plan.PlanUtils; +import org.apache.hadoop.hive.ql.plan.ReduceSinkDesc; +import org.apache.hadoop.hive.ql.plan.TableScanDesc; +import org.apache.hadoop.hive.ql.udf.UDFType; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF.DeferredJavaObject; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBridge; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPAnd; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqual; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNull; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPOr; +import org.apache.hadoop.hive.serde.serdeConstants; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorConverters; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorConverters.Converter; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorUtils; +import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils; +import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils; + +import com.google.common.collect.ImmutableSet; + +/** + * Factory for generating the different node processors used by ConstantPropagate. + */ +public final class ConstantPropagateProcFactory { + protected static final Log LOG = LogFactory.getLog(ConstantPropagateProcFactory.class.getName()); + protected static Set> propagatableUdfs = new HashSet>(); + + static { + propagatableUdfs.add(GenericUDFOPAnd.class); + }; + + private ConstantPropagateProcFactory() { + // prevent instantiation + } + + /** + * Get ColumnInfo from column expression. + * + * @param rr + * @param desc + * @return + */ + public static ColumnInfo resolveColumn(RowResolver rr, + ExprNodeColumnDesc desc) { + try { + ColumnInfo ci = rr.get(desc.getTabAlias(), desc.getColumn()); + if (ci == null) { + String[] tmp = rr.reverseLookup(desc.getColumn()); + if (tmp == null) { + return null; + } + ci = rr.get(tmp[0], tmp[1]); + ci.setTabAlias(tmp[0]); + ci.setAlias(tmp[1]); + } else { + String[] tmp = rr.reverseLookup(ci.getInternalName()); + if (tmp == null) { + return null; + } + ci.setTabAlias(tmp[0]); + ci.setAlias(tmp[1]); + } + return ci; + } catch (SemanticException e) { + throw new RuntimeException(e); + } + } + + private static final Set unSupportedTypes = ImmutableSet + .builder() + .add(PrimitiveCategory.DECIMAL) + .add(PrimitiveCategory.VARCHAR) + .add(PrimitiveCategory.CHAR).build(); + + /** + * Cast type from expression type to expected type ti. + * + * @param desc constant expression + * @param ti expected type info + * @return cast constant, or null if the type cast failed. + */ + private static ExprNodeConstantDesc typeCast(ExprNodeDesc desc, TypeInfo ti) { + if (desc instanceof ExprNodeNullDesc) { + return null; + } + if (!(ti instanceof PrimitiveTypeInfo) || !(desc.getTypeInfo() instanceof PrimitiveTypeInfo)) { + return null; + } + + PrimitiveTypeInfo priti = (PrimitiveTypeInfo) ti; + PrimitiveTypeInfo descti = (PrimitiveTypeInfo) desc.getTypeInfo(); + + if (unSupportedTypes.contains(priti.getPrimitiveCategory()) + || unSupportedTypes.contains(descti.getPrimitiveCategory())) { + // FIXME: support template types. It currently has conflict with + // ExprNodeConstantDesc + return null; + } + LOG.debug("Casting " + desc + " to type " + ti); + ExprNodeConstantDesc c = (ExprNodeConstantDesc) desc; + ObjectInspector origOI = + TypeInfoUtils.getStandardJavaObjectInspectorFromTypeInfo(desc.getTypeInfo()); + ObjectInspector oi = + TypeInfoUtils.getStandardJavaObjectInspectorFromTypeInfo(ti); + Converter converter = ObjectInspectorConverters.getConverter(origOI, oi); + Object convObj = converter.convert(c.getValue()); + + // Convert integer related types because converters are not sufficient + if (convObj instanceof Integer) { + switch (priti.getPrimitiveCategory()) { + case BYTE: + convObj = new Byte((byte) (((Integer) convObj).intValue())); + break; + case SHORT: + convObj = new Short((short) ((Integer) convObj).intValue()); + break; + case LONG: + convObj = new Long(((Integer) convObj).intValue()); + default: + } + } + return new ExprNodeConstantDesc(ti, convObj); + } + + /** + * Fold input expression desc. + * + * If desc is a UDF and all parameters are constants, evaluate it. If desc is a column expression, + * find it from propagated constants, and if there is, replace it with constant. + * + * @param desc folding expression + * @param constants current propagated constant map + * @param cppCtx + * @param op processing operator + * @param propagate if true, assignment expressions will be added to constants. + * @return fold expression + */ + private static ExprNodeDesc foldExpr(ExprNodeDesc desc, Map constants, + ConstantPropagateProcCtx cppCtx, Operator op, int tag, + boolean propagate) { + if (desc instanceof ExprNodeGenericFuncDesc) { + ExprNodeGenericFuncDesc funcDesc = (ExprNodeGenericFuncDesc) desc; + + // The function must be deterministic, or we can't fold it. + GenericUDF udf = funcDesc.getGenericUDF(); + if (!isDeterministicUdf(udf)) { + LOG.debug("Function " + udf.getClass() + " undeterministic, quit folding."); + return desc; + } + + boolean propagateNext = propagate && propagatableUdfs.contains(udf.getClass()); + List newExprs = new ArrayList(); + for (ExprNodeDesc childExpr : desc.getChildren()) { + newExprs.add(foldExpr(childExpr, constants, cppCtx, op, tag, propagateNext)); + } + + // If all child expressions are constants, evaluate UDF immediately + ExprNodeDesc constant = evaluateFunction(udf, newExprs, desc.getChildren()); + if (constant != null) { + LOG.debug("Folding expression:" + desc + " -> " + constant); + return constant; + } else { + + // Check if the function can be short cut. + ExprNodeDesc shortcut = shortcutFunction(udf, newExprs); + if (shortcut != null) { + LOG.debug("Folding expression:" + desc + " -> " + shortcut); + return shortcut; + } + ((ExprNodeGenericFuncDesc) desc).setChildren(newExprs); + } + + // If in some selected binary operators (=, is null, etc), one of the + // expressions are + // constant, add them to colToConstatns as half-deterministic columns. + if (propagate) { + propagate(udf, newExprs, cppCtx.getRowResolver(op), constants); + } + + return desc; + } else if (desc instanceof ExprNodeColumnDesc) { + if (op.getParentOperators() == null || op.getParentOperators().isEmpty()) { + return desc; + } + Operator parent = op.getParentOperators().get(tag); + ExprNodeDesc col = evaluateColumn((ExprNodeColumnDesc) desc, cppCtx, parent); + if (col != null) { + LOG.debug("Folding expression:" + desc + " -> " + col); + return col; + } + } + return desc; + } + + private static boolean isDeterministicUdf(GenericUDF udf) { + UDFType udfType = udf.getClass().getAnnotation(UDFType.class); + if (udf instanceof GenericUDFBridge) { + udfType = ((GenericUDFBridge) udf).getUdfClass().getAnnotation(UDFType.class); + } + if (udfType.deterministic() == false) { + return false; + } + + // If udf is requiring additional jars, we can't determine the result in + // compile time. + String[] files; + String[] jars; + if (udf instanceof GenericUDFBridge) { + GenericUDFBridge bridge = (GenericUDFBridge) udf; + String udfClassName = bridge.getUdfClassName(); + try { + UDF udfInternal = + (UDF) Class.forName(bridge.getUdfClassName(), true, JavaUtils.getClassLoader()) + .newInstance(); + files = udfInternal.getRequiredFiles(); + jars = udf.getRequiredJars(); + } catch (Exception e) { + LOG.error("The UDF implementation class '" + udfClassName + + "' is not present in the class path"); + return false; + } + } else { + files = udf.getRequiredFiles(); + jars = udf.getRequiredJars(); + } + if (files != null || jars != null) { + return false; + } + return true; + } + + /** + * Propagate assignment expression, adding an entry into constant map constants. + * + * @param udf expression UDF, currently only 2 UDFs are supported: '=' and 'is null'. + * @param newExprs child expressions (parameters). + * @param cppCtx + * @param op + * @param constants + */ + private static void propagate(GenericUDF udf, List newExprs, RowResolver rr, + Map constants) { + if (udf instanceof GenericUDFOPEqual) { + ExprNodeDesc lOperand = newExprs.get(0); + ExprNodeDesc rOperand = newExprs.get(1); + ExprNodeColumnDesc c; + ExprNodeConstantDesc v; + if (lOperand instanceof ExprNodeColumnDesc && rOperand instanceof ExprNodeConstantDesc) { + c = (ExprNodeColumnDesc) lOperand; + v = (ExprNodeConstantDesc) rOperand; + } else if (rOperand instanceof ExprNodeColumnDesc && lOperand instanceof ExprNodeConstantDesc) { + c = (ExprNodeColumnDesc) rOperand; + v = (ExprNodeConstantDesc) lOperand; + } else { + return; + } + ColumnInfo ci = resolveColumn(rr, c); + if (ci != null) { + LOG.debug("Filter " + udf + " is identified as a value assignment, propagate it."); + if (!v.getTypeInfo().equals(ci.getType())) { + v = typeCast(v, ci.getType()); + } + if (v != null) { + constants.put(ci, v); + } + } + } else if (udf instanceof GenericUDFOPNull) { + ExprNodeDesc operand = newExprs.get(0); + if (operand instanceof ExprNodeColumnDesc) { + LOG.debug("Filter " + udf + " is identified as a value assignment, propagate it."); + ExprNodeColumnDesc c = (ExprNodeColumnDesc) operand; + ColumnInfo ci = resolveColumn(rr, c); + if (ci != null) { + constants.put(ci, new ExprNodeNullDesc()); + } + } + } + } + + private static ExprNodeDesc shortcutFunction(GenericUDF udf, List newExprs) { + if (udf instanceof GenericUDFOPAnd) { + for (int i = 0; i < 2; i++) { + ExprNodeDesc childExpr = newExprs.get(i); + if (childExpr instanceof ExprNodeConstantDesc) { + ExprNodeConstantDesc c = (ExprNodeConstantDesc) childExpr; + if (c.getValue() == Boolean.TRUE) { + + // if true, prune it + return newExprs.get(Math.abs(i - 1)); + } else { + + // if false return false + return childExpr; + } + } + } + } + + if (udf instanceof GenericUDFOPOr) { + for (int i = 0; i < 2; i++) { + ExprNodeDesc childExpr = newExprs.get(i); + if (childExpr instanceof ExprNodeConstantDesc) { + ExprNodeConstantDesc c = (ExprNodeConstantDesc) childExpr; + if (c.getValue() == Boolean.FALSE) { + + // if false, prune it + return newExprs.get(Math.abs(i - 1)); + } else { + + // if true return true + return childExpr; + } + } + } + } + + return null; + } + + /** + * Evaluate column, replace the deterministic columns with constants if possible + * + * @param desc + * @param ctx + * @param op + * @param colToConstants + * @return + */ + private static ExprNodeDesc evaluateColumn(ExprNodeColumnDesc desc, + ConstantPropagateProcCtx cppCtx, Operator parent) { + try { + ColumnInfo ci = null; + RowResolver rr = cppCtx.getOpToParseCtxMap().get(parent).getRowResolver(); + String[] tmp = rr.reverseLookup(desc.getColumn()); + if (tmp == null) { + LOG.error("Reverse look up of column " + desc + " error!"); + return null; + } + ci = rr.get(tmp[0], tmp[1]); + if (ci != null) { + ExprNodeDesc constant = null; + // Additional work for union operator, see union27.q + if (ci.getAlias() == null) { + for (Entry e : cppCtx.getOpToConstantExprs().get(parent).entrySet()) { + if (e.getKey().getInternalName().equals(ci.getInternalName())) { + constant = e.getValue(); + break; + } + } + } else { + constant = cppCtx.getOpToConstantExprs().get(parent).get(ci); + } + if (constant != null) { + if (constant instanceof ExprNodeConstantDesc + && !constant.getTypeInfo().equals(desc.getTypeInfo())) { + return typeCast(constant, desc.getTypeInfo()); + } + return constant; + } else { + return null; + } + } + LOG.error("Can't resolve " + desc.getTabAlias() + "." + desc.getColumn()); + throw new RuntimeException("Can't resolve " + desc.getTabAlias() + "." + desc.getColumn()); + } catch (SemanticException e) { + throw new RuntimeException(e); + } + + } + + /** + * Evaluate UDF + * + * @param udf UDF object + * @param exprs + * @param oldExprs + * @return null if expression cannot be evaluated (not all parameters are constants). Or evaluated + * ExprNodeConstantDesc if possible. + * @throws HiveException + */ + private static ExprNodeDesc evaluateFunction(GenericUDF udf, List exprs, + List oldExprs) { + DeferredJavaObject[] arguments = new DeferredJavaObject[exprs.size()]; + ObjectInspector[] argois = new ObjectInspector[exprs.size()]; + for (int i = 0; i < exprs.size(); i++) { + ExprNodeDesc desc = exprs.get(i); + if (desc instanceof ExprNodeConstantDesc) { + ExprNodeConstantDesc constant = (ExprNodeConstantDesc) exprs.get(i); + if (!constant.getTypeInfo().equals(oldExprs.get(i).getTypeInfo())) { + constant = typeCast(constant, oldExprs.get(i).getTypeInfo()); + if (constant == null) { + return null; + } + } + Object value = constant.getValue(); + PrimitiveTypeInfo pti = (PrimitiveTypeInfo) constant.getTypeInfo(); + Object writableValue = + PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector(pti) + .getPrimitiveWritableObject(value); + arguments[i] = new DeferredJavaObject(writableValue); + argois[i] = + ObjectInspectorUtils.getConstantObjectInspector(constant.getWritableObjectInspector(), + writableValue); + } else if (desc instanceof ExprNodeNullDesc) { + + // FIXME: add null support. + return null; + } else { + return null; + } + } + + try { + ObjectInspector oi = udf.initialize(argois); + Object o = udf.evaluate(arguments); + LOG.debug(udf.getClass().getName() + "(" + exprs + ")=" + o); + if (o == null) { + return new ExprNodeNullDesc(); + } + Class clz = o.getClass(); + if (PrimitiveObjectInspectorUtils.isPrimitiveWritableClass(clz)) { + PrimitiveObjectInspector poi = (PrimitiveObjectInspector) oi; + TypeInfo typeInfo = poi.getTypeInfo(); + + // Handling parameterized types (varchar, decimal, etc). + if (typeInfo.getTypeName().contains(serdeConstants.DECIMAL_TYPE_NAME) + || typeInfo.getTypeName().contains(serdeConstants.VARCHAR_TYPE_NAME) + || typeInfo.getTypeName().contains(serdeConstants.CHAR_TYPE_NAME)) { + + // Do not support parameterized types. + return null; + } + o = poi.getPrimitiveJavaObject(o); + } else if (PrimitiveObjectInspectorUtils.isPrimitiveJavaClass(clz)) { + + } else { + LOG.error("Unable to evaluate " + udf + ". Return value unrecoginizable."); + return null; + } + return new ExprNodeConstantDesc(o); + } catch (HiveException e) { + LOG.error("Evaluation function " + udf.getClass() + + " failed in Constant Propagatation Optimizer."); + throw new RuntimeException(e); + } + } + + /** + * Change operator row schema, replace column with constant if it is. + * + * @param op + * @param constants + * @throws SemanticException + */ + private static void foldOperator(Operator op, + ConstantPropagateProcCtx cppCtx) throws SemanticException { + RowSchema schema = op.getSchema(); + Map constants = cppCtx.getOpToConstantExprs().get(op); + if (schema != null && schema.getSignature() != null) { + for (ColumnInfo col : schema.getSignature()) { + ExprNodeDesc constant = constants.get(col); + if (constant != null) { + LOG.debug("Replacing column " + col + " with constant " + constant + " in " + op); + if (!col.getType().equals(constant.getTypeInfo())) { + constant = typeCast(constant, col.getType()); + } + if (constant != null) { + col.setObjectinspector(constant.getWritableObjectInspector()); + } + } + } + } + + Map colExprMap = op.getColumnExprMap(); + if (colExprMap != null) { + for (Entry e : constants.entrySet()) { + String internalName = e.getKey().getInternalName(); + if (colExprMap.containsKey(internalName)) { + colExprMap.put(internalName, e.getValue()); + } + } + } + } + + /** + * Node Processor for Constant Propagation on Filter Operators. The processor is to fold + * conditional expressions and extract assignment expressions and propagate them. + */ + public static class ConstantPropagateFilterProc implements NodeProcessor { + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, Object... nodeOutputs) + throws SemanticException { + FilterOperator op = (FilterOperator) nd; + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + Map constants = cppCtx.getPropagatedConstants(op); + cppCtx.getOpToConstantExprs().put(op, constants); + + ExprNodeDesc condn = op.getConf().getPredicate(); + LOG.debug("Old filter FIL[" + op.getIdentifier() + "] conditions:" + condn.getExprString()); + ExprNodeDesc newCondn = foldExpr(condn, constants, cppCtx, op, 0, true); +// // Try propagate constant in the condition expression if chained constants can be +// // folded, e.g., col1=col2 and col1=3. +// int numOldConst = 0; +// while (numOldConst < constants.size()) { +// numOldConst = constants.size(); +// foldExpr(newCondn, constants, cppCtx, op, 0, true); +// } + if (newCondn instanceof ExprNodeConstantDesc) { + ExprNodeConstantDesc c = (ExprNodeConstantDesc) newCondn; + if (c.getValue() == Boolean.TRUE) { + cppCtx.addOpToDelete(op); + LOG.debug("Filter expression " + condn + " holds true. Will delete it."); + } else if (c.getValue() == Boolean.FALSE) { + LOG.warn("Filter expression " + condn + " holds false!"); + } + } + LOG.debug("New filter FIL[" + op.getIdentifier() + "] conditions:" + condn.getExprString()); + + // merge it with the downstream col list + op.getConf().setPredicate(newCondn); + foldOperator(op, cppCtx); + return null; + } + + } + + /** + * Factory method to get the ConstantPropagateFilterProc class. + * + * @return ConstantPropagateFilterProc + */ + public static ConstantPropagateFilterProc getFilterProc() { + return new ConstantPropagateFilterProc(); + } + + /** + * Node Processor for Constant Propagate for Group By Operators. + */ + public static class ConstantPropagateGroupByProc implements NodeProcessor { + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, Object... nodeOutputs) + throws SemanticException { + GroupByOperator op = (GroupByOperator) nd; + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + Map colToConstants = cppCtx.getPropagatedConstants(op); + cppCtx.getOpToConstantExprs().put(op, colToConstants); + + if (colToConstants.isEmpty()) { + return null; + } + + GroupByDesc conf = op.getConf(); + ArrayList keys = conf.getKeys(); + for (int i = 0; i < keys.size(); i++) { + ExprNodeDesc key = keys.get(i); + ExprNodeDesc newkey = foldExpr(key, colToConstants, cppCtx, op, 0, false); + keys.set(i, newkey); + } + foldOperator(op, cppCtx); + return null; + } + } + + /** + * Factory method to get the ConstantPropagateGroupByProc class. + * + * @return ConstantPropagateGroupByProc + */ + public static ConstantPropagateGroupByProc getGroupByProc() { + return new ConstantPropagateGroupByProc(); + } + + /** + * The Default Node Processor for Constant Propagation. + */ + public static class ConstantPropagateDefaultProc implements NodeProcessor { + @SuppressWarnings("unchecked") + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, Object... nodeOutputs) + throws SemanticException { + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + Operator op = (Operator) nd; + Map constants = cppCtx.getPropagatedConstants(op); + cppCtx.getOpToConstantExprs().put(op, constants); + if (constants.isEmpty()) { + return null; + } + foldOperator(op, cppCtx); + return null; + } + } + + /** + * Factory method to get the ConstantPropagateDefaultProc class. + * + * @return ConstantPropagateDefaultProc + */ + public static ConstantPropagateDefaultProc getDefaultProc() { + return new ConstantPropagateDefaultProc(); + } + + /** + * The Node Processor for Constant Propagation for Select Operators. + */ + public static class ConstantPropagateSelectProc implements NodeProcessor { + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, Object... nodeOutputs) + throws SemanticException { + SelectOperator op = (SelectOperator) nd; + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + Map constants = cppCtx.getPropagatedConstants(op); + cppCtx.getOpToConstantExprs().put(op, constants); + foldOperator(op, cppCtx); + List colList = op.getConf().getColList(); + if (colList != null) { + for (int i = 0; i < colList.size(); i++) { + ExprNodeDesc newCol = foldExpr(colList.get(i), constants, cppCtx, op, 0, false); + colList.set(i, newCol); + } + LOG.debug("New column list:(" + StringUtils.join(colList, " ") + ")"); + } + return null; + } + } + + /** + * The Factory method to get the ConstantPropagateSelectProc class. + * + * @return ConstantPropagateSelectProc + */ + public static ConstantPropagateSelectProc getSelectProc() { + return new ConstantPropagateSelectProc(); + } + + /** + * The Node Processor for constant propagation for FileSink Operators. In addition to constant + * propagation, this processor also prunes dynamic partitions to static partitions if possible. + */ + public static class ConstantPropagateFileSinkProc implements NodeProcessor { + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, Object... nodeOutputs) + throws SemanticException { + FileSinkOperator op = (FileSinkOperator) nd; + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + Map constants = cppCtx.getPropagatedConstants(op); + cppCtx.getOpToConstantExprs().put(op, constants); + if (constants.isEmpty()) { + return null; + } + FileSinkDesc fsdesc = op.getConf(); + DynamicPartitionCtx dpCtx = fsdesc.getDynPartCtx(); + if (dpCtx != null) { + + // If all dynamic partitions are propagated as constant, remove DP. + Set inputs = dpCtx.getInputToDPCols().keySet(); + + // Assume only 1 parent for FS operator + Operator parent = op.getParentOperators().get(0); + Map parentConstants = cppCtx.getPropagatedConstants(parent); + RowResolver rr = cppCtx.getOpToParseCtxMap().get(parent).getRowResolver(); + boolean allConstant = true; + for (String input : inputs) { + String tmp[] = rr.reverseLookup(input); + ColumnInfo ci = rr.get(tmp[0], tmp[1]); + if (parentConstants.get(ci) == null) { + allConstant = false; + break; + } + } + if (allConstant) { + pruneDP(fsdesc); + } + } + foldOperator(op, cppCtx); + return null; + } + + private void pruneDP(FileSinkDesc fsdesc) { + // FIXME: Support pruning dynamic partitioning. + LOG.info("DP can be rewritten to SP!"); + } + } + + public static NodeProcessor getFileSinkProc() { + return new ConstantPropagateFileSinkProc(); + } + + /** + * The Node Processor for Constant Propagation for Operators which is designed to stop propagate. + * Currently these kinds of Operators include UnionOperator and ScriptOperator. + */ + public static class ConstantPropagateStopProc implements NodeProcessor { + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, Object... nodeOutputs) + throws SemanticException { + Operator op = (Operator) nd; + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + cppCtx.getOpToConstantExprs().put(op, new HashMap()); + LOG.debug("Stop propagate constants on op " + op.getOperatorId()); + return null; + } + } + + public static NodeProcessor getStopProc() { + return new ConstantPropagateStopProc(); + } + + /** + * The Node Processor for Constant Propagation for ReduceSink Operators. If the RS Operator is for + * a join, then only those constants from inner join tables, or from the 'inner side' of a outer + * join (left table for left outer join and vice versa) can be propagated. + */ + public static class ConstantPropagateReduceSinkProc implements NodeProcessor { + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, Object... nodeOutputs) + throws SemanticException { + ReduceSinkOperator op = (ReduceSinkOperator) nd; + ReduceSinkDesc rsDesc = op.getConf(); + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + Map constants = cppCtx.getPropagatedConstants(op); + cppCtx.getOpToConstantExprs().put(op, constants); + if (constants.isEmpty()) { + return null; + } + + if (op.getChildOperators().size() == 1 + && op.getChildOperators().get(0) instanceof JoinOperator) { + JoinOperator joinOp = (JoinOperator) op.getChildOperators().get(0); + if (skipFolding(joinOp.getConf(), rsDesc.getTag())) { + LOG.debug("Skip folding in outer join " + op); + cppCtx.getOpToConstantExprs().put(op, new HashMap()); + return null; + } + } + + if (rsDesc.getDistinctColumnIndices() != null + && !rsDesc.getDistinctColumnIndices().isEmpty()) { + LOG.debug("Skip folding in distinct subqueries " + op); + cppCtx.getOpToConstantExprs().put(op, new HashMap()); + return null; + } + + // key columns + List constantIdxs = new ArrayList(); + for (int i = 0; i < rsDesc.getKeyCols().size(); i++) { + ExprNodeDesc desc = rsDesc.getKeyCols().get(i); + ExprNodeDesc expr = foldExpr(desc, constants, cppCtx, op, 0, false); + if (expr instanceof ExprNodeConstantDesc || expr instanceof ExprNodeNullDesc) { + constantIdxs.add(i); + } + } + for (int i = constantIdxs.size() - 1; i >= 0; i--) { + int removeIdx = constantIdxs.get(i); + rsDesc.getKeyCols().remove(removeIdx); + rsDesc.getOutputKeyColumnNames().remove(removeIdx); + } + if (!constantIdxs.isEmpty()) { + rsDesc.setNumDistributionKeys(rsDesc.getNumDistributionKeys() - constantIdxs.size()); + rsDesc.setKeySerializeInfo(PlanUtils.getReduceKeyTableDesc( + PlanUtils + .getFieldSchemasFromColumnList( + rsDesc.getKeyCols(), rsDesc.getOutputKeyColumnNames(), 0, ""), + rsDesc.getOrder())); + } + + // partition columns + ArrayList newPartExprs = new ArrayList(); + for (ExprNodeDesc desc : rsDesc.getPartitionCols()) { + newPartExprs.add(foldExpr(desc, constants, cppCtx, op, 0, false)); + } + rsDesc.setPartitionCols(newPartExprs); + + // value columns + ArrayList newValExprs = new ArrayList(); + for (ExprNodeDesc desc : rsDesc.getValueCols()) { + newValExprs.add(foldExpr(desc, constants, cppCtx, op, 0, false)); + } + rsDesc.setValueCols(newValExprs); + foldOperator(op, cppCtx); + return null; + } + + private boolean skipFolding(JoinDesc joinDesc, int tag) { + JoinCondDesc[] conds = joinDesc.getConds(); + int i; + for (i = conds.length - 1; i >= 0; i--) { + if (conds[i].getType() == JoinDesc.INNER_JOIN) { + if (tag == i + 1) + return false; + } else if (conds[i].getType() == JoinDesc.FULL_OUTER_JOIN) { + return true; + } else if (conds[i].getType() == JoinDesc.RIGHT_OUTER_JOIN) { + if (tag == i + 1) + return false; + return true; + } else if (conds[i].getType() == JoinDesc.LEFT_OUTER_JOIN) { + if (tag == i + 1) + return true; + } + } + if (tag == 0) { + return false; + } + return true; + } + + } + + public static NodeProcessor getReduceSinkProc() { + return new ConstantPropagateReduceSinkProc(); + } + + /** + * The Node Processor for Constant Propagation for Join Operators. + */ + public static class ConstantPropagateJoinProc implements NodeProcessor { + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, Object... nodeOutputs) + throws SemanticException { + JoinOperator op = (JoinOperator) nd; + JoinDesc conf = op.getConf(); + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + Map constants = cppCtx.getPropagatedConstants(op); + cppCtx.getOpToConstantExprs().put(op, constants); + if (constants.isEmpty()) { + return null; + } + + // Note: the following code (removing folded constants in exprs) is deeply coupled with + // ColumnPruner optimizer. + // Assuming ColumnPrunner will remove constant columns so we don't deal with output columns. + // Except one case that the join operator is followed by a redistribution (RS operator). + if (op.getChildOperators().size() == 1 + && op.getChildOperators().get(0) instanceof ReduceSinkOperator) { + LOG.debug("Skip JOIN-RS structure."); + return null; + } + LOG.info("Old exprs " + conf.getExprs()); + Iterator>> itr = conf.getExprs().entrySet().iterator(); + while (itr.hasNext()) { + Entry> e = itr.next(); + int tag = e.getKey(); + List exprs = e.getValue(); + if (exprs == null) { + continue; + } + List newExprs = new ArrayList(); + for (ExprNodeDesc expr : exprs) { + ExprNodeDesc newExpr = foldExpr(expr, constants, cppCtx, op, tag, false); + if (newExpr instanceof ExprNodeConstantDesc || newExpr instanceof ExprNodeNullDesc) { + LOG.info("expr " + newExpr + " fold from " + expr + " is removed."); + continue; + } + newExprs.add(newExpr); + } + e.setValue(newExprs); + } + LOG.info("New exprs " + conf.getExprs()); + + for (List v : conf.getFilters().values()) { + for (int i = 0; i < v.size(); i++) { + ExprNodeDesc expr = foldExpr(v.get(i), constants, cppCtx, op, 0, false); + v.set(i, expr); + } + } + foldOperator(op, cppCtx); + return null; + } + + } + + public static NodeProcessor getJoinProc() { + return new ConstantPropagateJoinProc(); + } + + /** + * The Node Processor for Constant Propagation for Table Scan Operators. + */ + public static class ConstantPropagateTableScanProc implements NodeProcessor { + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, Object... nodeOutputs) + throws SemanticException { + TableScanOperator op = (TableScanOperator) nd; + TableScanDesc conf = op.getConf(); + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + Map constants = cppCtx.getPropagatedConstants(op); + cppCtx.getOpToConstantExprs().put(op, constants); + ExprNodeGenericFuncDesc pred = conf.getFilterExpr(); + if (pred == null) { + return null; + } + + List newChildren = new ArrayList(); + for (ExprNodeDesc expr : pred.getChildren()) { + ExprNodeDesc constant = foldExpr(expr, constants, cppCtx, op, 0, false); + newChildren.add(constant); + } + pred.setChildren(newChildren); + return null; + } + } + + public static NodeProcessor getTableScanProc() { + return new ConstantPropagateTableScanProc(); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/Optimizer.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/Optimizer.java index a93e178..69d83fe 100644 --- ql/src/java/org/apache/hadoop/hive/ql/optimizer/Optimizer.java +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/Optimizer.java @@ -62,13 +62,19 @@ public void initialize(HiveConf hiveConf) { /* Add list bucketing pruner. */ transformations.add(new ListBucketingPruner()); } + if (HiveConf.getBoolVar(hiveConf, + HiveConf.ConfVars.HIVEOPTCONSTANTPROPAGATION)) { + transformations.add(new ConstantPropagate()); + } } - if (HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVEOPTGROUPBY) || - HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVE_MAP_GROUPBY_SORT)) { + if (HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVEOPTGROUPBY) + || HiveConf.getBoolVar(hiveConf, + HiveConf.ConfVars.HIVE_MAP_GROUPBY_SORT)) { transformations.add(new GroupByOptimizer()); } transformations.add(new ColumnPruner()); - if (HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVE_OPTIMIZE_SKEWJOIN_COMPILETIME)) { + if (HiveConf.getBoolVar(hiveConf, + HiveConf.ConfVars.HIVE_OPTIMIZE_SKEWJOIN_COMPILETIME)) { transformations.add(new SkewJoinOptimizer()); } if (HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVEOPTGBYUSINGINDEX)) { diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeConstantDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeConstantDesc.java index 1ba6c2e..0826a53 100755 --- ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeConstantDesc.java +++ ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeConstantDesc.java @@ -34,6 +34,8 @@ */ public class ExprNodeConstantDesc extends ExprNodeDesc implements Serializable { private static final long serialVersionUID = 1L; + final protected transient static char[] hexArray = "0123456789ABCDEF".toCharArray(); + private Object value; public ExprNodeConstantDesc() { @@ -83,6 +85,15 @@ public String getExprString() { if (typeInfo.getTypeName().equals(serdeConstants.STRING_TYPE_NAME)) { return "'" + value.toString() + "'"; + } else if (typeInfo.getTypeName().equals(serdeConstants.BINARY_TYPE_NAME)) { + byte[] bytes = (byte[]) value; + char[] hexChars = new char[bytes.length * 2]; + for ( int j = 0; j < bytes.length; j++ ) { + int v = bytes[j] & 0xFF; + hexChars[j * 2] = hexArray[v >>> 4]; + hexChars[j * 2 + 1] = hexArray[v & 0x0F]; + } + return new String(hexChars); } else { return value.toString(); } diff --git ql/src/java/org/apache/hadoop/hive/ql/stats/StatsUtils.java ql/src/java/org/apache/hadoop/hive/ql/stats/StatsUtils.java index faa2387..1aab06f 100644 --- ql/src/java/org/apache/hadoop/hive/ql/stats/StatsUtils.java +++ ql/src/java/org/apache/hadoop/hive/ql/stats/StatsUtils.java @@ -255,6 +255,10 @@ public static int estimateRowSizeFromSchema(HiveConf conf, List sche int avgRowSize = 0; for (String neededCol : neededColumns) { ColumnInfo ci = getColumnInfoForColumn(neededCol, schema); + if (ci == null) { + // No need to collect statistics of index columns + continue; + } ObjectInspector oi = ci.getObjectInspector(); String colType = ci.getTypeName(); if (colType.equalsIgnoreCase(serdeConstants.STRING_TYPE_NAME) diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/generic/UDFCurrentDB.java ql/src/java/org/apache/hadoop/hive/ql/udf/generic/UDFCurrentDB.java index a2e0cd7..5f484cf 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/generic/UDFCurrentDB.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/generic/UDFCurrentDB.java @@ -54,7 +54,7 @@ public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumen @Override public Object evaluate(DeferredObject[] arguments) throws HiveException { - throw new IllegalStateException("never"); + return SessionState.get().getCurrentDatabase(); } @Override diff --git ql/src/test/queries/clientpositive/constprog1.q ql/src/test/queries/clientpositive/constprog1.q new file mode 100644 index 0000000..b8adccc --- /dev/null +++ ql/src/test/queries/clientpositive/constprog1.q @@ -0,0 +1,9 @@ +set hive.fetch.task.conversion=more; +set hive.optimize.constant.propagation=true; + +EXPLAIN +SELECT IF(INSTR(CONCAT('foo', 'bar'), 'foob') > 0, "F1", "B1") + FROM src tablesample (1 rows); + +SELECT IF(INSTR(CONCAT('foo', 'bar'), 'foob') > 0, "F1", "B1") + FROM src tablesample (1 rows); diff --git ql/src/test/queries/clientpositive/constprog2.q ql/src/test/queries/clientpositive/constprog2.q new file mode 100644 index 0000000..6cb10a2 --- /dev/null +++ ql/src/test/queries/clientpositive/constprog2.q @@ -0,0 +1,9 @@ +set hive.fetch.task.conversion=more; +set hive.optimize.constant.propagation=true; + +EXPLAIN +SELECT src1.key, src1.key + 1, src2.value + FROM src src1 join src src2 ON src1.key = src2.key AND src1.key = 86; + +SELECT src1.key, src1.key + 1, src2.value + FROM src src1 join src src2 ON src1.key = src2.key AND src1.key = 86; diff --git ql/src/test/queries/clientpositive/constprog_dp.q ql/src/test/queries/clientpositive/constprog_dp.q new file mode 100644 index 0000000..7dad040 --- /dev/null +++ ql/src/test/queries/clientpositive/constprog_dp.q @@ -0,0 +1,11 @@ +set hive.optimize.constant.propagation=true; +set hive.exec.dynamic.partition.mode=nonstrict; + +create table dest(key string, value string) partitioned by (ds string); + +EXPLAIN +from srcpart +insert overwrite table dest partition (ds) select key, value, ds where ds='2008-04-08'; + +from srcpart +insert overwrite table dest partition (ds) select key, value, ds where ds='2008-04-08'; diff --git ql/src/test/queries/clientpositive/constprog_type.q ql/src/test/queries/clientpositive/constprog_type.q new file mode 100644 index 0000000..93249ad --- /dev/null +++ ql/src/test/queries/clientpositive/constprog_type.q @@ -0,0 +1,14 @@ +set hive.optimize.constant.propagation=true; + +CREATE TABLE dest1(d date, t timestamp); + +EXPLAIN +INSERT OVERWRITE TABLE dest1 +SELECT cast('2013-11-17' as date), cast(cast('1.3041352164485E9' as double) as timestamp) + FROM src tablesample (1 rows); + +INSERT OVERWRITE TABLE dest1 +SELECT cast('2013-11-17' as date), cast(cast('1.3041352164485E9' as double) as timestamp) + FROM src tablesample (1 rows); + +SELECT * FROM dest1; diff --git ql/src/test/results/clientpositive/annotate_stats_filter.q.out ql/src/test/results/clientpositive/annotate_stats_filter.q.out index f1175c7..f61235f 100644 --- ql/src/test/results/clientpositive/annotate_stats_filter.q.out +++ ql/src/test/results/clientpositive/annotate_stats_filter.q.out @@ -136,7 +136,7 @@ STAGE PLANS: predicate: (state = 'OH') (type: boolean) Statistics: Num rows: 4 Data size: 398 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: int) + expressions: 'OH' (type: string), locid (type: int), zip (type: bigint), year (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 4 Data size: 398 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -272,7 +272,7 @@ STAGE PLANS: predicate: (state = 'OH') (type: boolean) Statistics: Num rows: 1 Data size: 102 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: int) + expressions: 'OH' (type: string), locid (type: int), zip (type: bigint), year (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 102 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator @@ -652,7 +652,7 @@ STAGE PLANS: predicate: zip is null (type: boolean) Statistics: Num rows: 1 Data size: 102 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: int) + expressions: state (type: string), locid (type: int), null (type: void), year (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 102 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator @@ -1144,103 +1144,22 @@ TOK_QUERY STAGE DEPENDENCIES: - Stage-1 is a root stage - Stage-0 depends on stages: Stage-1 + Stage-0 is a root stage STAGE PLANS: - Stage: Stage-1 - Map Reduce - Map Operator Tree: - TableScan - alias: loc_orc - Statistics: Num rows: 8 Data size: 796 Basic stats: COMPLETE Column stats: COMPLETE - GatherStats: false - Filter Operator - isSamplingPred: false - predicate: (not false) (type: boolean) - Statistics: Num rows: 8 Data size: 804 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: int) - outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 8 Data size: 804 Basic stats: COMPLETE Column stats: COMPLETE - File Output Operator - compressed: false - GlobalTableId: 0 -#### A masked pattern was here #### - NumFilesPerFileSink: 1 - Statistics: Num rows: 8 Data size: 804 Basic stats: COMPLETE Column stats: COMPLETE -#### 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,_col2,_col3 - columns.types string:int:bigint:int - escape.delim \ - hive.serialization.extend.nesting.levels true - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - TotalFiles: 1 - GatherStats: false - MultiFileSpray: false - Path -> Alias: -#### A masked pattern was here #### - Path -> Partition: -#### A masked pattern was here #### - Partition - base file name: loc_orc - input format: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat - output format: org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat - properties: - COLUMN_STATS_ACCURATE true - bucket_count -1 - columns state,locid,zip,year - columns.comments - columns.types string:int:bigint:int - field.delim | -#### A masked pattern was here #### - name default.loc_orc - numFiles 1 - numRows 8 - rawDataSize 796 - serialization.ddl struct loc_orc { string state, i32 locid, i64 zip, i32 year} - serialization.format | - serialization.lib org.apache.hadoop.hive.ql.io.orc.OrcSerde - totalSize 489 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.ql.io.orc.OrcSerde - - input format: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat - output format: org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat - properties: - COLUMN_STATS_ACCURATE true - bucket_count -1 - columns state,locid,zip,year - columns.comments - columns.types string:int:bigint:int - field.delim | -#### A masked pattern was here #### - name default.loc_orc - numFiles 1 - numRows 8 - rawDataSize 796 - serialization.ddl struct loc_orc { string state, i32 locid, i64 zip, i32 year} - serialization.format | - serialization.lib org.apache.hadoop.hive.ql.io.orc.OrcSerde - totalSize 489 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.ql.io.orc.OrcSerde - name: default.loc_orc - name: default.loc_orc - Truncated Path -> Alias: - /loc_orc [loc_orc] - Stage: Stage-0 Fetch Operator limit: -1 Processor Tree: - ListSink + TableScan + alias: loc_orc + Statistics: Num rows: 8 Data size: 796 Basic stats: COMPLETE Column stats: COMPLETE + GatherStats: false + Select Operator + expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: int) + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 8 Data size: 796 Basic stats: COMPLETE Column stats: COMPLETE + ListSink PREHOOK: query: -- numRows: 0 rawDataSize: 0 explain extended select * from loc_orc where !true @@ -1281,7 +1200,7 @@ STAGE PLANS: GatherStats: false Filter Operator isSamplingPred: false - predicate: (not true) (type: boolean) + predicate: false (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: COMPLETE Select Operator expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: int) @@ -1550,7 +1469,7 @@ STAGE PLANS: predicate: ((year = 2001) and year is null) (type: boolean) Statistics: Num rows: 8 Data size: 804 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: int) + expressions: state (type: string), locid (type: int), zip (type: bigint), null (type: void) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 8 Data size: 804 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator @@ -1686,7 +1605,7 @@ STAGE PLANS: predicate: (((year = 2001) and (state = 'OH')) and (state = 'FL')) (type: boolean) Statistics: Num rows: 1 Data size: 102 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: int) + expressions: 'FL' (type: string), locid (type: int), zip (type: bigint), 2001 (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 102 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator @@ -1962,7 +1881,7 @@ STAGE PLANS: predicate: (((year = 2001) or year is null) and (state = 'CA')) (type: boolean) Statistics: Num rows: 2 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: int) + expressions: 'CA' (type: string), locid (type: int), zip (type: bigint), year (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 2 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator diff --git ql/src/test/results/clientpositive/annotate_stats_part.q.out ql/src/test/results/clientpositive/annotate_stats_part.q.out index 1e35932..b0d0433 100644 --- ql/src/test/results/clientpositive/annotate_stats_part.q.out +++ ql/src/test/results/clientpositive/annotate_stats_part.q.out @@ -965,7 +965,7 @@ STAGE PLANS: predicate: ((year = '2001') and (year = '__HIVE_DEFAULT_PARTITION__')) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: state (type: string), locid (type: int), zip (type: bigint), year (type: string) + expressions: state (type: string), locid (type: int), zip (type: bigint), '__HIVE_DEFAULT_PARTITION__' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE ListSink diff --git ql/src/test/results/clientpositive/annotate_stats_select.q.out ql/src/test/results/clientpositive/annotate_stats_select.q.out index 97e9473..67de532 100644 --- ql/src/test/results/clientpositive/annotate_stats_select.q.out +++ ql/src/test/results/clientpositive/annotate_stats_select.q.out @@ -1699,7 +1699,7 @@ STAGE PLANS: Statistics: Num rows: 2 Data size: 1686 Basic stats: COMPLETE Column stats: COMPLETE GatherStats: false Select Operator - expressions: unbase64('0xe23') (type: binary) + expressions: D317B6 (type: binary) outputColumnNames: _col0 Statistics: Num rows: 2 Data size: 96 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator @@ -1826,7 +1826,7 @@ STAGE PLANS: Statistics: Num rows: 2 Data size: 1686 Basic stats: COMPLETE Column stats: COMPLETE GatherStats: false Select Operator - expressions: UDFToByte('1') (type: tinyint), UDFToShort('20') (type: smallint) + expressions: 1 (type: tinyint), 20 (type: smallint) outputColumnNames: _col0, _col1 Statistics: Num rows: 2 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator @@ -1949,7 +1949,7 @@ STAGE PLANS: Statistics: Num rows: 2 Data size: 1686 Basic stats: COMPLETE Column stats: COMPLETE GatherStats: false Select Operator - expressions: CAST( '1970-12-31 15:59:58.174' AS TIMESTAMP) (type: timestamp) + expressions: 1970-12-31 15:59:58.174 (type: timestamp) outputColumnNames: _col0 Statistics: Num rows: 2 Data size: 80 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator @@ -2072,7 +2072,7 @@ STAGE PLANS: Statistics: Num rows: 2 Data size: 1686 Basic stats: COMPLETE Column stats: COMPLETE GatherStats: false Select Operator - expressions: CAST( '1970-12-31 15:59:58.174' AS DATE) (type: date) + expressions: null (type: void) outputColumnNames: _col0 Statistics: Num rows: 2 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator diff --git ql/src/test/results/clientpositive/archive_excludeHadoop20.q.out ql/src/test/results/clientpositive/archive_excludeHadoop20.q.out index 35cdfb6..18d200e 100644 --- ql/src/test/results/clientpositive/archive_excludeHadoop20.q.out +++ ql/src/test/results/clientpositive/archive_excludeHadoop20.q.out @@ -139,6 +139,7 @@ POSTHOOK: Input: default@tstsrcpart POSTHOOK: Input: default@tstsrcpart@ds=2008-04-08/hr=12 #### A masked pattern was here #### 0 3 +Warning: Shuffle Join JOIN[4][tables = [a, b]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT * FROM tstsrcpart a JOIN tstsrc b ON a.key=b.key WHERE a.ds='2008-04-08' AND a.hr='12' AND a.key='0' PREHOOK: type: QUERY diff --git ql/src/test/results/clientpositive/archive_multi.q.out ql/src/test/results/clientpositive/archive_multi.q.out index 511f2bd..31f9471 100644 --- ql/src/test/results/clientpositive/archive_multi.q.out +++ ql/src/test/results/clientpositive/archive_multi.q.out @@ -141,6 +141,7 @@ POSTHOOK: Input: default@tstsrcpart POSTHOOK: Input: default@tstsrcpart@ds=2008-04-08/hr=12 #### A masked pattern was here #### 0 3 +Warning: Shuffle Join JOIN[4][tables = [a, b]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT * FROM tstsrcpart a JOIN tstsrc b ON a.key=b.key WHERE a.ds='2008-04-08' AND a.hr='12' AND a.key='0' PREHOOK: type: QUERY diff --git ql/src/test/results/clientpositive/auto_join14_hadoop20.q.out ql/src/test/results/clientpositive/auto_join14_hadoop20.q.out index c41eafe..5e404a3 100644 --- ql/src/test/results/clientpositive/auto_join14_hadoop20.q.out +++ ql/src/test/results/clientpositive/auto_join14_hadoop20.q.out @@ -40,7 +40,7 @@ STAGE PLANS: Statistics: Num rows: 19 Data size: 1903 Basic stats: COMPLETE Column stats: NONE HashTable Sink Operator condition expressions: - 0 {key} + 0 1 {value} keys: 0 key (type: string) diff --git ql/src/test/results/clientpositive/auto_join8.q.out ql/src/test/results/clientpositive/auto_join8.q.out index ea52872..3a50eae 100644 --- ql/src/test/results/clientpositive/auto_join8.q.out +++ ql/src/test/results/clientpositive/auto_join8.q.out @@ -96,7 +96,7 @@ STAGE PLANS: predicate: _col2 is null (type: boolean) Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: string), UDFToInteger(_col2) (type: int), _col3 (type: string) + expressions: UDFToInteger(_col0) (type: int), _col1 (type: string), UDFToInteger(null) (type: int), _col3 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/cast1.q.out ql/src/test/results/clientpositive/cast1.q.out index f6b8238..a8c3820 100644 --- ql/src/test/results/clientpositive/cast1.q.out +++ ql/src/test/results/clientpositive/cast1.q.out @@ -27,17 +27,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 86) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: (3 + 2) (type: int), (3.0 + 2) (type: double), (3 + 2.0) (type: double), (3.0 + 2.0) (type: double), ((3 + UDFToInteger(2.0)) + UDFToInteger(UDFToShort(0))) (type: int), UDFToBoolean(1) (type: boolean), UDFToInteger(true) (type: int) + expressions: 5 (type: int), 5.0 (type: double), 5.0 (type: double), 5.0 (type: double), 5 (type: int), true (type: boolean), 1 (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/cluster.q.out ql/src/test/results/clientpositive/cluster.q.out index 6f9b7e3..fbefb70 100644 --- ql/src/test/results/clientpositive/cluster.q.out +++ ql/src/test/results/clientpositive/cluster.q.out @@ -14,28 +14,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 10) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '10' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: '10' (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -72,28 +71,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: '20' (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -130,28 +128,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: '20' (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -188,28 +185,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: '20' (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -246,28 +242,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: '20' (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -304,28 +299,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: '20' (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -362,28 +356,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col1 (type: string) sort order: + Map-reduce partition columns: _col1 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), KEY.reducesinkkey0 (type: string) + expressions: '20' (type: string), KEY.reducesinkkey0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -420,28 +413,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: '20' (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -462,6 +454,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 20 val_20 +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: EXPLAIN SELECT x.key, x.value as v1, y.key FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY v1 PREHOOK: type: QUERY @@ -479,40 +472,36 @@ STAGE PLANS: Map Operator Tree: TableScan alias: y - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} - 1 {KEY.reducesinkkey0} - outputColumnNames: _col0, _col1, _col4 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + 0 {VALUE._col0} + 1 + outputColumnNames: _col1 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + expressions: _col1 (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -528,16 +517,15 @@ STAGE PLANS: key expressions: _col1 (type: string) sort order: + Map-reduce partition columns: _col1 (type: string) - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: string), _col2 (type: string) + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), KEY.reducesinkkey0 (type: string), VALUE._col1 (type: string) + expressions: '20' (type: string), KEY.reducesinkkey0 (type: string), '20' (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -549,6 +537,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT x.key, x.value as v1, y.key FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY v1 PREHOOK: type: QUERY PREHOOK: Input: default@src @@ -558,6 +547,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 20 val_20 20 +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: EXPLAIN SELECT x.key, x.value as v1, y.* FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY v1 PREHOOK: type: QUERY @@ -575,41 +565,37 @@ STAGE PLANS: Map Operator Tree: TableScan alias: y - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: string) TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} - 1 {KEY.reducesinkkey0} {VALUE._col0} - outputColumnNames: _col0, _col1, _col4, _col5 - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + 0 {VALUE._col0} + 1 {VALUE._col0} + outputColumnNames: _col1, _col5 + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string), _col5 (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + expressions: _col1 (type: string), _col5 (type: string) + outputColumnNames: _col1, _col3 + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -625,16 +611,16 @@ STAGE PLANS: key expressions: _col1 (type: string) sort order: + Map-reduce partition columns: _col1 (type: string) - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: string), _col2 (type: string), _col3 (type: string) + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + value expressions: _col3 (type: string) Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), KEY.reducesinkkey0 (type: string), VALUE._col1 (type: string), VALUE._col2 (type: string) + expressions: '20' (type: string), KEY.reducesinkkey0 (type: string), '20' (type: string), VALUE._col2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -646,6 +632,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT x.key, x.value as v1, y.* FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY v1 PREHOOK: type: QUERY PREHOOK: Input: default@src @@ -655,6 +642,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 20 val_20 20 val_20 +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: EXPLAIN SELECT x.key, x.value as v1, y.* FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY x.key PREHOOK: type: QUERY @@ -672,41 +660,37 @@ STAGE PLANS: Map Operator Tree: TableScan alias: y - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: string) TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} - 1 {KEY.reducesinkkey0} {VALUE._col0} - outputColumnNames: _col0, _col1, _col4, _col5 - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + 0 {VALUE._col0} + 1 {VALUE._col0} + outputColumnNames: _col1, _col5 + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string), _col5 (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + expressions: _col1 (type: string), _col5 (type: string) + outputColumnNames: _col1, _col3 + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -719,19 +703,18 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE - value expressions: _col1 (type: string), _col2 (type: string), _col3 (type: string) + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: string), _col3 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col2 (type: string) + expressions: '20' (type: string), VALUE._col0 (type: string), '20' (type: string), VALUE._col2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -743,6 +726,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT x.key, x.value as v1, y.* FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY x.key PREHOOK: type: QUERY PREHOOK: Input: default@src @@ -752,6 +736,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 20 val_20 20 val_20 +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: EXPLAIN SELECT x.key, x.value as v1, y.key as yk FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY key PREHOOK: type: QUERY @@ -769,40 +754,36 @@ STAGE PLANS: Map Operator Tree: TableScan alias: y - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} - 1 {KEY.reducesinkkey0} - outputColumnNames: _col0, _col1, _col4 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + 0 {VALUE._col0} + 1 + outputColumnNames: _col1 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + expressions: _col1 (type: string), '20' (type: string) + outputColumnNames: _col1, _col2 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -815,19 +796,18 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string), _col2 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string), VALUE._col1 (type: string) + expressions: '20' (type: string), VALUE._col0 (type: string), VALUE._col1 (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -839,6 +819,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT x.key, x.value as v1, y.key as yk FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY key PREHOOK: type: QUERY PREHOOK: Input: default@src diff --git ql/src/test/results/clientpositive/column_access_stats.q.out ql/src/test/results/clientpositive/column_access_stats.q.out index b180a9f..4c396cd 100644 --- ql/src/test/results/clientpositive/column_access_stats.q.out +++ ql/src/test/results/clientpositive/column_access_stats.q.out @@ -525,7 +525,6 @@ STAGE PLANS: sort order: + Map-reduce partition columns: key (type: string) Statistics: Num rows: 2 Data size: 6 Basic stats: COMPLETE Column stats: NONE - value expressions: val (type: string) TableScan alias: t1 Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -537,18 +536,17 @@ STAGE PLANS: sort order: + Map-reduce partition columns: key (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: val (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} - 1 {KEY.reducesinkkey0} {VALUE._col0} - outputColumnNames: _col0, _col1, _col4, _col5 + 0 {KEY.reducesinkkey0} + 1 {KEY.reducesinkkey0} + outputColumnNames: _col0, _col4 Statistics: Num rows: 2 Data size: 6 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string), _col5 (type: string) + expressions: _col0 (type: string), '3' (type: string), _col4 (type: string), '3' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 2 Data size: 6 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/constprog1.q.out ql/src/test/results/clientpositive/constprog1.q.out new file mode 100644 index 0000000..78c03e2 --- /dev/null +++ ql/src/test/results/clientpositive/constprog1.q.out @@ -0,0 +1,37 @@ +PREHOOK: query: EXPLAIN +SELECT IF(INSTR(CONCAT('foo', 'bar'), 'foob') > 0, "F1", "B1") + FROM src tablesample (1 rows) +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN +SELECT IF(INSTR(CONCAT('foo', 'bar'), 'foob') > 0, "F1", "B1") + FROM src tablesample (1 rows) +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 + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: 'F1' (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE + ListSink + +PREHOOK: query: SELECT IF(INSTR(CONCAT('foo', 'bar'), 'foob') > 0, "F1", "B1") + FROM src tablesample (1 rows) +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: SELECT IF(INSTR(CONCAT('foo', 'bar'), 'foob') > 0, "F1", "B1") + FROM src tablesample (1 rows) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +F1 diff --git ql/src/test/results/clientpositive/constprog2.q.out ql/src/test/results/clientpositive/constprog2.q.out new file mode 100644 index 0000000..196dffb --- /dev/null +++ ql/src/test/results/clientpositive/constprog2.q.out @@ -0,0 +1,75 @@ +Warning: Shuffle Join JOIN[5][tables = [src1, src2]] in Stage 'Stage-1:MAPRED' is a cross product +PREHOOK: query: EXPLAIN +SELECT src1.key, src1.key + 1, src2.value + FROM src src1 join src src2 ON src1.key = src2.key AND src1.key = 86 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN +SELECT src1.key, src1.key + 1, src2.value + FROM src src1 join src src2 ON src1.key = src2.key AND src1.key = 86 +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: src2 + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (key = 86) (type: boolean) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + sort order: + + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + value expressions: value (type: string) + TableScan + alias: src1 + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (key = 86) (type: boolean) + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + sort order: + + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Join Operator + condition map: + Inner Join 0 to 1 + condition expressions: + 0 + 1 {VALUE._col0} + outputColumnNames: _col5 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: '86' (type: string), 87.0 (type: double), _col5 (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 1598 Data size: 3196 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 + +Warning: Shuffle Join JOIN[5][tables = [src1, src2]] in Stage 'Stage-1:MAPRED' is a cross product +PREHOOK: query: SELECT src1.key, src1.key + 1, src2.value + FROM src src1 join src src2 ON src1.key = src2.key AND src1.key = 86 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: SELECT src1.key, src1.key + 1, src2.value + FROM src src1 join src src2 ON src1.key = src2.key AND src1.key = 86 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +86 87.0 val_86 diff --git ql/src/test/results/clientpositive/constprog_dp.q.out ql/src/test/results/clientpositive/constprog_dp.q.out new file mode 100644 index 0000000..adff821 --- /dev/null +++ ql/src/test/results/clientpositive/constprog_dp.q.out @@ -0,0 +1,80 @@ +PREHOOK: query: create table dest(key string, value string) partitioned by (ds string) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +POSTHOOK: query: create table dest(key string, value string) partitioned by (ds string) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@dest +PREHOOK: query: EXPLAIN +from srcpart +insert overwrite table dest partition (ds) select key, value, ds where ds='2008-04-08' +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN +from srcpart +insert overwrite table dest partition (ds) select key, value, ds where ds='2008-04-08' +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 PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: srcpart + Statistics: Num rows: 58 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: key (type: string), value (type: string), ds (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 58 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col2 (type: string) + sort order: + + Map-reduce partition columns: _col2 (type: string) + Statistics: Num rows: 58 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string) + Reduce Operator Tree: + Extract + Statistics: Num rows: 58 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 58 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: default.dest + + Stage: Stage-0 + Move Operator + tables: + partition: + ds + replace: true + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: default.dest + + Stage: Stage-2 + Stats-Aggr Operator + +PREHOOK: query: from srcpart +insert overwrite table dest partition (ds) select key, value, ds where ds='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: Output: default@dest +POSTHOOK: query: from srcpart +insert overwrite table dest partition (ds) select key, value, ds where ds='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: Output: default@dest@ds=2008-04-08 +POSTHOOK: Lineage: dest PARTITION(ds=2008-04-08).key SIMPLE [(srcpart)srcpart.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: dest PARTITION(ds=2008-04-08).value SIMPLE [(srcpart)srcpart.FieldSchema(name:value, type:string, comment:default), ] diff --git ql/src/test/results/clientpositive/constprog_type.q.out ql/src/test/results/clientpositive/constprog_type.q.out new file mode 100644 index 0000000..2a0047a --- /dev/null +++ ql/src/test/results/clientpositive/constprog_type.q.out @@ -0,0 +1,123 @@ +PREHOOK: query: CREATE TABLE dest1(d date, t timestamp) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +POSTHOOK: query: CREATE TABLE dest1(d date, t timestamp) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@dest1 +PREHOOK: query: EXPLAIN +INSERT OVERWRITE TABLE dest1 +SELECT cast('2013-11-17' as date), cast(cast('1.3041352164485E9' as double) as timestamp) + FROM src tablesample (1 rows) +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN +INSERT OVERWRITE TABLE dest1 +SELECT cast('2013-11-17' as date), cast(cast('1.3041352164485E9' as double) as timestamp) + FROM src tablesample (1 rows) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-7 depends on stages: Stage-1 , consists of Stage-4, Stage-3, Stage-5 + Stage-4 + Stage-0 depends on stages: Stage-4, Stage-3, Stage-6 + Stage-2 depends on stages: Stage-0 + Stage-3 + Stage-5 + Stage-6 depends on stages: Stage-5 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: 2013-11-17 (type: date), 2011-04-29 20:46:56.4485 (type: timestamp) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL 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 + name: default.dest1 + + Stage: Stage-7 + Conditional Operator + + Stage: Stage-4 + Move Operator + files: + hdfs directory: true +#### A masked pattern was here #### + + Stage: Stage-0 + Move Operator + tables: + replace: true + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: default.dest1 + + Stage: Stage-2 + Stats-Aggr Operator + + Stage: Stage-3 + Map Reduce + Map Operator Tree: + TableScan + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: default.dest1 + + Stage: Stage-5 + Map Reduce + Map Operator Tree: + TableScan + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: default.dest1 + + Stage: Stage-6 + Move Operator + files: + hdfs directory: true +#### A masked pattern was here #### + +PREHOOK: query: INSERT OVERWRITE TABLE dest1 +SELECT cast('2013-11-17' as date), cast(cast('1.3041352164485E9' as double) as timestamp) + FROM src tablesample (1 rows) +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: default@dest1 +POSTHOOK: query: INSERT OVERWRITE TABLE dest1 +SELECT cast('2013-11-17' as date), cast(cast('1.3041352164485E9' as double) as timestamp) + FROM src tablesample (1 rows) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: default@dest1 +POSTHOOK: Lineage: dest1.d EXPRESSION [] +POSTHOOK: Lineage: dest1.t EXPRESSION [] +PREHOOK: query: SELECT * FROM dest1 +PREHOOK: type: QUERY +PREHOOK: Input: default@dest1 +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM dest1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@dest1 +#### A masked pattern was here #### +2013-11-17 2011-04-29 20:46:56.4485 diff --git ql/src/test/results/clientpositive/create_view.q.out ql/src/test/results/clientpositive/create_view.q.out index e193a4f..ecace81 100644 --- ql/src/test/results/clientpositive/create_view.q.out +++ ql/src/test/results/clientpositive/create_view.q.out @@ -181,17 +181,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 18) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '18' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/cross_product_check_1.q.out ql/src/test/results/clientpositive/cross_product_check_1.q.out index af380fc..bfc4de4 100644 --- ql/src/test/results/clientpositive/cross_product_check_1.q.out +++ ql/src/test/results/clientpositive/cross_product_check_1.q.out @@ -208,24 +208,21 @@ STAGE PLANS: 1 outputColumnNames: _col0 Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string) + Select Operator + expressions: _col0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: _col0 (type: string) + mode: hash outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Group By Operator - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 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 + Statistics: Num rows: 11 Data size: 114 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 @@ -235,17 +232,17 @@ STAGE PLANS: key expressions: _col0 (type: string) sort order: + Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Group By Operator keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string) outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -259,7 +256,7 @@ STAGE PLANS: TableScan Reduce Output Operator sort order: - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: string) TableScan alias: a @@ -333,24 +330,21 @@ STAGE PLANS: 1 outputColumnNames: _col0 Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string) + Select Operator + expressions: _col0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: _col0 (type: string) + mode: hash outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Group By Operator - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 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 + Statistics: Num rows: 11 Data size: 114 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 @@ -360,17 +354,17 @@ STAGE PLANS: key expressions: _col0 (type: string) sort order: + Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Group By Operator keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string) outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -384,7 +378,7 @@ STAGE PLANS: TableScan Reduce Output Operator sort order: - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: string) TableScan alias: a @@ -465,24 +459,21 @@ STAGE PLANS: 1 outputColumnNames: _col0 Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string) + Select Operator + expressions: _col0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: _col0 (type: string) + mode: hash outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Group By Operator - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 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 + Statistics: Num rows: 11 Data size: 114 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 @@ -492,17 +483,17 @@ STAGE PLANS: key expressions: _col0 (type: string) sort order: + Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Group By Operator keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string) outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -516,7 +507,7 @@ STAGE PLANS: TableScan Reduce Output Operator sort order: - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: string) TableScan Reduce Output Operator diff --git ql/src/test/results/clientpositive/cross_product_check_2.q.out ql/src/test/results/clientpositive/cross_product_check_2.q.out index bff4ed9..93459b3 100644 --- ql/src/test/results/clientpositive/cross_product_check_2.q.out +++ ql/src/test/results/clientpositive/cross_product_check_2.q.out @@ -232,23 +232,20 @@ STAGE PLANS: 1 key (type: string) outputColumnNames: _col0 Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string) + Select Operator + expressions: _col0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: _col0 (type: string) + mode: hash outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Group By Operator - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string) - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE Local Work: Map Reduce Local Work Reduce Operator Tree: @@ -256,11 +253,11 @@ STAGE PLANS: keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string) outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -372,23 +369,20 @@ STAGE PLANS: 1 outputColumnNames: _col0 Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string) + Select Operator + expressions: _col0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: _col0 (type: string) + mode: hash outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Group By Operator - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string) - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE Local Work: Map Reduce Local Work Reduce Operator Tree: @@ -396,11 +390,11 @@ STAGE PLANS: keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string) outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -618,7 +612,7 @@ STAGE PLANS: TableScan Reduce Output Operator sort order: - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: string) TableScan Reduce Output Operator @@ -682,23 +676,20 @@ STAGE PLANS: 1 key (type: string) outputColumnNames: _col0 Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string) + Select Operator + expressions: _col0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: _col0 (type: string) + mode: hash outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Group By Operator - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string) - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 11 Data size: 114 Basic stats: COMPLETE Column stats: NONE Local Work: Map Reduce Local Work Reduce Operator Tree: @@ -706,11 +697,11 @@ STAGE PLANS: keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string) outputColumnNames: _col0 - Statistics: Num rows: 2 Data size: 20 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5 Data size: 51 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: diff --git ql/src/test/results/clientpositive/cte_1.q.out ql/src/test/results/clientpositive/cte_1.q.out index afd0d4f..21c6966 100644 --- ql/src/test/results/clientpositive/cte_1.q.out +++ ql/src/test/results/clientpositive/cte_1.q.out @@ -18,17 +18,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5812 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = '5') (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string) + expressions: '5' (type: string) outputColumnNames: _col0 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -75,17 +75,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5812 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = '5') (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string) + expressions: '5' (type: string) outputColumnNames: _col0 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -132,17 +132,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 5812 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = '5') (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string) + expressions: '5' (type: string) outputColumnNames: _col0 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/explain_logical.q.out ql/src/test/results/clientpositive/explain_logical.q.out index 0047133..778e118 100644 --- ql/src/test/results/clientpositive/explain_logical.q.out +++ ql/src/test/results/clientpositive/explain_logical.q.out @@ -692,7 +692,7 @@ v5:srcpart predicate: (ds = '10') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator (SEL_2) - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: key (type: string), value (type: string), '10' (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator (FS_4) diff --git ql/src/test/results/clientpositive/groupby_ppd.q.out ql/src/test/results/clientpositive/groupby_ppd.q.out index e7ddc41..6ac83cf 100644 --- ql/src/test/results/clientpositive/groupby_ppd.q.out +++ ql/src/test/results/clientpositive/groupby_ppd.q.out @@ -26,13 +26,13 @@ STAGE PLANS: predicate: (bar = 1) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: bar (type: int), foo (type: int) - outputColumnNames: _col0, _col1 + expressions: foo (type: int) + outputColumnNames: _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Union Statistics: Num rows: 0 Data size: 0 Basic stats: NONE 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: 0 Data size: 0 Basic stats: NONE Column stats: NONE Group By Operator @@ -52,13 +52,13 @@ STAGE PLANS: predicate: (bar = 1) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: bar (type: int), foo (type: int) - outputColumnNames: _col0, _col1 + expressions: foo (type: int) + outputColumnNames: _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Union Statistics: Num rows: 0 Data size: 0 Basic stats: NONE 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: 0 Data size: 0 Basic stats: NONE Column stats: NONE Group By Operator diff --git ql/src/test/results/clientpositive/groupby_sort_1.q.out ql/src/test/results/clientpositive/groupby_sort_1.q.out index bee863b..6899443 100644 --- ql/src/test/results/clientpositive/groupby_sort_1.q.out +++ ql/src/test/results/clientpositive/groupby_sort_1.q.out @@ -6421,8 +6421,9 @@ STAGE DEPENDENCIES: Stage-2 is a root stage Stage-0 depends on stages: Stage-2 Stage-3 depends on stages: Stage-0 - Stage-1 depends on stages: Stage-2 - Stage-4 depends on stages: Stage-1 + Stage-4 depends on stages: Stage-2 + Stage-1 depends on stages: Stage-4 + Stage-5 depends on stages: Stage-1 STAGE PLANS: Stage: Stage-2 @@ -6435,57 +6436,46 @@ STAGE PLANS: predicate: (key = 8) (type: boolean) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), val (type: string) - outputColumnNames: _col0, _col1 + expressions: val (type: string) + outputColumnNames: _col1 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string) - outputColumnNames: _col0 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1) - bucketGroup: true - keys: _col0 (type: string) + keys: '8' (type: string) mode: hash outputColumnNames: _col0, _col1 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: bigint) Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 + expressions: _col1 (type: string) + outputColumnNames: _col1 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1) - keys: _col0 (type: string), _col1 (type: string) - mode: final + keys: '8' (type: string), _col1 (type: string) + mode: hash outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: string), UDFToInteger(_col2) (type: int) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: true - Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE - table: - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - name: default.dest2 + Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: true + 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 Reduce Operator Tree: Group By Operator aggregations: count(VALUE._col0) - keys: KEY._col0 (type: string) + keys: '8' (type: string) mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), UDFToInteger(_col1) (type: int) + expressions: 8 (type: int), UDFToInteger(_col1) (type: int) outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -6510,6 +6500,36 @@ STAGE PLANS: Stage: Stage-3 Stats-Aggr Operator + Stage: Stage-4 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col1 (type: string) + sort order: ++ + Map-reduce partition columns: _col1 (type: string) + Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE + value expressions: _col2 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: '8' (type: string), KEY._col1 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: 8 (type: int), _col1 (type: string), UDFToInteger(_col2) (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: true + Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: default.dest2 + Stage: Stage-1 Move Operator tables: @@ -6520,7 +6540,7 @@ STAGE PLANS: serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe name: default.dest2 - Stage: Stage-4 + Stage: Stage-5 Stats-Aggr Operator PREHOOK: query: FROM (select key, val from T2 where key = 8) x diff --git ql/src/test/results/clientpositive/groupby_sort_skew_1.q.out ql/src/test/results/clientpositive/groupby_sort_skew_1.q.out index fa813dc..8a05406 100644 --- ql/src/test/results/clientpositive/groupby_sort_skew_1.q.out +++ ql/src/test/results/clientpositive/groupby_sort_skew_1.q.out @@ -4100,7 +4100,7 @@ STAGE PLANS: Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE tag: 0 - value expressions: _col0 (type: string), _col1 (type: bigint) + value expressions: _col1 (type: bigint) TableScan alias: t1 Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE @@ -4185,8 +4185,8 @@ STAGE PLANS: condition map: Inner Join 0 to 1 condition expressions: - 0 {VALUE._col0} {VALUE._col1} - 1 {VALUE._col1} + 0 {KEY.reducesinkkey0} {VALUE._col0} + 1 {VALUE._col0} outputColumnNames: _col0, _col1, _col3 Statistics: Num rows: 3 Data size: 13 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -4581,7 +4581,7 @@ STAGE PLANS: Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE tag: 0 - value expressions: _col0 (type: string), _col1 (type: bigint) + value expressions: _col1 (type: bigint) TableScan GatherStats: false Reduce Output Operator @@ -4590,7 +4590,7 @@ STAGE PLANS: Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE tag: 1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) + value expressions: _col1 (type: string), _col2 (type: bigint) Path -> Alias: #### A masked pattern was here #### Path -> Partition: @@ -4671,8 +4671,8 @@ STAGE PLANS: condition map: Inner Join 0 to 1 condition expressions: - 0 {VALUE._col0} {VALUE._col1} - 1 {VALUE._col0} {VALUE._col1} {VALUE._col2} + 0 {KEY.reducesinkkey0} {VALUE._col0} + 1 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 3 Data size: 13 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -6897,8 +6897,10 @@ STAGE DEPENDENCIES: Stage-3 depends on stages: Stage-2 Stage-0 depends on stages: Stage-3 Stage-4 depends on stages: Stage-0 - Stage-1 depends on stages: Stage-3 - Stage-5 depends on stages: Stage-1 + Stage-5 depends on stages: Stage-2 + Stage-6 depends on stages: Stage-5 + Stage-1 depends on stages: Stage-6 + Stage-7 depends on stages: Stage-1 STAGE PLANS: Stage: Stage-2 @@ -6911,16 +6913,15 @@ STAGE PLANS: predicate: (key = 8) (type: boolean) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), val (type: string) - outputColumnNames: _col0, _col1 + expressions: val (type: string) + outputColumnNames: _col1 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string) + expressions: '8' (type: string) outputColumnNames: _col0 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1) - bucketGroup: true keys: _col0 (type: string) mode: hash outputColumnNames: _col0, _col1 @@ -6932,27 +6933,21 @@ STAGE PLANS: Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: bigint) Select Operator - expressions: _col0 (type: string), _col1 (type: string) + expressions: '8' (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1) keys: _col0 (type: string), _col1 (type: string) - mode: final + mode: hash outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: string), UDFToInteger(_col2) (type: int) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: true - Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE - table: - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - name: default.dest2 + Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: true + 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 Reduce Operator Tree: Group By Operator aggregations: count(VALUE._col0) @@ -7010,6 +7005,60 @@ STAGE PLANS: Stage: Stage-4 Stats-Aggr Operator + Stage: Stage-5 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + sort order: ++ + Map-reduce partition columns: rand() (type: double) + Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE + value expressions: _col2 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string), KEY._col1 (type: string) + mode: partials + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: true + 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-6 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE + value expressions: _col2 (type: bigint) + Reduce Operator Tree: + Group By Operator + aggregations: count(VALUE._col0) + keys: KEY._col0 (type: string), KEY._col1 (type: string) + mode: final + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: UDFToInteger(_col0) (type: int), _col1 (type: string), UDFToInteger(_col2) (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: true + Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: default.dest2 + Stage: Stage-1 Move Operator tables: @@ -7020,7 +7069,7 @@ STAGE PLANS: serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe name: default.dest2 - Stage: Stage-5 + Stage: Stage-7 Stats-Aggr Operator PREHOOK: query: FROM (select key, val from T2 where key = 8) x diff --git ql/src/test/results/clientpositive/infer_const_type.q.out ql/src/test/results/clientpositive/infer_const_type.q.out index 66de332..4b5f6d4 100644 --- ql/src/test/results/clientpositive/infer_const_type.q.out +++ ql/src/test/results/clientpositive/infer_const_type.q.out @@ -56,12 +56,12 @@ STAGE PLANS: Map Operator Tree: TableScan alias: infertypes - Statistics: Num rows: 0 Data size: 117 Basic stats: PARTIAL Column stats: NONE + Statistics: Num rows: 3 Data size: 117 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (((((((ti = 127) and (si = 32767)) and (i = 12345)) and (bi = -12345)) and (fl = 906.0)) and (db = -307.0)) and (str = 1234)) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: ti (type: tinyint), si (type: smallint), i (type: int), bi (type: bigint), fl (type: float), db (type: double), str (type: string) + expressions: 127 (type: tinyint), 32767 (type: smallint), 12345 (type: int), -12345 (type: bigint), 906.0 (type: float), -307.0 (type: double), '1234' (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -135,7 +135,7 @@ STAGE PLANS: alias: infertypes Statistics: Num rows: 0 Data size: 117 Basic stats: PARTIAL Column stats: NONE Filter Operator - predicate: (((((false or false) or false) or false) or false) or false) (type: boolean) + predicate: false (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator expressions: ti (type: tinyint), si (type: smallint), i (type: int), bi (type: bigint), fl (type: float), db (type: double), str (type: string) @@ -199,7 +199,7 @@ STAGE PLANS: alias: infertypes Statistics: Num rows: 0 Data size: 117 Basic stats: PARTIAL Column stats: NONE Filter Operator - predicate: ((false or false) or false) (type: boolean) + predicate: false (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator expressions: ti (type: tinyint), si (type: smallint), i (type: int), bi (type: bigint), fl (type: float), db (type: double), str (type: string) @@ -253,12 +253,12 @@ STAGE PLANS: Map Operator Tree: TableScan alias: infertypes - Statistics: Num rows: 0 Data size: 117 Basic stats: PARTIAL Column stats: NONE + Statistics: Num rows: 3 Data size: 117 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (((ti < 127.0) and (i > 100.0)) and (str = 1.57)) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: ti (type: tinyint), si (type: smallint), i (type: int), bi (type: bigint), fl (type: float), db (type: double), str (type: string) + expressions: ti (type: tinyint), si (type: smallint), i (type: int), bi (type: bigint), fl (type: float), db (type: double), '1.57' (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/input18.q.out ql/src/test/results/clientpositive/input18.q.out index de980d6..f9875b6 100644 --- ql/src/test/results/clientpositive/input18.q.out +++ ql/src/test/results/clientpositive/input18.q.out @@ -36,7 +36,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), (1 + 2) (type: int), (3 + 4) (type: int) + expressions: key (type: string), value (type: string), 3 (type: int), 7 (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Transform Operator diff --git ql/src/test/results/clientpositive/input23.q.out ql/src/test/results/clientpositive/input23.q.out index 1891aae..d748dec 100644 --- ql/src/test/results/clientpositive/input23.q.out +++ ql/src/test/results/clientpositive/input23.q.out @@ -132,11 +132,11 @@ STAGE PLANS: Inner Join 0 to 1 condition expressions: 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} - 1 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} - outputColumnNames: _col0, _col1, _col2, _col3, _col6, _col7, _col8, _col9 + 1 {VALUE._col0} {VALUE._col1} + outputColumnNames: _col0, _col1, _col2, _col3, _col6, _col7 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string) + expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col6 (type: string), _col7 (type: string), '2008-04-08' (type: string), '14' (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE Limit diff --git ql/src/test/results/clientpositive/input26.q.out ql/src/test/results/clientpositive/input26.q.out index ea37b7e..1adda31 100644 --- ql/src/test/results/clientpositive/input26.q.out +++ ql/src/test/results/clientpositive/input26.q.out @@ -85,7 +85,7 @@ STAGE PLANS: Map Reduce Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), VALUE._col2 (type: string), VALUE._col3 (type: string) + expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), '2008-04-08' (type: string), '14' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Limit diff --git ql/src/test/results/clientpositive/input38.q.out ql/src/test/results/clientpositive/input38.q.out index 0b29370..8249a63 100644 --- ql/src/test/results/clientpositive/input38.q.out +++ ql/src/test/results/clientpositive/input38.q.out @@ -39,7 +39,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), (1 + 2) (type: int), (3 + 4) (type: int) + expressions: key (type: string), value (type: string), 3 (type: int), 7 (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Transform Operator diff --git ql/src/test/results/clientpositive/input6.q.out ql/src/test/results/clientpositive/input6.q.out index f9cf42f..927a347 100644 --- ql/src/test/results/clientpositive/input6.q.out +++ ql/src/test/results/clientpositive/input6.q.out @@ -34,7 +34,7 @@ STAGE PLANS: predicate: key is null (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: null (type: void), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/input_part2.q.out ql/src/test/results/clientpositive/input_part2.q.out index 9987769..77c412a 100644 --- ql/src/test/results/clientpositive/input_part2.q.out +++ ql/src/test/results/clientpositive/input_part2.q.out @@ -155,7 +155,7 @@ STAGE PLANS: predicate: ((key < 100) and (ds = '2008-04-08')) (type: boolean) Statistics: Num rows: 19 Data size: 3807 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(key) (type: int), value (type: string), hr (type: string), ds (type: string) + expressions: UDFToInteger(key) (type: int), value (type: string), hr (type: string), '2008-04-08' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 19 Data size: 3807 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -189,7 +189,7 @@ STAGE PLANS: predicate: ((key < 100) and (ds = '2008-04-09')) (type: boolean) Statistics: Num rows: 19 Data size: 3807 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(key) (type: int), value (type: string), hr (type: string), ds (type: string) + expressions: UDFToInteger(key) (type: int), value (type: string), hr (type: string), '2008-04-09' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 19 Data size: 3807 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/input_part4.q.out ql/src/test/results/clientpositive/input_part4.q.out index dbc5cf5..85e9aa9 100644 --- ql/src/test/results/clientpositive/input_part4.q.out +++ ql/src/test/results/clientpositive/input_part4.q.out @@ -19,7 +19,7 @@ STAGE PLANS: predicate: ((ds = '2008-04-08') and (hr = 15)) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: key (type: string), value (type: string), '2008-04-08' (type: string), '15' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE ListSink diff --git ql/src/test/results/clientpositive/input_part6.q.out ql/src/test/results/clientpositive/input_part6.q.out index 664a7ee..f05c05b 100644 --- ql/src/test/results/clientpositive/input_part6.q.out +++ ql/src/test/results/clientpositive/input_part6.q.out @@ -16,12 +16,12 @@ STAGE PLANS: alias: x Statistics: Num rows: 116 Data size: 23248 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (ds = ((2008 - 4) - 8)) (type: boolean) - Statistics: Num rows: 58 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + predicate: (ds = 1996) (type: boolean) + Statistics: Num rows: 116 Data size: 23248 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: key (type: string), value (type: string), '1996' (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 58 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 116 Data size: 23248 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 10 Statistics: Num rows: 10 Data size: 2000 Basic stats: COMPLETE Column stats: NONE diff --git ql/src/test/results/clientpositive/insert1.q.out ql/src/test/results/clientpositive/insert1.q.out index fbbf89c..df3d1fb 100644 --- ql/src/test/results/clientpositive/insert1.q.out +++ ql/src/test/results/clientpositive/insert1.q.out @@ -48,10 +48,10 @@ STAGE PLANS: alias: a Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Filter Operator - predicate: (key = (- 1)) (type: boolean) + predicate: (key = -1) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string) + expressions: -1 (type: int), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -137,10 +137,10 @@ STAGE PLANS: alias: a Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Filter Operator - predicate: (key = (- 1)) (type: boolean) + predicate: (key = -1) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string) + expressions: -1 (type: int), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -239,10 +239,10 @@ STAGE PLANS: alias: a Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Filter Operator - predicate: (key = (- 1)) (type: boolean) + predicate: (key = -1) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string) + expressions: -1 (type: int), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -328,10 +328,10 @@ STAGE PLANS: alias: a Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Filter Operator - predicate: (key = (- 1)) (type: boolean) + predicate: (key = -1) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string) + expressions: -1 (type: int), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/join38.q.out ql/src/test/results/clientpositive/join38.q.out index e26333a..faa3d21 100644 --- ql/src/test/results/clientpositive/join38.q.out +++ ql/src/test/results/clientpositive/join38.q.out @@ -35,6 +35,7 @@ POSTHOOK: Input: default@tmp #### A masked pattern was here #### 100 101 102.0 103.0 104.0 105 106.0 107.0 108.0 109.0 110.0 111 100 101 102.0 103.0 104.0 105 106.0 107.0 108.0 109.0 110.0 111 +Warning: Map Join MAPJOIN[14][bigTable=?] in task 'Stage-1:MAPRED' is a cross product PREHOOK: query: explain FROM src a JOIN tmp b ON (a.key = b.col11) SELECT /*+ MAPJOIN(a) */ a.value, b.col5, count(1) as count @@ -63,17 +64,17 @@ STAGE PLANS: a TableScan alias: a - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 111) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE HashTable Sink Operator condition expressions: 0 {value} 1 {col5} keys: - 0 key (type: string) - 1 col11 (type: string) + 0 + 1 Stage: Stage-1 Map Reduce @@ -91,25 +92,25 @@ STAGE PLANS: 0 {value} 1 {col5} keys: - 0 key (type: string) - 1 col11 (type: string) + 0 + 1 outputColumnNames: _col1, _col9 - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col9 (type: string) outputColumnNames: _col1, _col9 - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1) keys: _col1 (type: string), _col9 (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: string), _col1 (type: string) sort order: ++ Map-reduce partition columns: _col0 (type: string), _col1 (type: string) - Statistics: Num rows: 15 Data size: 3085 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 30 Data size: 3196 Basic stats: COMPLETE Column stats: NONE value expressions: _col2 (type: bigint) Local Work: Map Reduce Local Work @@ -119,14 +120,14 @@ STAGE PLANS: keys: KEY._col0 (type: string), KEY._col1 (type: string) mode: mergepartial outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 7 Data size: 1439 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 1598 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 7 Data size: 1439 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 1598 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 7 Data size: 1439 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 1598 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -138,6 +139,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Map Join MAPJOIN[14][bigTable=?] in task 'Stage-1:MAPRED' is a cross product PREHOOK: query: FROM src a JOIN tmp b ON (a.key = b.col11) SELECT /*+ MAPJOIN(a) */ a.value, b.col5, count(1) as count where b.col11 = 111 diff --git ql/src/test/results/clientpositive/join8.q.out ql/src/test/results/clientpositive/join8.q.out index eef07ba..b7b3d74 100644 --- ql/src/test/results/clientpositive/join8.q.out +++ ql/src/test/results/clientpositive/join8.q.out @@ -89,7 +89,7 @@ STAGE PLANS: predicate: _col2 is null (type: boolean) Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: UDFToInteger(_col0) (type: int), _col1 (type: string), UDFToInteger(_col2) (type: int), _col3 (type: string) + expressions: UDFToInteger(_col0) (type: int), _col1 (type: string), UDFToInteger(null) (type: int), _col3 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/join_cond_pushdown_1.q.out ql/src/test/results/clientpositive/join_cond_pushdown_1.q.out index 06a58ae..6c00256 100644 --- ql/src/test/results/clientpositive/join_cond_pushdown_1.q.out +++ ql/src/test/results/clientpositive/join_cond_pushdown_1.q.out @@ -299,7 +299,7 @@ STAGE PLANS: Reduce Output Operator sort order: Statistics: Num rows: 2 Data size: 1269 Basic stats: COMPLETE Column stats: NONE - value expressions: p_partkey (type: int), p_name (type: string), p_mfgr (type: string), p_brand (type: string), p_type (type: string), p_size (type: int), p_container (type: string), p_retailprice (type: double), p_comment (type: string) + value expressions: p_name (type: string), p_mfgr (type: string), p_brand (type: string), p_type (type: string), p_size (type: int), p_container (type: string), p_retailprice (type: double), p_comment (type: string) TableScan alias: p1 Statistics: Num rows: 5 Data size: 3173 Basic stats: COMPLETE Column stats: NONE @@ -313,8 +313,8 @@ STAGE PLANS: Inner Join 0 to 1 condition expressions: 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} - 1 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 + 1 {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 Statistics: Num rows: 5 Data size: 3490 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false @@ -341,18 +341,18 @@ STAGE PLANS: sort order: + Map-reduce partition columns: _col12 (type: string) Statistics: Num rows: 5 Data size: 3490 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col11 (type: int), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string) + value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} {VALUE._col11} {KEY.reducesinkkey0} {VALUE._col12} {VALUE._col13} {VALUE._col14} {VALUE._col15} {VALUE._col16} {VALUE._col17} {VALUE._col18} + 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} {KEY.reducesinkkey0} {VALUE._col12} {VALUE._col13} {VALUE._col14} {VALUE._col15} {VALUE._col16} {VALUE._col17} {VALUE._col18} 1 {VALUE._col0} {KEY.reducesinkkey0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col22, _col23, _col24, _col25, _col26, _col27, _col28, _col29, _col30 + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col22, _col23, _col24, _col25, _col26, _col27, _col28, _col29, _col30 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col11 (type: int), _col12 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string), _col22 (type: int), _col23 (type: string), _col24 (type: string), _col25 (type: string), _col26 (type: string), _col27 (type: int), _col28 (type: string), _col29 (type: double), _col30 (type: string) + expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), 1 (type: int), _col12 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string), _col22 (type: int), _col23 (type: string), _col24 (type: string), _col25 (type: string), _col26 (type: string), _col27 (type: int), _col28 (type: string), _col29 (type: double), _col30 (type: string) 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 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/join_cond_pushdown_3.q.out ql/src/test/results/clientpositive/join_cond_pushdown_3.q.out index 0ae4e77..0d82c1d 100644 --- ql/src/test/results/clientpositive/join_cond_pushdown_3.q.out +++ ql/src/test/results/clientpositive/join_cond_pushdown_3.q.out @@ -316,7 +316,7 @@ STAGE PLANS: Reduce Output Operator sort order: Statistics: Num rows: 2 Data size: 1269 Basic stats: COMPLETE Column stats: NONE - value expressions: p_partkey (type: int), p_name (type: string), p_mfgr (type: string), p_brand (type: string), p_type (type: string), p_size (type: int), p_container (type: string), p_retailprice (type: double), p_comment (type: string) + value expressions: p_name (type: string), p_mfgr (type: string), p_brand (type: string), p_type (type: string), p_size (type: int), p_container (type: string), p_retailprice (type: double), p_comment (type: string) TableScan alias: p1 Statistics: Num rows: 5 Data size: 3173 Basic stats: COMPLETE Column stats: NONE @@ -330,8 +330,8 @@ STAGE PLANS: Inner Join 0 to 1 condition expressions: 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} - 1 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 + 1 {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 Statistics: Num rows: 5 Data size: 3490 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false @@ -358,26 +358,26 @@ STAGE PLANS: sort order: + Map-reduce partition columns: _col12 (type: string) Statistics: Num rows: 5 Data size: 3490 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col11 (type: int), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string) + value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} {VALUE._col11} {KEY.reducesinkkey0} {VALUE._col12} {VALUE._col13} {VALUE._col14} {VALUE._col15} {VALUE._col16} {VALUE._col17} {VALUE._col18} + 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} {KEY.reducesinkkey0} {VALUE._col12} {VALUE._col13} {VALUE._col14} {VALUE._col15} {VALUE._col16} {VALUE._col17} {VALUE._col18} 1 {VALUE._col0} {KEY.reducesinkkey0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col22, _col23, _col24, _col25, _col26, _col27, _col28, _col29, _col30 + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col22, _col23, _col24, _col25, _col26, _col27, _col28, _col29, _col30 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((_col11 = 1) and (_col23 = _col12)) (type: boolean) - Statistics: Num rows: 1 Data size: 767 Basic stats: COMPLETE Column stats: NONE + predicate: (_col23 = _col12) (type: boolean) + Statistics: Num rows: 2 Data size: 1535 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col11 (type: int), _col12 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string), _col22 (type: int), _col23 (type: string), _col24 (type: string), _col25 (type: string), _col26 (type: string), _col27 (type: int), _col28 (type: string), _col29 (type: double), _col30 (type: string) + expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), 1 (type: int), _col12 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string), _col22 (type: int), _col23 (type: string), _col24 (type: string), _col25 (type: string), _col26 (type: string), _col27 (type: int), _col28 (type: string), _col29 (type: double), _col30 (type: string) 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 - Statistics: Num rows: 1 Data size: 767 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2 Data size: 1535 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 1 Data size: 767 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2 Data size: 1535 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/join_cond_pushdown_unqual1.q.out ql/src/test/results/clientpositive/join_cond_pushdown_unqual1.q.out index 4ad0ffe..32404e1 100644 --- ql/src/test/results/clientpositive/join_cond_pushdown_unqual1.q.out +++ ql/src/test/results/clientpositive/join_cond_pushdown_unqual1.q.out @@ -353,7 +353,7 @@ STAGE PLANS: Reduce Output Operator sort order: Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: p2_partkey (type: int), p2_name (type: string), p2_mfgr (type: string), p2_brand (type: string), p2_type (type: string), p2_size (type: int), p2_container (type: string), p2_retailprice (type: double), p2_comment (type: string) + value expressions: p2_name (type: string), p2_mfgr (type: string), p2_brand (type: string), p2_type (type: string), p2_size (type: int), p2_container (type: string), p2_retailprice (type: double), p2_comment (type: string) TableScan alias: p1 Statistics: Num rows: 5 Data size: 3173 Basic stats: COMPLETE Column stats: NONE @@ -367,8 +367,8 @@ STAGE PLANS: Inner Join 0 to 1 condition expressions: 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} - 1 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 + 1 {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 Statistics: Num rows: 5 Data size: 3490 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false @@ -395,18 +395,18 @@ STAGE PLANS: sort order: + Map-reduce partition columns: _col12 (type: string) Statistics: Num rows: 5 Data size: 3490 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col11 (type: int), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string) + value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} {VALUE._col11} {KEY.reducesinkkey0} {VALUE._col12} {VALUE._col13} {VALUE._col14} {VALUE._col15} {VALUE._col16} {VALUE._col17} {VALUE._col18} + 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} {KEY.reducesinkkey0} {VALUE._col12} {VALUE._col13} {VALUE._col14} {VALUE._col15} {VALUE._col16} {VALUE._col17} {VALUE._col18} 1 {VALUE._col0} {KEY.reducesinkkey0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col22, _col23, _col24, _col25, _col26, _col27, _col28, _col29, _col30 + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col22, _col23, _col24, _col25, _col26, _col27, _col28, _col29, _col30 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col11 (type: int), _col12 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string), _col22 (type: int), _col23 (type: string), _col24 (type: string), _col25 (type: string), _col26 (type: string), _col27 (type: int), _col28 (type: string), _col29 (type: double), _col30 (type: string) + expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), 1 (type: int), _col12 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string), _col22 (type: int), _col23 (type: string), _col24 (type: string), _col25 (type: string), _col26 (type: string), _col27 (type: int), _col28 (type: string), _col29 (type: double), _col30 (type: string) 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 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/join_cond_pushdown_unqual3.q.out ql/src/test/results/clientpositive/join_cond_pushdown_unqual3.q.out index 05aeefe..21d7e44 100644 --- ql/src/test/results/clientpositive/join_cond_pushdown_unqual3.q.out +++ ql/src/test/results/clientpositive/join_cond_pushdown_unqual3.q.out @@ -370,7 +370,7 @@ STAGE PLANS: Reduce Output Operator sort order: Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: p2_partkey (type: int), p2_name (type: string), p2_mfgr (type: string), p2_brand (type: string), p2_type (type: string), p2_size (type: int), p2_container (type: string), p2_retailprice (type: double), p2_comment (type: string) + value expressions: p2_name (type: string), p2_mfgr (type: string), p2_brand (type: string), p2_type (type: string), p2_size (type: int), p2_container (type: string), p2_retailprice (type: double), p2_comment (type: string) TableScan alias: p1 Statistics: Num rows: 5 Data size: 3173 Basic stats: COMPLETE Column stats: NONE @@ -384,8 +384,8 @@ STAGE PLANS: Inner Join 0 to 1 condition expressions: 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} - 1 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 + 1 {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 Statistics: Num rows: 5 Data size: 3490 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false @@ -412,26 +412,26 @@ STAGE PLANS: sort order: + Map-reduce partition columns: _col12 (type: string) Statistics: Num rows: 5 Data size: 3490 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col11 (type: int), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string) + value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} {VALUE._col11} {KEY.reducesinkkey0} {VALUE._col12} {VALUE._col13} {VALUE._col14} {VALUE._col15} {VALUE._col16} {VALUE._col17} {VALUE._col18} + 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} {VALUE._col8} {KEY.reducesinkkey0} {VALUE._col12} {VALUE._col13} {VALUE._col14} {VALUE._col15} {VALUE._col16} {VALUE._col17} {VALUE._col18} 1 {VALUE._col0} {KEY.reducesinkkey0} {VALUE._col1} {VALUE._col2} {VALUE._col3} {VALUE._col4} {VALUE._col5} {VALUE._col6} {VALUE._col7} - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col22, _col23, _col24, _col25, _col26, _col27, _col28, _col29, _col30 + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col22, _col23, _col24, _col25, _col26, _col27, _col28, _col29, _col30 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((_col11 = 1) and (_col23 = _col12)) (type: boolean) - Statistics: Num rows: 1 Data size: 767 Basic stats: COMPLETE Column stats: NONE + predicate: (_col23 = _col12) (type: boolean) + Statistics: Num rows: 2 Data size: 1535 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), _col11 (type: int), _col12 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string), _col22 (type: int), _col23 (type: string), _col24 (type: string), _col25 (type: string), _col26 (type: string), _col27 (type: int), _col28 (type: string), _col29 (type: double), _col30 (type: string) + expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string), 1 (type: int), _col12 (type: string), _col13 (type: string), _col14 (type: string), _col15 (type: string), _col16 (type: int), _col17 (type: string), _col18 (type: double), _col19 (type: string), _col22 (type: int), _col23 (type: string), _col24 (type: string), _col25 (type: string), _col26 (type: string), _col27 (type: int), _col28 (type: string), _col29 (type: double), _col30 (type: string) 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 - Statistics: Num rows: 1 Data size: 767 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2 Data size: 1535 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 1 Data size: 767 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2 Data size: 1535 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/join_literals.q.out ql/src/test/results/clientpositive/join_literals.q.out index eab2085..eafeeda 100644 --- ql/src/test/results/clientpositive/join_literals.q.out +++ ql/src/test/results/clientpositive/join_literals.q.out @@ -1,4 +1,5 @@ WARNING: Comparing a bigint and a string may result in a loss of precision. +Warning: Shuffle Join JOIN[5][tables = [a, b]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: -- Test Joins with a variety of literals in the on clause SELECT COUNT(*) FROM src a JOIN src b ON a.key = b.key AND a.key = 0L @@ -12,6 +13,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 9 +Warning: Shuffle Join JOIN[5][tables = [a, b]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT COUNT(*) FROM src a JOIN src b ON a.key = b.key AND a.key = 0S PREHOOK: type: QUERY PREHOOK: Input: default@src @@ -21,6 +23,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 9 +Warning: Shuffle Join JOIN[5][tables = [a, b]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT COUNT(*) FROM src a JOIN src b ON a.key = b.key AND a.key = 0Y PREHOOK: type: QUERY PREHOOK: Input: default@src diff --git ql/src/test/results/clientpositive/join_nullsafe.q.out ql/src/test/results/clientpositive/join_nullsafe.q.out index 360d9c8..dc11e27 100644 --- ql/src/test/results/clientpositive/join_nullsafe.q.out +++ ql/src/test/results/clientpositive/join_nullsafe.q.out @@ -1211,6 +1211,7 @@ NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL +Warning: Shuffle Join JOIN[5][tables = [a, b]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: --HIVE-3315 join predicate transitive explain select * from myinput1 a join myinput1 b on a.key<=>b.value AND a.key is NULL PREHOOK: type: QUERY @@ -1232,9 +1233,7 @@ STAGE PLANS: predicate: value is null (type: boolean) Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: value (type: int) sort order: + - Map-reduce partition columns: value (type: int) Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE value expressions: key (type: int) TableScan @@ -1244,9 +1243,7 @@ STAGE PLANS: predicate: key is null (type: boolean) Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: int) sort order: + - Map-reduce partition columns: key (type: int) Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: int) Reduce Operator Tree: @@ -1254,13 +1251,13 @@ STAGE PLANS: condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} - 1 {VALUE._col0} {KEY.reducesinkkey0} + 0 {VALUE._col0} + 1 {VALUE._col0} nullSafes: [true] - outputColumnNames: _col0, _col1, _col4, _col5 + outputColumnNames: _col1, _col4 Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col1 (type: int), _col4 (type: int), _col5 (type: int) + expressions: null (type: void), _col1 (type: int), _col4 (type: int), null (type: void) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -1277,6 +1274,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[5][tables = [a, b]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: select * from myinput1 a join myinput1 b on a.key<=>b.value AND a.key is NULL PREHOOK: type: QUERY PREHOOK: Input: default@myinput1 diff --git ql/src/test/results/clientpositive/join_view.q.out ql/src/test/results/clientpositive/join_view.q.out index a42d0fb..9984bce 100644 --- ql/src/test/results/clientpositive/join_view.q.out +++ ql/src/test/results/clientpositive/join_view.q.out @@ -50,11 +50,11 @@ STAGE PLANS: Inner Join 0 to 1 condition expressions: 0 {VALUE._col1} - 1 {VALUE._col0} {KEY.reducesinkkey0} - outputColumnNames: _col1, _col5, _col7 + 1 {VALUE._col0} + outputColumnNames: _col1, _col5 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col1 (type: string), _col5 (type: int), _col7 (type: string) + expressions: _col1 (type: string), _col5 (type: int), '2011-09-01' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/lateral_view_ppd.q.out ql/src/test/results/clientpositive/lateral_view_ppd.q.out index 0a869d0..67653ee 100644 --- ql/src/test/results/clientpositive/lateral_view_ppd.q.out +++ ql/src/test/results/clientpositive/lateral_view_ppd.q.out @@ -12,26 +12,26 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = '0') (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Lateral View Forward - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col1, _col4 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -39,20 +39,20 @@ STAGE PLANS: Select Operator expressions: array(1,2,3) (type: array) outputColumnNames: _col0 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE UDTF Operator - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE function name: explode Lateral View Join Operator outputColumnNames: _col1, _col4 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -95,26 +95,26 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = '0') (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Lateral View Forward - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col1, _col4 - Statistics: Num rows: 21 Data size: 4207 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 42 Data size: 4282 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: string), _col4 (type: int) + expressions: _col1 (type: string), 1 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 21 Data size: 4207 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 42 Data size: 4282 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 21 Data size: 4207 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 42 Data size: 4282 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -122,23 +122,23 @@ STAGE PLANS: Select Operator expressions: array(1,2,3) (type: array) outputColumnNames: _col0 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE UDTF Operator - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE function name: explode Filter Operator predicate: (col = 1) (type: boolean) - Statistics: Num rows: 7 Data size: 1402 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 14 Data size: 1427 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col1, _col4 - Statistics: Num rows: 21 Data size: 4207 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 42 Data size: 4282 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: string), _col4 (type: int) + expressions: _col1 (type: string), 1 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 21 Data size: 4207 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 42 Data size: 4282 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 21 Data size: 4207 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 42 Data size: 4282 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -266,35 +266,35 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = '0') (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Lateral View Forward - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col1, _col4 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE Lateral View Forward - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col1, _col4 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col1, _col4, _col5 - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -302,20 +302,20 @@ STAGE PLANS: Select Operator expressions: array(1,2,3) (type: array) outputColumnNames: _col0 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE UDTF Operator - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE function name: explode Lateral View Join Operator outputColumnNames: _col1, _col4, _col5 - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -323,29 +323,29 @@ STAGE PLANS: Select Operator expressions: array(1,2,3) (type: array) outputColumnNames: _col0 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE UDTF Operator - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE function name: explode Lateral View Join Operator outputColumnNames: _col1, _col4 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE Lateral View Forward - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col1, _col4 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col1, _col4, _col5 - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -353,20 +353,20 @@ STAGE PLANS: Select Operator expressions: array(1,2,3) (type: array) outputColumnNames: _col0 - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE UDTF Operator - Statistics: Num rows: 28 Data size: 5610 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5710 Basic stats: COMPLETE Column stats: NONE function name: explode Lateral View Join Operator outputColumnNames: _col1, _col4, _col5 - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 56 Data size: 11220 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11420 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -429,26 +429,26 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = '0') (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Lateral View Forward - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col1, _col4 - Statistics: Num rows: 18 Data size: 3606 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 37 Data size: 3772 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 18 Data size: 3606 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 37 Data size: 3772 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 18 Data size: 3606 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 37 Data size: 3772 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -456,23 +456,23 @@ STAGE PLANS: Select Operator expressions: array(1,2,3) (type: array) outputColumnNames: _col0 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE UDTF Operator - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE function name: explode Filter Operator predicate: (col > 1) (type: boolean) - Statistics: Num rows: 4 Data size: 801 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 9 Data size: 917 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col1, _col4 - Statistics: Num rows: 18 Data size: 3606 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 37 Data size: 3772 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col4 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 18 Data size: 3606 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 37 Data size: 3772 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 18 Data size: 3606 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 37 Data size: 3772 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/list_bucket_dml_1.q.out ql/src/test/results/clientpositive/list_bucket_dml_1.q.out index b48c36a..b7ac4fc 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_1.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_1.q.out @@ -448,7 +448,7 @@ STAGE PLANS: predicate: (key = '484') (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '484' (type: string), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_11.q.out ql/src/test/results/clientpositive/list_bucket_dml_11.q.out index acf80aa..fe0f469 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_11.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_11.q.out @@ -318,7 +318,7 @@ STAGE PLANS: predicate: (value = 'val_466') (type: boolean) Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: key (type: string), 'val_466' (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_12.q.out ql/src/test/results/clientpositive/list_bucket_dml_12.q.out index fa5bc92..6a2c063 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_12.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_12.q.out @@ -331,7 +331,7 @@ STAGE PLANS: predicate: ((col2 = '466') and (col4 = 'val_466')) (type: boolean) Statistics: Num rows: 125 Data size: 1578 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: col1 (type: string), col2 (type: string), col3 (type: string), col4 (type: string), col5 (type: string), ds (type: string), hr (type: string) + expressions: col1 (type: string), '466' (type: string), col3 (type: string), 'val_466' (type: string), col5 (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 Statistics: Num rows: 125 Data size: 1578 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -489,7 +489,7 @@ STAGE PLANS: predicate: ((col2 = '382') and (col4 = 'val_382')) (type: boolean) Statistics: Num rows: 125 Data size: 1578 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: col1 (type: string), col2 (type: string), col3 (type: string), col4 (type: string), col5 (type: string), ds (type: string), hr (type: string) + expressions: col1 (type: string), '382' (type: string), col3 (type: string), 'val_382' (type: string), col5 (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 Statistics: Num rows: 125 Data size: 1578 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_13.q.out ql/src/test/results/clientpositive/list_bucket_dml_13.q.out index a5813a6..4b7863c 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_13.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_13.q.out @@ -331,7 +331,7 @@ STAGE PLANS: predicate: ((col2 = '466') and (col4 = 'val_466')) (type: boolean) Statistics: Num rows: 125 Data size: 1578 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: col1 (type: string), col2 (type: string), col3 (type: string), col4 (type: string), col5 (type: string), ds (type: string), hr (type: string) + expressions: col1 (type: string), '466' (type: string), col3 (type: string), 'val_466' (type: string), col5 (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 Statistics: Num rows: 125 Data size: 1578 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_14.q.out ql/src/test/results/clientpositive/list_bucket_dml_14.q.out index 730fa9e..29b9681 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_14.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_14.q.out @@ -291,7 +291,7 @@ STAGE PLANS: predicate: (key = '484') (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '484' (type: string), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_2.q.out ql/src/test/results/clientpositive/list_bucket_dml_2.q.out index 5462629..e0757fb 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_2.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_2.q.out @@ -417,7 +417,7 @@ STAGE PLANS: predicate: ((key = '484') and (value = 'val_484')) (type: boolean) Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '484' (type: string), 'val_484' (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_3.q.out ql/src/test/results/clientpositive/list_bucket_dml_3.q.out index b786fc8..3e641d2 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_3.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_3.q.out @@ -388,7 +388,7 @@ STAGE PLANS: predicate: (key = '484') (type: boolean) Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '484' (type: string), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_4.q.out ql/src/test/results/clientpositive/list_bucket_dml_4.q.out index 083568a..90e379f 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_4.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_4.q.out @@ -820,7 +820,7 @@ STAGE PLANS: predicate: ((key = '484') and (value = 'val_484')) (type: boolean) Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '484' (type: string), 'val_484' (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_5.q.out ql/src/test/results/clientpositive/list_bucket_dml_5.q.out index 2db238e..9223a8c 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_5.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_5.q.out @@ -461,7 +461,7 @@ STAGE PLANS: predicate: ((key = '103') and (value = 'val_103')) (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '103' (type: string), 'val_103' (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_6.q.out ql/src/test/results/clientpositive/list_bucket_dml_6.q.out index c1ababc..549aa25 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_6.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_6.q.out @@ -982,7 +982,7 @@ STAGE PLANS: predicate: ((key = '484') and (value = 'val_484')) (type: boolean) Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '484' (type: string), 'val_484' (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_7.q.out ql/src/test/results/clientpositive/list_bucket_dml_7.q.out index 4c905e9..6c18e2e 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_7.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_7.q.out @@ -930,7 +930,7 @@ STAGE PLANS: predicate: ((key = '484') and (value = 'val_484')) (type: boolean) Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '484' (type: string), 'val_484' (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_8.q.out ql/src/test/results/clientpositive/list_bucket_dml_8.q.out index ff94687..a8c007a 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_8.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_8.q.out @@ -581,7 +581,7 @@ STAGE PLANS: predicate: ((key = '484') and (value = 'val_484')) (type: boolean) Statistics: Num rows: 4 Data size: 34 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '484' (type: string), 'val_484' (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 4 Data size: 34 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_dml_9.q.out ql/src/test/results/clientpositive/list_bucket_dml_9.q.out index 41872d7..58c62fd 100644 --- ql/src/test/results/clientpositive/list_bucket_dml_9.q.out +++ ql/src/test/results/clientpositive/list_bucket_dml_9.q.out @@ -820,7 +820,7 @@ STAGE PLANS: predicate: ((key = '484') and (value = 'val_484')) (type: boolean) Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '484' (type: string), 'val_484' (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 250 Data size: 2406 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_query_multiskew_1.q.out ql/src/test/results/clientpositive/list_bucket_query_multiskew_1.q.out index 81c519e..4adfc7c 100644 --- ql/src/test/results/clientpositive/list_bucket_query_multiskew_1.q.out +++ ql/src/test/results/clientpositive/list_bucket_query_multiskew_1.q.out @@ -171,7 +171,7 @@ STAGE PLANS: predicate: ((key = '484') and (value = 'val_484')) (type: boolean) Statistics: Num rows: 125 Data size: 1328 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string) + expressions: '484' (type: string) outputColumnNames: _col0 Statistics: Num rows: 125 Data size: 1328 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -331,7 +331,7 @@ STAGE PLANS: predicate: ((key = '238') and (value = 'val_238')) (type: boolean) Statistics: Num rows: 125 Data size: 1328 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '238' (type: string), 'val_238' (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 125 Data size: 1328 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -638,7 +638,7 @@ STAGE PLANS: predicate: (key = '495') (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '495' (type: string), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_query_multiskew_2.q.out ql/src/test/results/clientpositive/list_bucket_query_multiskew_2.q.out index 9caaece..00a7365 100644 --- ql/src/test/results/clientpositive/list_bucket_query_multiskew_2.q.out +++ ql/src/test/results/clientpositive/list_bucket_query_multiskew_2.q.out @@ -169,7 +169,7 @@ STAGE PLANS: predicate: (value = 'val_484') (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: key (type: string), 'val_484' (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -368,7 +368,7 @@ STAGE PLANS: predicate: (key = '406') (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string) + expressions: '406' (type: string) outputColumnNames: _col0 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_query_multiskew_3.q.out ql/src/test/results/clientpositive/list_bucket_query_multiskew_3.q.out index d4f833b..84d4746 100644 --- ql/src/test/results/clientpositive/list_bucket_query_multiskew_3.q.out +++ ql/src/test/results/clientpositive/list_bucket_query_multiskew_3.q.out @@ -287,7 +287,7 @@ STAGE PLANS: predicate: (key = '145') (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '145' (type: string), value (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -599,7 +599,7 @@ STAGE PLANS: predicate: ((key = '484') and (value = 'val_484')) (type: boolean) Statistics: Num rows: 125 Data size: 1328 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '484' (type: string), 'val_484' (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 125 Data size: 1328 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -753,7 +753,7 @@ STAGE PLANS: predicate: ((key = '327') and (value = 'val_327')) (type: boolean) Statistics: Num rows: 125 Data size: 1328 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) + expressions: '327' (type: string), 'val_327' (type: string), ds (type: string), hr (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 125 Data size: 1328 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_query_oneskew_1.q.out ql/src/test/results/clientpositive/list_bucket_query_oneskew_1.q.out index 69b14fe..1674768 100644 --- ql/src/test/results/clientpositive/list_bucket_query_oneskew_1.q.out +++ ql/src/test/results/clientpositive/list_bucket_query_oneskew_1.q.out @@ -223,7 +223,7 @@ STAGE PLANS: predicate: (x = 484) (type: boolean) Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: x (type: int) + expressions: 484 (type: int) outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -370,7 +370,7 @@ STAGE PLANS: predicate: (x = 495) (type: boolean) Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: x (type: int) + expressions: 495 (type: int) outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -513,7 +513,7 @@ STAGE PLANS: predicate: (x = 1) (type: boolean) Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: x (type: int) + expressions: 1 (type: int) outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/list_bucket_query_oneskew_2.q.out ql/src/test/results/clientpositive/list_bucket_query_oneskew_2.q.out index 21fac22..08bb344 100644 --- ql/src/test/results/clientpositive/list_bucket_query_oneskew_2.q.out +++ ql/src/test/results/clientpositive/list_bucket_query_oneskew_2.q.out @@ -240,7 +240,7 @@ STAGE PLANS: predicate: (x = 484) (type: boolean) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: x (type: int) + expressions: 484 (type: int) outputColumnNames: _col0 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -756,7 +756,7 @@ STAGE PLANS: predicate: (x = 484) (type: boolean) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: x (type: int) + expressions: 484 (type: int) outputColumnNames: x Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Group By Operator diff --git ql/src/test/results/clientpositive/literal_double.q.out ql/src/test/results/clientpositive/literal_double.q.out index b3f51f4..251858a 100644 --- ql/src/test/results/clientpositive/literal_double.q.out +++ ql/src/test/results/clientpositive/literal_double.q.out @@ -14,7 +14,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: 3.14 (type: double), (- 3.14) (type: double), 3.14E8 (type: double), 3.14E-8 (type: double), (- 3.14E8) (type: double), (- 3.14E-8) (type: double), 3.14E8 (type: double), 3.14E8 (type: double), 3.14E-8 (type: double) + expressions: 3.14 (type: double), -3.14 (type: double), 3.14E8 (type: double), 3.14E-8 (type: double), -3.14E8 (type: double), -3.14E-8 (type: double), 3.14E8 (type: double), 3.14E8 (type: double), 3.14E-8 (type: double) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit diff --git ql/src/test/results/clientpositive/macro.q.out ql/src/test/results/clientpositive/macro.q.out index dc046ba..78cd90a 100644 --- ql/src/test/results/clientpositive/macro.q.out +++ ql/src/test/results/clientpositive/macro.q.out @@ -29,7 +29,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: SIGMOID(2) (type: double) + expressions: 0.8807970779778823 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit @@ -74,7 +74,7 @@ STAGE PLANS: Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE GatherStats: false Select Operator - expressions: SIGMOID(2) (type: double) + expressions: 0.8807970779778823 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit @@ -119,7 +119,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: (FIXED_NUMBER() + 1) (type: int) + expressions: 2 (type: int) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit @@ -165,7 +165,7 @@ STAGE PLANS: Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE GatherStats: false Select Operator - expressions: (FIXED_NUMBER() + 1) (type: int) + expressions: 2 (type: int) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit @@ -237,7 +237,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: SIMPLE_ADD(1, 9) (type: int) + expressions: 10 (type: int) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit @@ -283,7 +283,7 @@ STAGE PLANS: Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE GatherStats: false Select Operator - expressions: SIMPLE_ADD(1, 9) (type: int) + expressions: 10 (type: int) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit diff --git ql/src/test/results/clientpositive/mapjoin1.q.out ql/src/test/results/clientpositive/mapjoin1.q.out index c77141b..77b9b3a 100644 --- ql/src/test/results/clientpositive/mapjoin1.q.out +++ ql/src/test/results/clientpositive/mapjoin1.q.out @@ -343,16 +343,13 @@ STAGE PLANS: TableScan alias: a Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: true (type: boolean) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - HashTable Sink Operator - condition expressions: - 0 {value} - 1 {key} {value} - keys: - 0 key (type: string) - 1 key (type: string) + HashTable Sink Operator + condition expressions: + 0 {value} + 1 {key} {value} + keys: + 0 key (type: string) + 1 key (type: string) Stage: Stage-1 Map Reduce @@ -360,34 +357,31 @@ STAGE PLANS: TableScan alias: b Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: true (type: boolean) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - Map Join Operator - condition map: - Right Outer Join0 to 1 - condition expressions: - 0 {key} {value} - 1 {key} {value} - keys: - 0 key (type: string) - 1 key (type: string) - outputColumnNames: _col0, _col1, _col4, _col5 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string), _col5 (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - Limit - Number of rows: 10 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE 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 + Map Join Operator + condition map: + Right Outer Join0 to 1 + condition expressions: + 0 {key} {value} + 1 {key} {value} + keys: + 0 key (type: string) + 1 key (type: string) + outputColumnNames: _col0, _col1, _col4, _col5 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string), _col5 (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + Limit + Number of rows: 10 + Statistics: Num rows: 10 Data size: 2060 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 10 Data size: 2060 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 Local Work: Map Reduce Local Work diff --git ql/src/test/results/clientpositive/multi_insert.q.out ql/src/test/results/clientpositive/multi_insert.q.out index 575bd06..f58801c 100644 --- ql/src/test/results/clientpositive/multi_insert.q.out +++ ql/src/test/results/clientpositive/multi_insert.q.out @@ -2501,45 +2501,45 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 2) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '2' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 4) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '4' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -2595,45 +2595,45 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 2) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '2' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 4) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '4' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -2689,45 +2689,45 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 2) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '2' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 4) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '4' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -2783,45 +2783,45 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 2) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '2' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 4) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '4' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/multi_insert_move_tasks_share_dependencies.q.out ql/src/test/results/clientpositive/multi_insert_move_tasks_share_dependencies.q.out index 06c47ce..d364548 100644 --- ql/src/test/results/clientpositive/multi_insert_move_tasks_share_dependencies.q.out +++ ql/src/test/results/clientpositive/multi_insert_move_tasks_share_dependencies.q.out @@ -2550,45 +2550,45 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 2) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '2' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 4) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '4' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -2648,45 +2648,45 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 2) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '2' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 4) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '4' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -2746,45 +2746,45 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 2) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '2' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 4) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '4' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -2844,45 +2844,45 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 2) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '2' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 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 Filter Operator predicate: (key = 4) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '4' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/nullgroup4.q.out ql/src/test/results/clientpositive/nullgroup4.q.out index 1050e15..9e1307c 100644 --- ql/src/test/results/clientpositive/nullgroup4.q.out +++ ql/src/test/results/clientpositive/nullgroup4.q.out @@ -15,25 +15,25 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 55 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 9999) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1), count(DISTINCT value) keys: value (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: string) sort order: + Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: bigint) Reduce Operator Tree: Group By Operator @@ -105,24 +105,24 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 55 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 9999) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1), count(DISTINCT value) keys: value (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: string) sort order: + - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: bigint) Reduce Operator Tree: Group By Operator @@ -174,19 +174,19 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 55 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 9999) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: value (type: string) sort order: + Map-reduce partition columns: value (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Group By Operator aggregations: count(1), count(DISTINCT KEY._col0:0._col0) @@ -257,18 +257,18 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 55 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 9999) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: value (type: string) sort order: + - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Group By Operator aggregations: count(1), count(DISTINCT KEY._col0:0._col0) diff --git ql/src/test/results/clientpositive/nullgroup4_multi_distinct.q.out ql/src/test/results/clientpositive/nullgroup4_multi_distinct.q.out index ba8fa67..7480798 100644 --- ql/src/test/results/clientpositive/nullgroup4_multi_distinct.q.out +++ ql/src/test/results/clientpositive/nullgroup4_multi_distinct.q.out @@ -14,24 +14,24 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 55 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 9999) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1), count(DISTINCT value), count(DISTINCT substr(value, 5)) keys: value (type: string), substr(value, 5) (type: string) mode: hash outputColumnNames: _col0, _col1, _col2, _col3, _col4 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: string), _col1 (type: string) sort order: ++ - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE value expressions: _col2 (type: bigint) Reduce Operator Tree: Group By Operator @@ -82,18 +82,18 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 55 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 9999) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: value (type: string) outputColumnNames: value - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: value (type: string), substr(value, 5) (type: string) sort order: ++ - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2853 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Group By Operator aggregations: count(1), count(DISTINCT KEY._col0:0._col0), count(DISTINCT KEY._col0:1._col0) diff --git ql/src/test/results/clientpositive/num_op_type_conv.q.out ql/src/test/results/clientpositive/num_op_type_conv.q.out index 4926c8b..5e898d2 100644 --- ql/src/test/results/clientpositive/num_op_type_conv.q.out +++ ql/src/test/results/clientpositive/num_op_type_conv.q.out @@ -20,7 +20,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: (null + 7) (type: double), (1.0 - null) (type: double), (null + null) (type: double), (UDFToLong(21) % UDFToByte(5)) (type: bigint), (UDFToLong(21) % UDFToLong(21)) (type: bigint), (9 % '3') (type: double) + expressions: (null + 7) (type: double), (1.0 - null) (type: double), (null + null) (type: double), 1 (type: bigint), 0 (type: bigint), 0.0 (type: double) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit diff --git ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out index 6d50419..beeebfe 100644 --- ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out +++ ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out @@ -319,7 +319,7 @@ STAGE PLANS: alias: orc_pred Statistics: Num rows: 1049 Data size: 311170 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((t is not null and (t < 0)) and (t > (- 2))) (type: boolean) + predicate: ((t is not null and (t < 0)) and (t > -2)) (type: boolean) Statistics: Num rows: 58 Data size: 17204 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: t (type: tinyint) @@ -474,10 +474,10 @@ STAGE PLANS: alias: orc_pred Statistics: Num rows: 1049 Data size: 311170 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((t = (- 1)) and s is not null) and (s like 'bob%')) (type: boolean) + predicate: (((t = -1) and s is not null) and (s like 'bob%')) (type: boolean) Statistics: Num rows: 131 Data size: 38859 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: t (type: tinyint), s (type: string) + expressions: -1 (type: tinyint), s (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 131 Data size: 38859 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -605,7 +605,7 @@ STAGE PLANS: alias: orc_pred Statistics: Num rows: 1049 Data size: 311170 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((s is not null and (s like 'bob%')) and (not (t) IN ((- 1), (- 2), (- 3)))) and t BETWEEN 25 AND 30) (type: boolean) + predicate: (((s is not null and (s like 'bob%')) and (not (t) IN (-1, -2, -3))) and t BETWEEN 25 AND 30) (type: boolean) Statistics: Num rows: 65 Data size: 19281 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: t (type: tinyint), s (type: string) @@ -782,7 +782,7 @@ STAGE PLANS: alias: orc_pred Statistics: Num rows: 1049 Data size: 311170 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((((((d >= round(9.99)) and (d < 12.0)) and t is not null) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) + predicate: (((((((d >= 10.0) and (d < 12.0)) and t is not null) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) Statistics: Num rows: 2 Data size: 593 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) @@ -984,7 +984,7 @@ STAGE PLANS: alias: orc_pred Statistics: Num rows: 1049 Data size: 311170 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((((((((t > 10) and (t <> 101)) and (d >= round(9.99))) and (d < 12.0)) and t is not null) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) + predicate: (((((((((t > 10) and (t <> 101)) and (d >= 10.0)) and (d < 12.0)) and t is not null) and (s like '%son')) and (not (s like '%car%'))) and (t > 0)) and si BETWEEN 300 AND 400) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) diff --git ql/src/test/results/clientpositive/pcr.q.out ql/src/test/results/clientpositive/pcr.q.out index 0894066..f1a131c 100644 --- ql/src/test/results/clientpositive/pcr.q.out +++ ql/src/test/results/clientpositive/pcr.q.out @@ -1688,11 +1688,11 @@ STAGE PLANS: predicate: (key = 14) (type: boolean) Statistics: Num rows: 20 Data size: 160 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string) - outputColumnNames: _col0, _col1 + expressions: value (type: string) + outputColumnNames: _col1 Statistics: Num rows: 20 Data size: 160 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: string) + key expressions: _col1 (type: string) sort order: ++ Statistics: Num rows: 20 Data size: 160 Basic stats: COMPLETE Column stats: NONE tag: -1 @@ -1795,7 +1795,7 @@ STAGE PLANS: Needs Tagging: false Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: string) + expressions: 14 (type: int), KEY.reducesinkkey1 (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 20 Data size: 160 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -4603,7 +4603,7 @@ STAGE PLANS: predicate: (key = 2) (type: boolean) Statistics: Num rows: 10 Data size: 80 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string) + expressions: 2 (type: int), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 10 Data size: 80 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -4642,7 +4642,7 @@ STAGE PLANS: predicate: (key = 3) (type: boolean) Statistics: Num rows: 10 Data size: 80 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string) + expressions: 3 (type: int), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 10 Data size: 80 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -5403,20 +5403,20 @@ STAGE PLANS: Map Operator Tree: TableScan alias: srcpart - Statistics: Num rows: 58 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11624 Basic stats: COMPLETE Column stats: NONE GatherStats: false Filter Operator isSamplingPred: false predicate: (key = 11) (type: boolean) - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string), ds (type: string), hr (type: string) + outputColumnNames: _col1, _col2, _col3 + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string), _col2 (type: string), _col3 (type: string) + key expressions: _col2 (type: string), _col3 (type: string) sort order: +++ - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE tag: -1 value expressions: _col1 (type: string) Path -> Alias: @@ -5520,15 +5520,15 @@ STAGE PLANS: Needs Tagging: false Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string), KEY.reducesinkkey2 (type: string) + expressions: '11' (type: string), VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string), KEY.reducesinkkey2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false GlobalTableId: 0 #### A masked pattern was here #### NumFilesPerFileSink: 1 - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE #### A masked pattern was here #### table: input format: org.apache.hadoop.mapred.TextInputFormat @@ -5625,20 +5625,20 @@ STAGE PLANS: Map Operator Tree: TableScan alias: srcpart - Statistics: Num rows: 58 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 112 Data size: 11624 Basic stats: COMPLETE Column stats: NONE GatherStats: false Filter Operator isSamplingPred: false predicate: (key = 11) (type: boolean) - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), ds (type: string), hr (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string), ds (type: string), hr (type: string) + outputColumnNames: _col1, _col2, _col3 + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string), _col2 (type: string), _col3 (type: string) + key expressions: _col2 (type: string), _col3 (type: string) sort order: +++ - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE tag: -1 value expressions: _col1 (type: string) Path -> Alias: @@ -5742,15 +5742,15 @@ STAGE PLANS: Needs Tagging: false Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string), KEY.reducesinkkey2 (type: string) + expressions: '11' (type: string), VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string), KEY.reducesinkkey2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false GlobalTableId: 0 #### A masked pattern was here #### NumFilesPerFileSink: 1 - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE #### A masked pattern was here #### table: input format: org.apache.hadoop.mapred.TextInputFormat diff --git ql/src/test/results/clientpositive/ppd2.q.out ql/src/test/results/clientpositive/ppd2.q.out index b24b4db..69f5ca8 100644 --- ql/src/test/results/clientpositive/ppd2.q.out +++ ql/src/test/results/clientpositive/ppd2.q.out @@ -331,6 +331,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: EXPLAIN SELECT x.key, x.value as v1, y.key FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY v1 PREHOOK: type: QUERY @@ -348,40 +349,36 @@ STAGE PLANS: Map Operator Tree: TableScan alias: y - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} - 1 {KEY.reducesinkkey0} - outputColumnNames: _col0, _col1, _col4 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + 0 {VALUE._col0} + 1 + outputColumnNames: _col1 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + expressions: _col1 (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -397,16 +394,15 @@ STAGE PLANS: key expressions: _col1 (type: string) sort order: + Map-reduce partition columns: _col1 (type: string) - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: string), _col2 (type: string) + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), KEY.reducesinkkey0 (type: string), VALUE._col1 (type: string) + expressions: '20' (type: string), KEY.reducesinkkey0 (type: string), '20' (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/ppd_clusterby.q.out ql/src/test/results/clientpositive/ppd_clusterby.q.out index 7b5b786..1df039a 100644 --- ql/src/test/results/clientpositive/ppd_clusterby.q.out +++ ql/src/test/results/clientpositive/ppd_clusterby.q.out @@ -14,28 +14,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 10) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '10' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: '10' (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -56,6 +55,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 10 val_10 +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: EXPLAIN SELECT x.key, x.value as v1, y.key FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY v1 PREHOOK: type: QUERY @@ -73,49 +73,42 @@ STAGE PLANS: Map Operator Tree: TableScan alias: y - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} - 1 {KEY.reducesinkkey0} - outputColumnNames: _col0, _col1, _col4 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (_col0 = 20) (type: boolean) - Statistics: Num rows: 15 Data size: 1546 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 15 Data size: 1546 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 + 0 {VALUE._col0} + 1 + outputColumnNames: _col1 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col1 (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 1598 Data size: 3196 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 @@ -125,16 +118,15 @@ STAGE PLANS: key expressions: _col1 (type: string) sort order: + Map-reduce partition columns: _col1 (type: string) - Statistics: Num rows: 15 Data size: 1546 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: string), _col2 (type: string) + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), KEY.reducesinkkey0 (type: string), VALUE._col1 (type: string) + expressions: '20' (type: string), KEY.reducesinkkey0 (type: string), '20' (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 15 Data size: 1546 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 15 Data size: 1546 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -146,6 +138,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT x.key, x.value as v1, y.key FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY v1 PREHOOK: type: QUERY PREHOOK: Input: default@src @@ -171,28 +164,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 10) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: value (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: '10' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: '10' (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -213,6 +205,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 10 val_10 +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: EXPLAIN SELECT x.key, x.value as v1, y.key FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY v1 PREHOOK: type: QUERY @@ -230,40 +223,36 @@ STAGE PLANS: Map Operator Tree: TableScan alias: y - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE TableScan alias: x - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 20) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} - 1 {KEY.reducesinkkey0} - outputColumnNames: _col0, _col1, _col4 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + 0 {VALUE._col0} + 1 + outputColumnNames: _col1 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + expressions: _col1 (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -279,16 +268,15 @@ STAGE PLANS: key expressions: _col1 (type: string) sort order: + Map-reduce partition columns: _col1 (type: string) - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: string), _col2 (type: string) + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Select Operator - expressions: VALUE._col0 (type: string), KEY.reducesinkkey0 (type: string), VALUE._col1 (type: string) + expressions: '20' (type: string), KEY.reducesinkkey0 (type: string), '20' (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 31 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -300,6 +288,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[4][tables = [x, y]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: SELECT x.key, x.value as v1, y.key FROM SRC x JOIN SRC y ON (x.key = y.key) where x.key = 20 CLUSTER BY v1 PREHOOK: type: QUERY PREHOOK: Input: default@src diff --git ql/src/test/results/clientpositive/ppd_constant_where.q.out ql/src/test/results/clientpositive/ppd_constant_where.q.out index bb0dba9..d031586 100644 --- ql/src/test/results/clientpositive/ppd_constant_where.q.out +++ ql/src/test/results/clientpositive/ppd_constant_where.q.out @@ -17,20 +17,17 @@ STAGE PLANS: TableScan alias: srcpart Statistics: Num rows: 0 Data size: 11624 Basic stats: PARTIAL Column stats: COMPLETE - Filter Operator - predicate: ('a' = 'a') (type: boolean) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: COMPLETE - Select Operator - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: COMPLETE - Group By Operator - aggregations: count() - mode: hash - outputColumnNames: _col0 + Select Operator + Statistics: Num rows: 0 Data size: 11624 Basic stats: PARTIAL Column stats: COMPLETE + Group By Operator + aggregations: count() + mode: hash + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + sort order: Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - sort order: - Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE - value expressions: _col0 (type: bigint) + value expressions: _col0 (type: bigint) Reduce Operator Tree: Group By Operator aggregations: count(VALUE._col0) diff --git ql/src/test/results/clientpositive/ppd_join4.q.out ql/src/test/results/clientpositive/ppd_join4.q.out index 94154b1..ebf0f1a 100644 --- ql/src/test/results/clientpositive/ppd_join4.q.out +++ ql/src/test/results/clientpositive/ppd_join4.q.out @@ -28,6 +28,7 @@ POSTHOOK: Input: default@dual POSTHOOK: Output: default@test_tbl POSTHOOK: Lineage: test_tbl.id SIMPLE [] POSTHOOK: Lineage: test_tbl.name SIMPLE [] +Warning: Shuffle Join JOIN[8][tables = [t2, t3]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: explain select t2.* from @@ -58,18 +59,12 @@ STAGE PLANS: predicate: ((name = 'c') and (id = 'a')) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: id (type: string), name (type: string) - outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) - outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator compressed: false @@ -88,28 +83,22 @@ STAGE PLANS: predicate: (id = 'a') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: id (type: string) sort order: + - Map-reduce partition columns: id (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE TableScan Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: _col1 (type: string) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} + 0 1 - outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string) + expressions: 'a' (type: string), 'c' (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -126,6 +115,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[8][tables = [t2, t3]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: select t2.* from (select id,name from (select id,name from test_tbl) t1 sort by id) t2 diff --git ql/src/test/results/clientpositive/ppd_outer_join5.q.out ql/src/test/results/clientpositive/ppd_outer_join5.q.out index a8d1681..1fb057e 100644 --- ql/src/test/results/clientpositive/ppd_outer_join5.q.out +++ ql/src/test/results/clientpositive/ppd_outer_join5.q.out @@ -45,9 +45,7 @@ STAGE PLANS: predicate: (id = 20) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: id (type: int) sort order: + - Map-reduce partition columns: id (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE value expressions: key (type: string), value (type: string) TableScan @@ -82,11 +80,11 @@ STAGE PLANS: condition expressions: 0 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} 1 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} - 2 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} - outputColumnNames: _col0, _col1, _col2, _col5, _col6, _col7, _col10, _col11, _col12 + 2 {VALUE._col0} {VALUE._col1} + outputColumnNames: _col0, _col1, _col2, _col5, _col6, _col7, _col11, _col12 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: string), _col10 (type: int), _col11 (type: string), _col12 (type: string) + expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: string), 20 (type: int), _col11 (type: string), _col12 (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -103,6 +101,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[6][tables = [t1, t2, t3]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: explain select * from t1 join t2 on (t1.id=t2.id) left outer join t3 on (t2.id=t3.id) where t2.id=20 PREHOOK: type: QUERY POSTHOOK: query: explain select * from t1 join t2 on (t1.id=t2.id) left outer join t3 on (t2.id=t3.id) where t2.id=20 @@ -134,9 +133,7 @@ STAGE PLANS: predicate: (id = 20) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: id (type: int) sort order: + - Map-reduce partition columns: id (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE value expressions: key (type: string), value (type: string) TableScan @@ -146,9 +143,7 @@ STAGE PLANS: predicate: (id = 20) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: id (type: int) sort order: + - Map-reduce partition columns: id (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE value expressions: key (type: string), value (type: string) Reduce Operator Tree: @@ -157,13 +152,13 @@ STAGE PLANS: Inner Join 0 to 1 Left Outer Join1 to 2 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} - 1 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} + 0 {VALUE._col0} {VALUE._col1} + 1 {VALUE._col0} {VALUE._col1} 2 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} - outputColumnNames: _col0, _col1, _col2, _col5, _col6, _col7, _col10, _col11, _col12 + outputColumnNames: _col1, _col2, _col6, _col7, _col10, _col11, _col12 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: string), _col10 (type: int), _col11 (type: string), _col12 (type: string) + expressions: 20 (type: int), _col1 (type: string), _col2 (type: string), 20 (type: int), _col6 (type: string), _col7 (type: string), _col10 (type: int), _col11 (type: string), _col12 (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -180,6 +175,7 @@ STAGE PLANS: Processor Tree: ListSink +Warning: Shuffle Join JOIN[6][tables = [t1, t2, t3]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: explain select * from t1 join t2 on (t1.id=t2.id) left outer join t3 on (t1.id=t3.id) where t2.id=20 PREHOOK: type: QUERY POSTHOOK: query: explain select * from t1 join t2 on (t1.id=t2.id) left outer join t3 on (t1.id=t3.id) where t2.id=20 @@ -211,9 +207,7 @@ STAGE PLANS: predicate: (id = 20) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: id (type: int) sort order: + - Map-reduce partition columns: id (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE value expressions: key (type: string), value (type: string) TableScan @@ -223,9 +217,7 @@ STAGE PLANS: predicate: (id = 20) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: id (type: int) sort order: + - Map-reduce partition columns: id (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE value expressions: key (type: string), value (type: string) Reduce Operator Tree: @@ -234,13 +226,13 @@ STAGE PLANS: Inner Join 0 to 1 Left Outer Join0 to 2 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} - 1 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} + 0 {VALUE._col0} {VALUE._col1} + 1 {VALUE._col0} {VALUE._col1} 2 {KEY.reducesinkkey0} {VALUE._col0} {VALUE._col1} - outputColumnNames: _col0, _col1, _col2, _col5, _col6, _col7, _col10, _col11, _col12 + outputColumnNames: _col1, _col2, _col6, _col7, _col10, _col11, _col12 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: string), _col10 (type: int), _col11 (type: string), _col12 (type: string) + expressions: 20 (type: int), _col1 (type: string), _col2 (type: string), 20 (type: int), _col6 (type: string), _col7 (type: string), _col10 (type: int), _col11 (type: string), _col12 (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/ppd_repeated_alias.q.out ql/src/test/results/clientpositive/ppd_repeated_alias.q.out index 922c9c8..0dc514d 100644 --- ql/src/test/results/clientpositive/ppd_repeated_alias.q.out +++ ql/src/test/results/clientpositive/ppd_repeated_alias.q.out @@ -72,7 +72,7 @@ STAGE PLANS: predicate: (_col6 = 3) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col5 (type: int), _col6 (type: int) + expressions: _col0 (type: int), _col5 (type: int), 3 (type: int) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -143,7 +143,7 @@ STAGE PLANS: predicate: (_col6 = 3) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col5 (type: int), _col6 (type: int) + expressions: _col0 (type: int), _col5 (type: int), 3 (type: int) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -203,18 +203,17 @@ STAGE PLANS: sort order: + Map-reduce partition columns: foo (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: bar (type: int) Reduce Operator Tree: Join Operator condition map: Inner Join 0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} + 0 {KEY.reducesinkkey0} 1 {KEY.reducesinkkey0} - outputColumnNames: _col0, _col1, _col5 + outputColumnNames: _col0, _col5 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col5 (type: int), _col1 (type: int) + expressions: _col0 (type: int), _col5 (type: int), 3 (type: int) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/ppd_udf_case.q.out ql/src/test/results/clientpositive/ppd_udf_case.q.out index c5f770f..8160079 100644 --- ql/src/test/results/clientpositive/ppd_udf_case.q.out +++ ql/src/test/results/clientpositive/ppd_udf_case.q.out @@ -70,8 +70,8 @@ STAGE PLANS: predicate: (((_col2 = '2008-04-08') and (_col8 = '2008-04-08')) and CASE (_col0) WHEN ('27') THEN (true) WHEN ('38') THEN (false) ELSE (null) END) (type: boolean) Statistics: Num rows: 3 Data size: 618 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col6 (type: string), _col7 (type: string), _col8 (type: string), _col9 (type: string) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string), _col6 (type: string), _col7 (type: string), _col9 (type: string) + outputColumnNames: _col0, _col1, _col3, _col4, _col5, _col7 Statistics: Num rows: 3 Data size: 618 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false @@ -85,12 +85,12 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col6 (type: string), _col7 (type: string) + key expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), _col7 (type: string) sort order: ++++++++ Statistics: Num rows: 3 Data size: 618 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string), KEY.reducesinkkey2 (type: string), KEY.reducesinkkey3 (type: string), KEY.reducesinkkey4 (type: string), KEY.reducesinkkey5 (type: string), KEY.reducesinkkey6 (type: string), KEY.reducesinkkey7 (type: string) + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string), '2008-04-08' (type: string), KEY.reducesinkkey3 (type: string), KEY.reducesinkkey4 (type: string), KEY.reducesinkkey5 (type: string), '2008-04-08' (type: string), KEY.reducesinkkey7 (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 Statistics: Num rows: 3 Data size: 618 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/ppd_udf_col.q.out ql/src/test/results/clientpositive/ppd_udf_col.q.out index f0a48bb..9166527 100644 --- ql/src/test/results/clientpositive/ppd_udf_col.q.out +++ ql/src/test/results/clientpositive/ppd_udf_col.q.out @@ -18,24 +18,24 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1937 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 100) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), rand() (type: double) - outputColumnNames: _col0, _col2 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + expressions: rand() (type: double) + outputColumnNames: _col2 + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (_col2 <= 0.1) (type: boolean) - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col2 (type: double) + expressions: '100' (type: string), _col2 (type: double) outputColumnNames: _col0, _col1 - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -71,34 +71,34 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1937 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 100) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), rand() (type: double) - outputColumnNames: _col0, _col2 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + expressions: rand() (type: double) + outputColumnNames: _col2 + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (_col2 <= 0.1) (type: boolean) - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col2 (type: double) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + expressions: _col2 (type: double) + outputColumnNames: _col1 + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (_col1 > 0.1) (type: boolean) - Statistics: Num rows: 3 Data size: 300 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 107 Data size: 321 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: double) + expressions: '100' (type: string), _col1 (type: double) outputColumnNames: _col0, _col1 - Statistics: Num rows: 3 Data size: 300 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 107 Data size: 321 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 20 - Statistics: Num rows: 3 Data size: 300 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 20 Data size: 60 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 3 Data size: 300 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 20 Data size: 60 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -130,24 +130,24 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1937 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 100) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), rand() (type: double), hex(4) (type: string) - outputColumnNames: _col0, _col2, _col3 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + expressions: rand() (type: double), '4' (type: string) + outputColumnNames: _col2, _col3 + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (_col3 <= 3) (type: boolean) - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col2 (type: double), _col3 (type: string) + expressions: '100' (type: string), _col2 (type: double), _col3 (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -179,24 +179,24 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 100) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), rand() (type: double), (value * 10) (type: double) - outputColumnNames: _col0, _col2, _col3 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: rand() (type: double), (value * 10) (type: double) + outputColumnNames: _col2, _col3 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (_col3 <= 200.0) (type: boolean) - Statistics: Num rows: 4 Data size: 801 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 9 Data size: 934 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col2 (type: double), _col3 (type: double) + expressions: '100' (type: string), _col2 (type: double), _col3 (type: double) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 4 Data size: 801 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 9 Data size: 934 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 4 Data size: 801 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 9 Data size: 934 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -228,24 +228,24 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1937 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 100) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), rand() (type: double) - outputColumnNames: _col0, _col2 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + expressions: rand() (type: double) + outputColumnNames: _col2 + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (_col2 <= 0.1) (type: boolean) - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col2 (type: double) + expressions: '100' (type: string), _col2 (type: double) outputColumnNames: _col0, _col1 - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -281,27 +281,27 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1937 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 100) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), rand() (type: double) - outputColumnNames: _col0, _col2 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + expressions: rand() (type: double) + outputColumnNames: _col2 + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: ((_col2 <= 0.1) and (_col2 > 0.1)) (type: boolean) - Statistics: Num rows: 3 Data size: 300 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 107 Data size: 321 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col2 (type: double) + expressions: '100' (type: string), _col2 (type: double) outputColumnNames: _col0, _col1 - Statistics: Num rows: 3 Data size: 300 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 107 Data size: 321 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 20 - Statistics: Num rows: 3 Data size: 300 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 20 Data size: 60 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 3 Data size: 300 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 20 Data size: 60 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -333,24 +333,24 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1937 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 100) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), rand() (type: double), hex(4) (type: string) - outputColumnNames: _col0, _col2, _col3 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + expressions: rand() (type: double), '4' (type: string) + outputColumnNames: _col2, _col3 + Statistics: Num rows: 968 Data size: 2904 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (_col3 <= 3) (type: boolean) - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col2 (type: double), _col3 (type: string) + expressions: '100' (type: string), _col2 (type: double), _col3 (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 322 Data size: 966 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -382,24 +382,24 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 56 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 100) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), rand() (type: double), (value * 10) (type: double) - outputColumnNames: _col0, _col2, _col3 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + expressions: rand() (type: double), (value * 10) (type: double) + outputColumnNames: _col2, _col3 + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (_col3 <= 200.0) (type: boolean) - Statistics: Num rows: 4 Data size: 801 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 9 Data size: 934 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col2 (type: double), _col3 (type: double) + expressions: '100' (type: string), _col2 (type: double), _col3 (type: double) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 4 Data size: 801 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 9 Data size: 934 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 4 Data size: 801 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 9 Data size: 934 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/ppd_union_view.q.out ql/src/test/results/clientpositive/ppd_union_view.q.out index 7b206c5..b7e1013 100644 --- ql/src/test/results/clientpositive/ppd_union_view.q.out +++ ql/src/test/results/clientpositive/ppd_union_view.q.out @@ -455,12 +455,12 @@ STAGE PLANS: condition map: Inner Join 0 to 1 condition expressions: - 0 {VALUE._col0} {KEY.reducesinkkey1} + 0 {VALUE._col0} 1 {VALUE._col0} - outputColumnNames: _col1, _col2, _col5 + outputColumnNames: _col1, _col5 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col5 (type: string), _col1 (type: string), _col2 (type: string) + expressions: _col5 (type: string), _col1 (type: string), '2011-10-15' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/query_result_fileformat.q.out ql/src/test/results/clientpositive/query_result_fileformat.q.out index 2b1fed8..014c7a1 100644 --- ql/src/test/results/clientpositive/query_result_fileformat.q.out +++ ql/src/test/results/clientpositive/query_result_fileformat.q.out @@ -53,7 +53,7 @@ STAGE PLANS: predicate: (key = 'key1') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: 'key1' (type: string), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -124,7 +124,7 @@ STAGE PLANS: predicate: (key = 'key1') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: 'key1' (type: string), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/quotedid_basic.q.out ql/src/test/results/clientpositive/quotedid_basic.q.out index 9478b99..0f86eed 100644 --- ql/src/test/results/clientpositive/quotedid_basic.q.out +++ ql/src/test/results/clientpositive/quotedid_basic.q.out @@ -76,7 +76,7 @@ STAGE PLANS: predicate: (!@#$%^&*()_q = '1') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + expressions: x+1 (type: string), y&y (type: string), '1' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -112,7 +112,7 @@ STAGE PLANS: predicate: (!@#$%^&*()_q = '1') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + expressions: x+1 (type: string), y&y (type: string), '1' (type: string) outputColumnNames: x+1, y&y, !@#$%^&*()_q Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Group By Operator @@ -171,7 +171,7 @@ STAGE PLANS: predicate: (!@#$%^&*()_q = '1') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + expressions: x+1 (type: string), y&y (type: string), '1' (type: string) outputColumnNames: x+1, y&y, !@#$%^&*()_q Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Group By Operator @@ -254,7 +254,7 @@ STAGE PLANS: predicate: (!@#$%^&*()_q = '1') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + expressions: x+1 (type: string), y&y (type: string), '1' (type: string) outputColumnNames: x+1, y&y, !@#$%^&*()_q Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Group By Operator diff --git ql/src/test/results/clientpositive/quotedid_partition.q.out ql/src/test/results/clientpositive/quotedid_partition.q.out index 84bd15e..014d93e 100644 --- ql/src/test/results/clientpositive/quotedid_partition.q.out +++ ql/src/test/results/clientpositive/quotedid_partition.q.out @@ -45,7 +45,7 @@ STAGE PLANS: predicate: (x+1 = '10') (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + expressions: '10' (type: string), y&y (type: string), !@#$%^&*()_q (type: string) outputColumnNames: x+1, y&y, !@#$%^&*()_q Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Group By Operator diff --git ql/src/test/results/clientpositive/regex_col.q.out ql/src/test/results/clientpositive/regex_col.q.out index e1f430a..ea4b1ca 100644 --- ql/src/test/results/clientpositive/regex_col.q.out +++ ql/src/test/results/clientpositive/regex_col.q.out @@ -173,26 +173,26 @@ STAGE PLANS: Map Operator Tree: TableScan alias: b - Statistics: Num rows: 232 Data size: 23248 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 7748 Data size: 23248 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 103) (type: boolean) - Statistics: Num rows: 116 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 3874 Data size: 11624 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string), hr (type: string), ds (type: string) + key expressions: hr (type: string), ds (type: string) sort order: +++ - Map-reduce partition columns: key (type: string), hr (type: string), ds (type: string) - Statistics: Num rows: 116 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: hr (type: string), ds (type: string) + Statistics: Num rows: 3874 Data size: 11624 Basic stats: COMPLETE Column stats: NONE TableScan alias: a - Statistics: Num rows: 232 Data size: 23248 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 7748 Data size: 23248 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 103) (type: boolean) - Statistics: Num rows: 116 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 3874 Data size: 11624 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string), hr (type: string), ds (type: string) + key expressions: hr (type: string), ds (type: string) sort order: +++ - Map-reduce partition columns: key (type: string), hr (type: string), ds (type: string) - Statistics: Num rows: 116 Data size: 11624 Basic stats: COMPLETE Column stats: NONE + Map-reduce partition columns: hr (type: string), ds (type: string) + Statistics: Num rows: 3874 Data size: 11624 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Join Operator condition map: @@ -201,11 +201,11 @@ STAGE PLANS: 0 1 {KEY.reducesinkkey2} {KEY.reducesinkkey1} outputColumnNames: _col8, _col9 - Statistics: Num rows: 127 Data size: 12786 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 4261 Data size: 12786 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col8 (type: string), _col9 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 127 Data size: 12786 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 4261 Data size: 12786 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -220,15 +220,15 @@ STAGE PLANS: Reduce Output Operator key expressions: _col0 (type: string), _col1 (type: string) sort order: ++ - Statistics: Num rows: 127 Data size: 12786 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 4261 Data size: 12786 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Select Operator expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 127 Data size: 12786 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 4261 Data size: 12786 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 127 Data size: 12786 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 4261 Data size: 12786 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/regexp_extract.q.out ql/src/test/results/clientpositive/regexp_extract.q.out index 6218e77..591a08b 100644 --- ql/src/test/results/clientpositive/regexp_extract.q.out +++ ql/src/test/results/clientpositive/regexp_extract.q.out @@ -98,7 +98,7 @@ STAGE PLANS: Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE GatherStats: false Select Operator - expressions: key (type: string), value (type: string), (1 + 2) (type: int), (3 + 4) (type: int) + expressions: key (type: string), value (type: string), 3 (type: int), 7 (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Transform Operator @@ -412,7 +412,7 @@ STAGE PLANS: Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE GatherStats: false Select Operator - expressions: key (type: string), value (type: string), (1 + 2) (type: int), (3 + 4) (type: int) + expressions: key (type: string), value (type: string), 3 (type: int), 7 (type: int) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Transform Operator diff --git ql/src/test/results/clientpositive/sample8.q.out ql/src/test/results/clientpositive/sample8.q.out index 7c37248..14bf7da 100644 --- ql/src/test/results/clientpositive/sample8.q.out +++ ql/src/test/results/clientpositive/sample8.q.out @@ -355,8 +355,8 @@ STAGE PLANS: predicate: ((((((_col6 = _col0) and (_col7 = _col1)) and (_col2 = '2008-04-08')) and (_col3 = '11')) and (_col2 = '2008-04-08')) and (_col3 = '11')) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator compressed: false @@ -367,8 +367,8 @@ STAGE PLANS: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat properties: - columns _col0,_col1,_col2,_col3 - columns.types string,string,string,string + columns _col0,_col1 + columns.types string,string escape.delim \ serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe @@ -387,7 +387,6 @@ STAGE PLANS: Map-reduce partition columns: _col0 (type: string), _col1 (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE tag: -1 - value expressions: _col2 (type: string), _col3 (type: string) Path -> Alias: #### A masked pattern was here #### Path -> Partition: @@ -397,8 +396,8 @@ STAGE PLANS: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat properties: - columns _col0,_col1,_col2,_col3 - columns.types string,string,string,string + columns _col0,_col1 + columns.types string,string escape.delim \ serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe @@ -406,8 +405,8 @@ STAGE PLANS: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat properties: - columns _col0,_col1,_col2,_col3 - columns.types string,string,string,string + columns _col0,_col1 + columns.types string,string escape.delim \ serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe @@ -416,7 +415,7 @@ STAGE PLANS: Needs Tagging: false Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string), VALUE._col0 (type: string), VALUE._col1 (type: string) + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string), '2008-04-08' (type: string), '11' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/select_dummy_source.q.out ql/src/test/results/clientpositive/select_dummy_source.q.out index 2742d56..651ce1d 100644 --- ql/src/test/results/clientpositive/select_dummy_source.q.out +++ ql/src/test/results/clientpositive/select_dummy_source.q.out @@ -64,7 +64,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: (1 + 1) (type: int) + expressions: 2 (type: int) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE File Output Operator @@ -193,7 +193,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: (1 + 1) (type: int) + expressions: 2 (type: int) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE ListSink @@ -277,7 +277,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: (2 + 3) (type: int), (1 + 2) (type: int) + expressions: 5 (type: int), (1 + 2) (type: int) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE File Output Operator diff --git ql/src/test/results/clientpositive/select_unquote_and.q.out ql/src/test/results/clientpositive/select_unquote_and.q.out index 47fed47..127fcb6 100644 --- ql/src/test/results/clientpositive/select_unquote_and.q.out +++ ql/src/test/results/clientpositive/select_unquote_and.q.out @@ -58,7 +58,7 @@ STAGE PLANS: alias: npe_test Statistics: Num rows: 498 Data size: 5290 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((ds > ((2012 - 11) - 31)) and (ds < ((2012 - 12) - 15))) (type: boolean) + predicate: ((ds > 1970) and (ds < 1985)) (type: boolean) Statistics: Num rows: 55 Data size: 584 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: key (type: string), value (type: string), ds (type: string) diff --git ql/src/test/results/clientpositive/select_unquote_not.q.out ql/src/test/results/clientpositive/select_unquote_not.q.out index ed35c10..0016c69 100644 --- ql/src/test/results/clientpositive/select_unquote_not.q.out +++ ql/src/test/results/clientpositive/select_unquote_not.q.out @@ -58,7 +58,7 @@ STAGE PLANS: alias: npe_test Statistics: Num rows: 498 Data size: 5290 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (not (ds < ((2012 - 11) - 31))) (type: boolean) + predicate: (not (ds < 1970)) (type: boolean) Statistics: Num rows: 332 Data size: 3526 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: key (type: string), value (type: string), ds (type: string) diff --git ql/src/test/results/clientpositive/select_unquote_or.q.out ql/src/test/results/clientpositive/select_unquote_or.q.out index 0425cca..537b9bb 100644 --- ql/src/test/results/clientpositive/select_unquote_or.q.out +++ ql/src/test/results/clientpositive/select_unquote_or.q.out @@ -58,7 +58,7 @@ STAGE PLANS: alias: npe_test Statistics: Num rows: 498 Data size: 5290 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((ds > ((2012 - 11) - 31)) or (ds < ((2012 - 12) - 15))) (type: boolean) + predicate: ((ds > 1970) or (ds < 1985)) (type: boolean) Statistics: Num rows: 332 Data size: 3526 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: key (type: string), value (type: string), ds (type: string) diff --git ql/src/test/results/clientpositive/set_processor_namespaces.q.out ql/src/test/results/clientpositive/set_processor_namespaces.q.out index df229ce..a863981 100644 --- ql/src/test/results/clientpositive/set_processor_namespaces.q.out +++ ql/src/test/results/clientpositive/set_processor_namespaces.q.out @@ -17,17 +17,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 5) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '5' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/set_variable_sub.q.out ql/src/test/results/clientpositive/set_variable_sub.q.out index bda25d7..097b1fb 100644 --- ql/src/test/results/clientpositive/set_variable_sub.q.out +++ ql/src/test/results/clientpositive/set_variable_sub.q.out @@ -12,17 +12,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 54 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 'value1') (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: 'value1' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -48,17 +48,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 54 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 'value1') (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: 'value1' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 27 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -84,17 +84,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = '1') (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '1' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/smb_mapjoin_18.q.out ql/src/test/results/clientpositive/smb_mapjoin_18.q.out index dbda142..e3a92c9 100644 --- ql/src/test/results/clientpositive/smb_mapjoin_18.q.out +++ ql/src/test/results/clientpositive/smb_mapjoin_18.q.out @@ -234,17 +234,25 @@ STAGE PLANS: predicate: (key = 238) (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string) - outputColumnNames: _col0, _col1 + expressions: value (type: string) + outputColumnNames: _col1 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false + Reduce Output Operator + sort order: + + Map-reduce partition columns: 238 (type: int) 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 - name: default.test_table2 + value expressions: 238 (type: int), _col1 (type: string) + Reduce Operator Tree: + Extract + 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 + name: default.test_table2 Stage: Stage-0 Move Operator diff --git ql/src/test/results/clientpositive/stats_empty_dyn_part.q.out ql/src/test/results/clientpositive/stats_empty_dyn_part.q.out index 267c285..6f76283 100644 --- ql/src/test/results/clientpositive/stats_empty_dyn_part.q.out +++ ql/src/test/results/clientpositive/stats_empty_dyn_part.q.out @@ -28,26 +28,26 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 51 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 'no_such_value') (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 25 Data size: 2849 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: 'no_such_value' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 25 Data size: 2849 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col1 (type: string) sort order: + Map-reduce partition columns: _col1 (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 25 Data size: 2849 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: string), _col1 (type: string) Reduce Operator Tree: Extract - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 25 Data size: 2849 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 25 Data size: 2849 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/subq_where_serialization.q.out ql/src/test/results/clientpositive/subq_where_serialization.q.out index d4d11a5..ff1d939 100644 --- ql/src/test/results/clientpositive/subq_where_serialization.q.out +++ ql/src/test/results/clientpositive/subq_where_serialization.q.out @@ -88,17 +88,15 @@ STAGE PLANS: 0 key (type: string) 1 _col0 (type: string) outputColumnNames: _col0 - Filter Operator - predicate: (1 = 1) (type: boolean) - Select Operator - expressions: _col0 (type: string) - outputColumnNames: _col0 - File Output Operator - compressed: false - 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 + expressions: _col0 (type: string) + outputColumnNames: _col0 + File Output Operator + compressed: false + 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 Local Work: Map Reduce Local Work @@ -128,20 +126,17 @@ STAGE PLANS: 1 outputColumnNames: _col0 Statistics: Num rows: 63 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 31 Data size: 3145 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string) - outputColumnNames: _col0 - Statistics: Num rows: 31 Data size: 3145 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 31 Data size: 3145 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 + expressions: _col0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 63 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 63 Data size: 6393 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 ql/src/test/results/clientpositive/subquery_exists.q.out ql/src/test/results/clientpositive/subquery_exists.q.out index 180a163..6dfe4f2 100644 --- ql/src/test/results/clientpositive/subquery_exists.q.out +++ ql/src/test/results/clientpositive/subquery_exists.q.out @@ -63,20 +63,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 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 + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 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 ql/src/test/results/clientpositive/subquery_exists_having.q.out ql/src/test/results/clientpositive/subquery_exists_having.q.out index 56986b7..ec5a8c7 100644 --- ql/src/test/results/clientpositive/subquery_exists_having.q.out +++ ql/src/test/results/clientpositive/subquery_exists_having.q.out @@ -101,20 +101,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 63 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 31 Data size: 3145 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: bigint) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 31 Data size: 3145 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 31 Data size: 3145 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 + expressions: _col0 (type: string), _col1 (type: bigint) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 63 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 63 Data size: 6393 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 ql/src/test/results/clientpositive/subquery_in.q.out ql/src/test/results/clientpositive/subquery_in.q.out index 2069101..749e03d 100644 --- ql/src/test/results/clientpositive/subquery_in.q.out +++ ql/src/test/results/clientpositive/subquery_in.q.out @@ -154,20 +154,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 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 + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 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 @@ -263,20 +260,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 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 + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 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 @@ -435,20 +429,17 @@ STAGE PLANS: 1 outputColumnNames: _col1, _col5 Statistics: Num rows: 33 Data size: 3490 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 16 Data size: 1692 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col1 (type: string), _col5 (type: int) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 16 Data size: 1692 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 16 Data size: 1692 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 + expressions: _col1 (type: string), _col5 (type: int) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 33 Data size: 3490 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 33 Data size: 3490 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 @@ -600,20 +591,17 @@ STAGE PLANS: 1 outputColumnNames: _col1, _col2, _col5 Statistics: Num rows: 16 Data size: 3490 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 8 Data size: 1745 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col2 (type: string), _col1 (type: string), _col5 (type: int) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 8 Data size: 1745 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 8 Data size: 1745 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 + expressions: _col2 (type: string), _col1 (type: string), _col5 (type: int) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 16 Data size: 3490 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 16 Data size: 3490 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 @@ -742,20 +730,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 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 + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 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 @@ -923,24 +908,24 @@ STAGE PLANS: value expressions: _col0 (type: int), _col3 (type: int) TableScan alias: lineitem - Statistics: Num rows: 116 Data size: 12099 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1728 Data size: 12099 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (l_shipmode = 'AIR') (type: boolean) - Statistics: Num rows: 58 Data size: 6049 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 864 Data size: 6049 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: l_orderkey (type: int) outputColumnNames: _col0 - Statistics: Num rows: 58 Data size: 6049 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 864 Data size: 6049 Basic stats: COMPLETE Column stats: NONE Group By Operator keys: _col0 (type: int) mode: hash outputColumnNames: _col0 - Statistics: Num rows: 58 Data size: 6049 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 864 Data size: 6049 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: int) sort order: + Map-reduce partition columns: _col0 (type: int) - Statistics: Num rows: 58 Data size: 6049 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 864 Data size: 6049 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Join Operator condition map: diff --git ql/src/test/results/clientpositive/subquery_in_having.q.out ql/src/test/results/clientpositive/subquery_in_having.q.out index 6e1eed0..ac8fdab 100644 --- ql/src/test/results/clientpositive/subquery_in_having.q.out +++ ql/src/test/results/clientpositive/subquery_in_having.q.out @@ -133,20 +133,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 63 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 31 Data size: 3145 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: bigint) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 31 Data size: 3145 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 31 Data size: 3145 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 + expressions: _col0 (type: string), _col1 (type: bigint) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 63 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 63 Data size: 6393 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-3 Map Reduce @@ -331,20 +328,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 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 + expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 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-3 Map Reduce @@ -492,20 +486,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 33 Data size: 3490 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 16 Data size: 1692 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: double) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 16 Data size: 1692 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 16 Data size: 1692 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 + expressions: _col0 (type: string), _col1 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 33 Data size: 3490 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 33 Data size: 3490 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-3 Map Reduce @@ -664,25 +655,22 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Group By Operator - aggregations: count() - keys: _col0 (type: string), _col1 (type: string) - mode: hash - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 15 Data size: 3093 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 + Select Operator + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: count() + keys: _col0 (type: string), _col1 (type: string) + mode: hash + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 31 Data size: 6393 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 @@ -692,7 +680,7 @@ STAGE PLANS: key expressions: _col0 (type: string), _col1 (type: string) sort order: ++ Map-reduce partition columns: _col0 (type: string), _col1 (type: string) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE value expressions: _col2 (type: bigint) Reduce Operator Tree: Group By Operator @@ -700,7 +688,7 @@ STAGE PLANS: keys: KEY._col0 (type: string), KEY._col1 (type: string) mode: mergepartial outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -716,7 +704,7 @@ STAGE PLANS: key expressions: _col2 (type: bigint) sort order: + Map-reduce partition columns: _col2 (type: bigint) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) TableScan Reduce Output Operator @@ -732,21 +720,18 @@ STAGE PLANS: 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} 1 outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 16 Data size: 3402 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 8 Data size: 1701 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 8 Data size: 1701 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 8 Data size: 1701 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 + Statistics: Num rows: 34 Data size: 7032 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 34 Data size: 7032 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 34 Data size: 7032 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-5 Map Reduce @@ -923,17 +908,15 @@ STAGE PLANS: 0 _col2 (type: bigint) 1 _col0 (type: bigint) outputColumnNames: _col0, _col1, _col2 - Filter Operator - predicate: (1 = 1) (type: boolean) - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) - outputColumnNames: _col0, _col1, _col2 - File Output Operator - compressed: false - 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 + expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) + outputColumnNames: _col0, _col1, _col2 + File Output Operator + compressed: false + 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 Local Work: Map Reduce Local Work @@ -945,7 +928,7 @@ STAGE PLANS: key expressions: _col2 (type: bigint) sort order: + Map-reduce partition columns: _col2 (type: bigint) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) TableScan Reduce Output Operator @@ -961,21 +944,18 @@ STAGE PLANS: 0 {VALUE._col0} {VALUE._col1} {VALUE._col2} 1 outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 16 Data size: 3402 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 8 Data size: 1701 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 8 Data size: 1701 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 8 Data size: 1701 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 + Statistics: Num rows: 34 Data size: 7032 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 34 Data size: 7032 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 34 Data size: 7032 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-10 Map Reduce Local Work @@ -1025,25 +1005,22 @@ STAGE PLANS: 1 _col0 (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Group By Operator - aggregations: count() - keys: _col0 (type: string), _col1 (type: string) - mode: hash - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - sort order: ++ - Map-reduce partition columns: _col0 (type: string), _col1 (type: string) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - value expressions: _col2 (type: bigint) + Select Operator + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: count() + keys: _col0 (type: string), _col1 (type: string) + mode: hash + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + value expressions: _col2 (type: bigint) Local Work: Map Reduce Local Work Reduce Operator Tree: @@ -1052,7 +1029,7 @@ STAGE PLANS: keys: KEY._col0 (type: string), KEY._col1 (type: string) mode: mergepartial outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -1159,17 +1136,15 @@ STAGE PLANS: 0 _col1 (type: string) 1 _col0 (type: string) outputColumnNames: _col0, _col1, _col2 - Filter Operator - predicate: (1 = 1) (type: boolean) - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: double) - outputColumnNames: _col0, _col1, _col2 - File Output Operator - compressed: false - 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 + expressions: _col0 (type: string), _col1 (type: string), _col2 (type: double) + outputColumnNames: _col0, _col1, _col2 + File Output Operator + compressed: false + 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 Local Work: Map Reduce Local Work @@ -1198,20 +1173,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 16 Data size: 3490 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 8 Data size: 1745 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: double) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 8 Data size: 1745 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 8 Data size: 1745 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 + expressions: _col0 (type: string), _col1 (type: string), _col2 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 16 Data size: 3490 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 16 Data size: 3490 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-3 Map Reduce diff --git ql/src/test/results/clientpositive/subquery_multiinsert.q.out ql/src/test/results/clientpositive/subquery_multiinsert.q.out index 3c2fab6..ea8b7c5 100644 --- ql/src/test/results/clientpositive/subquery_multiinsert.q.out +++ ql/src/test/results/clientpositive/subquery_multiinsert.q.out @@ -113,21 +113,18 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - table: - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - name: default.src_4 + Select Operator + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: default.src_4 Stage: Stage-0 Move Operator @@ -200,17 +197,17 @@ STAGE PLANS: condition map: Left Outer Join0 to 1 condition expressions: - 0 {KEY.reducesinkkey0} {VALUE._col0} + 0 {VALUE._col0} 1 {KEY.reducesinkkey0} - outputColumnNames: _col0, _col1, _col4 + outputColumnNames: _col1, _col4 Statistics: Num rows: 34 Data size: 7032 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col4 is null) (type: boolean) - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + predicate: _col4 is null (type: boolean) + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + expressions: _col1 (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -223,18 +220,17 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: null (type: void), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -372,125 +368,125 @@ POSTHOOK: query: select * from src_5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src_5 #### A masked pattern was here #### -0 val_0 -0 val_0 -0 val_0 -10 val_10 -100 val_100 -100 val_100 -103 val_103 -103 val_103 -104 val_104 -104 val_104 -105 val_105 -11 val_11 -111 val_111 -113 val_113 -113 val_113 -114 val_114 -116 val_116 -118 val_118 -118 val_118 -119 val_119 -119 val_119 -119 val_119 -12 val_12 -12 val_12 -120 val_120 -120 val_120 -125 val_125 -125 val_125 -126 val_126 -128 val_128 -128 val_128 -128 val_128 -129 val_129 -129 val_129 -131 val_131 -133 val_133 -134 val_134 -134 val_134 -136 val_136 -137 val_137 -137 val_137 -138 val_138 -138 val_138 -138 val_138 -138 val_138 -143 val_143 -145 val_145 -146 val_146 -146 val_146 -149 val_149 -149 val_149 -15 val_15 -15 val_15 -150 val_150 -152 val_152 -152 val_152 -153 val_153 -155 val_155 -156 val_156 -157 val_157 -158 val_158 -160 val_160 -162 val_162 -163 val_163 -164 val_164 -164 val_164 -165 val_165 -165 val_165 -166 val_166 -167 val_167 -167 val_167 -167 val_167 -168 val_168 -169 val_169 -169 val_169 -169 val_169 -169 val_169 -17 val_17 -170 val_170 -172 val_172 -172 val_172 -174 val_174 -174 val_174 -175 val_175 -175 val_175 -176 val_176 -176 val_176 -177 val_177 -178 val_178 -179 val_179 -179 val_179 -18 val_18 -18 val_18 -180 val_180 -181 val_181 -183 val_183 -186 val_186 -187 val_187 -187 val_187 -187 val_187 -189 val_189 -19 val_19 -190 val_190 -191 val_191 -191 val_191 -192 val_192 -193 val_193 -193 val_193 -193 val_193 -194 val_194 -195 val_195 -195 val_195 -196 val_196 -197 val_197 -197 val_197 -199 val_199 -199 val_199 -199 val_199 -2 val_2 +NULL val_2 +NULL val_199 +NULL val_199 +NULL val_199 +NULL val_197 +NULL val_197 +NULL val_196 +NULL val_195 +NULL val_195 +NULL val_194 +NULL val_193 +NULL val_193 +NULL val_193 +NULL val_192 +NULL val_191 +NULL val_191 +NULL val_190 +NULL val_19 +NULL val_189 +NULL val_187 +NULL val_187 +NULL val_187 +NULL val_186 +NULL val_183 +NULL val_181 +NULL val_180 +NULL val_18 +NULL val_18 +NULL val_179 +NULL val_179 +NULL val_178 +NULL val_177 +NULL val_176 +NULL val_176 +NULL val_175 +NULL val_175 +NULL val_174 +NULL val_174 +NULL val_172 +NULL val_172 +NULL val_170 +NULL val_17 +NULL val_169 +NULL val_169 +NULL val_169 +NULL val_169 +NULL val_168 +NULL val_167 +NULL val_167 +NULL val_167 +NULL val_166 +NULL val_165 +NULL val_165 +NULL val_164 +NULL val_164 +NULL val_163 +NULL val_162 +NULL val_160 +NULL val_158 +NULL val_157 +NULL val_156 +NULL val_155 +NULL val_153 +NULL val_152 +NULL val_152 +NULL val_150 +NULL val_15 +NULL val_15 +NULL val_149 +NULL val_149 +NULL val_146 +NULL val_146 +NULL val_145 +NULL val_143 +NULL val_138 +NULL val_138 +NULL val_138 +NULL val_138 +NULL val_137 +NULL val_137 +NULL val_136 +NULL val_134 +NULL val_134 +NULL val_133 +NULL val_131 +NULL val_129 +NULL val_129 +NULL val_128 +NULL val_128 +NULL val_128 +NULL val_126 +NULL val_125 +NULL val_125 +NULL val_120 +NULL val_120 +NULL val_12 +NULL val_12 +NULL val_119 +NULL val_119 +NULL val_119 +NULL val_118 +NULL val_118 +NULL val_116 +NULL val_114 +NULL val_113 +NULL val_113 +NULL val_111 +NULL val_11 +NULL val_105 +NULL val_104 +NULL val_104 +NULL val_103 +NULL val_103 +NULL val_100 +NULL val_100 +NULL val_10 +NULL val_0 +NULL val_0 +NULL val_0 Warning: Map Join MAPJOIN[103][bigTable=?] in task 'Stage-12:MAPRED' is a cross product Warning: Shuffle Join JOIN[29][tables = [b, sq_2_notin_nullcheck]] in Stage 'Stage-4:MAPRED' is a cross product PREHOOK: query: explain @@ -645,7 +641,7 @@ STAGE PLANS: Statistics: Num rows: 19 Data size: 1903 Basic stats: COMPLETE Column stats: NONE HashTable Sink Operator condition expressions: - 0 {_col0} {_col1} + 0 {_col1} 1 keys: 0 _col0 (type: string) @@ -659,35 +655,34 @@ STAGE PLANS: condition map: Left Outer Join0 to 1 condition expressions: - 0 {_col0} {_col1} + 0 {_col1} 1 {_col0} keys: 0 _col0 (type: string) 1 _col0 (type: string) - outputColumnNames: _col0, _col1, _col4 + outputColumnNames: _col1, _col4 Statistics: Num rows: 34 Data size: 7032 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col4 is null) (type: boolean) - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + predicate: _col4 is null (type: boolean) + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + expressions: _col1 (type: string) + outputColumnNames: _col1 + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: _col0 (type: string) sort order: + - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: string) Local Work: Map Reduce Local Work Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + expressions: null (type: void), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -783,21 +778,18 @@ STAGE PLANS: 1 _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - table: - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - name: default.src_4 + Select Operator + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: default.src_4 File Output Operator compressed: false table: @@ -897,122 +889,122 @@ POSTHOOK: query: select * from src_5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src_5 #### A masked pattern was here #### -0 val_0 -0 val_0 -0 val_0 -10 val_10 -100 val_100 -100 val_100 -103 val_103 -103 val_103 -104 val_104 -104 val_104 -105 val_105 -11 val_11 -111 val_111 -113 val_113 -113 val_113 -114 val_114 -116 val_116 -118 val_118 -118 val_118 -119 val_119 -119 val_119 -119 val_119 -12 val_12 -12 val_12 -120 val_120 -120 val_120 -125 val_125 -125 val_125 -126 val_126 -128 val_128 -128 val_128 -128 val_128 -129 val_129 -129 val_129 -131 val_131 -133 val_133 -134 val_134 -134 val_134 -136 val_136 -137 val_137 -137 val_137 -138 val_138 -138 val_138 -138 val_138 -138 val_138 -143 val_143 -145 val_145 -146 val_146 -146 val_146 -149 val_149 -149 val_149 -15 val_15 -15 val_15 -150 val_150 -152 val_152 -152 val_152 -153 val_153 -155 val_155 -156 val_156 -157 val_157 -158 val_158 -160 val_160 -162 val_162 -163 val_163 -164 val_164 -164 val_164 -165 val_165 -165 val_165 -166 val_166 -167 val_167 -167 val_167 -167 val_167 -168 val_168 -169 val_169 -169 val_169 -169 val_169 -169 val_169 -17 val_17 -170 val_170 -172 val_172 -172 val_172 -174 val_174 -174 val_174 -175 val_175 -175 val_175 -176 val_176 -176 val_176 -177 val_177 -178 val_178 -179 val_179 -179 val_179 -18 val_18 -18 val_18 -180 val_180 -181 val_181 -183 val_183 -186 val_186 -187 val_187 -187 val_187 -187 val_187 -189 val_189 -19 val_19 -190 val_190 -191 val_191 -191 val_191 -192 val_192 -193 val_193 -193 val_193 -193 val_193 -194 val_194 -195 val_195 -195 val_195 -196 val_196 -197 val_197 -197 val_197 -199 val_199 -199 val_199 -199 val_199 -2 val_2 +NULL val_169 +NULL val_126 +NULL val_194 +NULL val_152 +NULL val_183 +NULL val_18 +NULL val_167 +NULL val_186 +NULL val_146 +NULL val_100 +NULL val_18 +NULL val_134 +NULL val_189 +NULL val_175 +NULL val_133 +NULL val_172 +NULL val_136 +NULL val_178 +NULL val_169 +NULL val_120 +NULL val_199 +NULL val_119 +NULL val_163 +NULL val_104 +NULL val_187 +NULL val_164 +NULL val_125 +NULL val_164 +NULL val_12 +NULL val_114 +NULL val_190 +NULL val_105 +NULL val_175 +NULL val_104 +NULL val_193 +NULL val_2 +NULL val_128 +NULL val_191 +NULL val_116 +NULL val_167 +NULL val_113 +NULL val_103 +NULL val_138 +NULL val_149 +NULL val_119 +NULL val_195 +NULL val_160 +NULL val_143 +NULL val_168 +NULL val_11 +NULL val_177 +NULL val_10 +NULL val_19 +NULL val_118 +NULL val_15 +NULL val_138 +NULL val_134 +NULL val_118 +NULL val_179 +NULL val_0 +NULL val_169 +NULL val_137 +NULL val_187 +NULL val_197 +NULL val_196 +NULL val_156 +NULL val_131 +NULL val_120 +NULL val_165 +NULL val_191 +NULL val_199 +NULL val_100 +NULL val_197 +NULL val_0 +NULL val_119 +NULL val_158 +NULL val_129 +NULL val_172 +NULL val_179 +NULL val_138 +NULL val_181 +NULL val_12 +NULL val_180 +NULL val_137 +NULL val_176 +NULL val_103 +NULL val_138 +NULL val_176 +NULL val_187 +NULL val_192 +NULL val_125 +NULL val_169 +NULL val_111 +NULL val_157 +NULL val_170 +NULL val_129 +NULL val_149 +NULL val_128 +NULL val_0 +NULL val_155 +NULL val_113 +NULL val_17 +NULL val_195 +NULL val_167 +NULL val_162 +NULL val_174 +NULL val_199 +NULL val_174 +NULL val_193 +NULL val_153 +NULL val_166 +NULL val_15 +NULL val_145 +NULL val_152 +NULL val_146 +NULL val_128 +NULL val_150 +NULL val_193 +NULL val_165 diff --git ql/src/test/results/clientpositive/subquery_notexists.q.out ql/src/test/results/clientpositive/subquery_notexists.q.out index 6c76dd2..2a0dfa6 100644 --- ql/src/test/results/clientpositive/subquery_notexists.q.out +++ ql/src/test/results/clientpositive/subquery_notexists.q.out @@ -59,15 +59,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col6 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col6 is null) (type: boolean) - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + predicate: _col6 is null (type: boolean) + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -312,15 +312,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col5 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col5 is null) (type: boolean) - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + predicate: _col5 is null (type: boolean) + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/subquery_notexists_having.q.out ql/src/test/results/clientpositive/subquery_notexists_having.q.out index a625333..e2c5e43 100644 --- ql/src/test/results/clientpositive/subquery_notexists_having.q.out +++ ql/src/test/results/clientpositive/subquery_notexists_having.q.out @@ -93,15 +93,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col4 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col4 is null) (type: boolean) - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + predicate: _col4 is null (type: boolean) + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -237,15 +237,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col3 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col3 is null) (type: boolean) - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + predicate: _col3 is null (type: boolean) + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/subquery_notin.q.out ql/src/test/results/clientpositive/subquery_notin.q.out index 8cf191e..4cbbdcc 100644 --- ql/src/test/results/clientpositive/subquery_notin.q.out +++ ql/src/test/results/clientpositive/subquery_notin.q.out @@ -228,15 +228,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col4 Statistics: Num rows: 34 Data size: 7032 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col4 is null) (type: boolean) - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + predicate: _col4 is null (type: boolean) + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 8 Data size: 1654 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 3516 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -263,125 +263,125 @@ order by key POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### -0 val_0 -0 val_0 -0 val_0 -10 val_10 -100 val_100 -100 val_100 -103 val_103 -103 val_103 -104 val_104 -104 val_104 -105 val_105 -11 val_11 -111 val_111 -113 val_113 -113 val_113 -114 val_114 -116 val_116 -118 val_118 -118 val_118 -119 val_119 -119 val_119 -119 val_119 -12 val_12 -12 val_12 -120 val_120 -120 val_120 -125 val_125 -125 val_125 -126 val_126 -128 val_128 -128 val_128 -128 val_128 -129 val_129 -129 val_129 -131 val_131 -133 val_133 -134 val_134 -134 val_134 -136 val_136 -137 val_137 -137 val_137 -138 val_138 -138 val_138 -138 val_138 -138 val_138 -143 val_143 -145 val_145 -146 val_146 -146 val_146 -149 val_149 -149 val_149 -15 val_15 -15 val_15 -150 val_150 -152 val_152 -152 val_152 -153 val_153 -155 val_155 -156 val_156 -157 val_157 -158 val_158 -160 val_160 -162 val_162 -163 val_163 -164 val_164 -164 val_164 -165 val_165 -165 val_165 -166 val_166 -167 val_167 -167 val_167 -167 val_167 -168 val_168 -169 val_169 -169 val_169 -169 val_169 -169 val_169 -17 val_17 -170 val_170 -172 val_172 -172 val_172 -174 val_174 -174 val_174 -175 val_175 -175 val_175 -176 val_176 -176 val_176 -177 val_177 -178 val_178 -179 val_179 -179 val_179 -18 val_18 -18 val_18 -180 val_180 -181 val_181 -183 val_183 -186 val_186 -187 val_187 -187 val_187 -187 val_187 -189 val_189 -19 val_19 -190 val_190 -191 val_191 -191 val_191 -192 val_192 -193 val_193 -193 val_193 -193 val_193 -194 val_194 -195 val_195 -195 val_195 -196 val_196 -197 val_197 -197 val_197 -199 val_199 -199 val_199 -199 val_199 -2 val_2 +NULL val_2 +NULL val_199 +NULL val_199 +NULL val_199 +NULL val_197 +NULL val_197 +NULL val_196 +NULL val_195 +NULL val_195 +NULL val_194 +NULL val_193 +NULL val_193 +NULL val_193 +NULL val_192 +NULL val_191 +NULL val_191 +NULL val_190 +NULL val_19 +NULL val_189 +NULL val_187 +NULL val_187 +NULL val_187 +NULL val_186 +NULL val_183 +NULL val_181 +NULL val_180 +NULL val_18 +NULL val_18 +NULL val_179 +NULL val_179 +NULL val_178 +NULL val_177 +NULL val_176 +NULL val_176 +NULL val_175 +NULL val_175 +NULL val_174 +NULL val_174 +NULL val_172 +NULL val_172 +NULL val_170 +NULL val_17 +NULL val_169 +NULL val_169 +NULL val_169 +NULL val_169 +NULL val_168 +NULL val_167 +NULL val_167 +NULL val_167 +NULL val_166 +NULL val_165 +NULL val_165 +NULL val_164 +NULL val_164 +NULL val_163 +NULL val_162 +NULL val_160 +NULL val_158 +NULL val_157 +NULL val_156 +NULL val_155 +NULL val_153 +NULL val_152 +NULL val_152 +NULL val_150 +NULL val_15 +NULL val_15 +NULL val_149 +NULL val_149 +NULL val_146 +NULL val_146 +NULL val_145 +NULL val_143 +NULL val_138 +NULL val_138 +NULL val_138 +NULL val_138 +NULL val_137 +NULL val_137 +NULL val_136 +NULL val_134 +NULL val_134 +NULL val_133 +NULL val_131 +NULL val_129 +NULL val_129 +NULL val_128 +NULL val_128 +NULL val_128 +NULL val_126 +NULL val_125 +NULL val_125 +NULL val_120 +NULL val_120 +NULL val_12 +NULL val_12 +NULL val_119 +NULL val_119 +NULL val_119 +NULL val_118 +NULL val_118 +NULL val_116 +NULL val_114 +NULL val_113 +NULL val_113 +NULL val_111 +NULL val_11 +NULL val_105 +NULL val_104 +NULL val_104 +NULL val_103 +NULL val_103 +NULL val_100 +NULL val_100 +NULL val_10 +NULL val_0 +NULL val_0 +NULL val_0 Warning: Shuffle Join JOIN[26][tables = [b, sq_1_notin_nullcheck]] in Stage 'Stage-1:MAPRED' is a cross product PREHOOK: query: -- non agg, corr explain @@ -469,15 +469,15 @@ STAGE PLANS: outputColumnNames: _col1, _col2, _col5, _col11 Statistics: Num rows: 17 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col11 is null) (type: boolean) - Statistics: Num rows: 4 Data size: 903 Basic stats: COMPLETE Column stats: NONE + predicate: _col11 is null (type: boolean) + Statistics: Num rows: 8 Data size: 1806 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col2 (type: string), _col1 (type: string), _col5 (type: int) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 4 Data size: 903 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 1806 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 4 Data size: 903 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 1806 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -743,15 +743,15 @@ STAGE PLANS: outputColumnNames: _col1, _col5, _col11 Statistics: Num rows: 36 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col11 is null) (type: boolean) - Statistics: Num rows: 9 Data size: 959 Basic stats: COMPLETE Column stats: NONE + predicate: _col11 is null (type: boolean) + Statistics: Num rows: 18 Data size: 1919 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: string), _col5 (type: int) outputColumnNames: _col0, _col1 - Statistics: Num rows: 9 Data size: 959 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 18 Data size: 1919 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 9 Data size: 959 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 18 Data size: 1919 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -1040,15 +1040,15 @@ STAGE PLANS: outputColumnNames: _col1, _col2, _col5, _col11 Statistics: Num rows: 17 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col11 is null) (type: boolean) - Statistics: Num rows: 4 Data size: 903 Basic stats: COMPLETE Column stats: NONE + predicate: _col11 is null (type: boolean) + Statistics: Num rows: 8 Data size: 1806 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col2 (type: string), _col1 (type: string), _col5 (type: int) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 4 Data size: 903 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 1806 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 4 Data size: 903 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 1806 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -1287,125 +1287,125 @@ order by key POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### -0 val_0 -0 val_0 -0 val_0 -10 val_10 -100 val_100 -100 val_100 -103 val_103 -103 val_103 -104 val_104 -104 val_104 -105 val_105 -11 val_11 -111 val_111 -113 val_113 -113 val_113 -114 val_114 -116 val_116 -118 val_118 -118 val_118 -119 val_119 -119 val_119 -119 val_119 -12 val_12 -12 val_12 -120 val_120 -120 val_120 -125 val_125 -125 val_125 -126 val_126 -128 val_128 -128 val_128 -128 val_128 -129 val_129 -129 val_129 -131 val_131 -133 val_133 -134 val_134 -134 val_134 -136 val_136 -137 val_137 -137 val_137 -138 val_138 -138 val_138 -138 val_138 -138 val_138 -143 val_143 -145 val_145 -146 val_146 -146 val_146 -149 val_149 -149 val_149 -15 val_15 -15 val_15 -150 val_150 -152 val_152 -152 val_152 -153 val_153 -155 val_155 -156 val_156 -157 val_157 -158 val_158 -160 val_160 -162 val_162 -163 val_163 -164 val_164 -164 val_164 -165 val_165 -165 val_165 -166 val_166 -167 val_167 -167 val_167 -167 val_167 -168 val_168 -169 val_169 -169 val_169 -169 val_169 -169 val_169 -17 val_17 -170 val_170 -172 val_172 -172 val_172 -174 val_174 -174 val_174 -175 val_175 -175 val_175 -176 val_176 -176 val_176 -177 val_177 -178 val_178 -179 val_179 -179 val_179 -18 val_18 -18 val_18 -180 val_180 -181 val_181 -183 val_183 -186 val_186 -187 val_187 -187 val_187 -187 val_187 -189 val_189 -19 val_19 -190 val_190 -191 val_191 -191 val_191 -192 val_192 -193 val_193 -193 val_193 -193 val_193 -194 val_194 -195 val_195 -195 val_195 -196 val_196 -197 val_197 -197 val_197 -199 val_199 -199 val_199 -199 val_199 -2 val_2 +NULL val_2 +NULL val_199 +NULL val_199 +NULL val_199 +NULL val_197 +NULL val_197 +NULL val_196 +NULL val_195 +NULL val_195 +NULL val_194 +NULL val_193 +NULL val_193 +NULL val_193 +NULL val_192 +NULL val_191 +NULL val_191 +NULL val_190 +NULL val_19 +NULL val_189 +NULL val_187 +NULL val_187 +NULL val_187 +NULL val_186 +NULL val_183 +NULL val_181 +NULL val_180 +NULL val_18 +NULL val_18 +NULL val_179 +NULL val_179 +NULL val_178 +NULL val_177 +NULL val_176 +NULL val_176 +NULL val_175 +NULL val_175 +NULL val_174 +NULL val_174 +NULL val_172 +NULL val_172 +NULL val_170 +NULL val_17 +NULL val_169 +NULL val_169 +NULL val_169 +NULL val_169 +NULL val_168 +NULL val_167 +NULL val_167 +NULL val_167 +NULL val_166 +NULL val_165 +NULL val_165 +NULL val_164 +NULL val_164 +NULL val_163 +NULL val_162 +NULL val_160 +NULL val_158 +NULL val_157 +NULL val_156 +NULL val_155 +NULL val_153 +NULL val_152 +NULL val_152 +NULL val_150 +NULL val_15 +NULL val_15 +NULL val_149 +NULL val_149 +NULL val_146 +NULL val_146 +NULL val_145 +NULL val_143 +NULL val_138 +NULL val_138 +NULL val_138 +NULL val_138 +NULL val_137 +NULL val_137 +NULL val_136 +NULL val_134 +NULL val_134 +NULL val_133 +NULL val_131 +NULL val_129 +NULL val_129 +NULL val_128 +NULL val_128 +NULL val_128 +NULL val_126 +NULL val_125 +NULL val_125 +NULL val_120 +NULL val_120 +NULL val_12 +NULL val_12 +NULL val_119 +NULL val_119 +NULL val_119 +NULL val_118 +NULL val_118 +NULL val_116 +NULL val_114 +NULL val_113 +NULL val_113 +NULL val_111 +NULL val_11 +NULL val_105 +NULL val_104 +NULL val_104 +NULL val_103 +NULL val_103 +NULL val_100 +NULL val_100 +NULL val_10 +NULL val_0 +NULL val_0 +NULL val_0 PREHOOK: query: -- null check create view T1_v as select key from src where key <'11' @@ -1567,15 +1567,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1 Statistics: Num rows: 22 Data size: 2302 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col1 is null) (type: boolean) - Statistics: Num rows: 5 Data size: 523 Basic stats: COMPLETE Column stats: NONE + predicate: _col1 is null (type: boolean) + Statistics: Num rows: 11 Data size: 1151 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string) outputColumnNames: _col0 - Statistics: Num rows: 5 Data size: 523 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 11 Data size: 1151 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 5 Data size: 523 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 11 Data size: 1151 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/subquery_notin_having.q.out ql/src/test/results/clientpositive/subquery_notin_having.q.out index 4f9fb13..55b6b71 100644 --- ql/src/test/results/clientpositive/subquery_notin_having.q.out +++ ql/src/test/results/clientpositive/subquery_notin_having.q.out @@ -176,15 +176,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 69 Data size: 7032 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col2 is null) (type: boolean) - Statistics: Num rows: 17 Data size: 1732 Basic stats: COMPLETE Column stats: NONE + predicate: _col2 is null (type: boolean) + Statistics: Num rows: 34 Data size: 3465 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: bigint) outputColumnNames: _col0, _col1 - Statistics: Num rows: 17 Data size: 1732 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 34 Data size: 3465 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 17 Data size: 1732 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 34 Data size: 3465 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -354,15 +354,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col4 Statistics: Num rows: 34 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col4 is null) (type: boolean) - Statistics: Num rows: 8 Data size: 903 Basic stats: COMPLETE Column stats: NONE + predicate: _col4 is null (type: boolean) + Statistics: Num rows: 17 Data size: 1919 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: double) outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 903 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 1919 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 8 Data size: 903 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 1919 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -646,15 +646,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col3 Statistics: Num rows: 34 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col3 is null) (type: boolean) - Statistics: Num rows: 8 Data size: 903 Basic stats: COMPLETE Column stats: NONE + predicate: _col3 is null (type: boolean) + Statistics: Num rows: 17 Data size: 1919 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: double) outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 903 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 1919 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 8 Data size: 903 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 1919 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -670,7 +670,7 @@ STAGE PLANS: predicate: p_mfgr is null (type: boolean) Statistics: Num rows: 14 Data size: 1531 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: p_mfgr (type: string), p_retailprice (type: double) + expressions: null (type: void), p_retailprice (type: double) outputColumnNames: p_mfgr, p_retailprice Statistics: Num rows: 14 Data size: 1531 Basic stats: COMPLETE Column stats: NONE Group By Operator diff --git ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out index 43a3256..843c0c5 100644 --- ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out +++ ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out @@ -116,20 +116,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 9 Data size: 1983 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 4 Data size: 881 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 881 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 4 Data size: 881 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 + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 9 Data size: 1983 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 9 Data size: 1983 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 @@ -186,20 +183,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 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 + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 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 @@ -329,20 +323,17 @@ STAGE PLANS: 1 outputColumnNames: _col1, _col2, _col5 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) + Select Operator + expressions: _col2 (type: string), _col1 (type: string), _col5 (type: int) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - Select Operator - expressions: _col2 (type: string), _col1 (type: string), _col5 (type: int) - outputColumnNames: _col0, _col1, _col2 + File Output Operator + compressed: false Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE 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 + 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 @@ -470,20 +461,17 @@ STAGE PLANS: 1 outputColumnNames: _col1, _col2, _col5 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) + Select Operator + expressions: _col2 (type: string), _col1 (type: string), _col5 (type: int) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - Select Operator - expressions: _col2 (type: string), _col1 (type: string), _col5 (type: int) - outputColumnNames: _col0, _col1, _col2 + File Output Operator + compressed: false Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE 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 + 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 @@ -588,20 +576,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 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 + expressions: _col0 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 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 @@ -691,20 +676,17 @@ STAGE PLANS: 1 outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: (1 = 1) (type: boolean) - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 15 Data size: 3093 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - Statistics: Num rows: 15 Data size: 3093 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 + expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 31 Data size: 6393 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-3 Map Reduce @@ -847,7 +829,7 @@ STAGE PLANS: outputColumnNames: _col1, _col2, _col5, _col11 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col11 is null) (type: boolean) + predicate: _col11 is null (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator expressions: _col2 (type: string), _col1 (type: string), _col5 (type: int) diff --git ql/src/test/results/clientpositive/transform_ppr1.q.out ql/src/test/results/clientpositive/transform_ppr1.q.out index 88baa2c..d152380 100644 --- ql/src/test/results/clientpositive/transform_ppr1.q.out +++ ql/src/test/results/clientpositive/transform_ppr1.q.out @@ -130,7 +130,7 @@ STAGE PLANS: Map-reduce partition columns: _col1 (type: string) Statistics: Num rows: 19 Data size: 3807 Basic stats: COMPLETE Column stats: NONE tag: -1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string) + value expressions: '2008-04-08' (type: string), _col1 (type: string), _col2 (type: string) Path -> Alias: #### A masked pattern was here #### Path -> Partition: diff --git ql/src/test/results/clientpositive/truncate_column_list_bucket.q.out ql/src/test/results/clientpositive/truncate_column_list_bucket.q.out index be8fafc..2ffcb01 100644 --- ql/src/test/results/clientpositive/truncate_column_list_bucket.q.out +++ ql/src/test/results/clientpositive/truncate_column_list_bucket.q.out @@ -102,22 +102,22 @@ STAGE PLANS: Map Operator Tree: TableScan alias: test_tab - Statistics: Num rows: 8 Data size: 1761 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 1761 Basic stats: COMPLETE Column stats: NONE GatherStats: false Filter Operator isSamplingPred: false predicate: (key = '484') (type: boolean) - Statistics: Num rows: 4 Data size: 880 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 828 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), part (type: string) + expressions: '484' (type: string), value (type: string), part (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 4 Data size: 880 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 828 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false GlobalTableId: 0 #### A masked pattern was here #### NumFilesPerFileSink: 1 - Statistics: Num rows: 4 Data size: 880 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 828 Basic stats: COMPLETE Column stats: NONE #### A masked pattern was here #### table: input format: org.apache.hadoop.mapred.TextInputFormat @@ -241,22 +241,22 @@ STAGE PLANS: Map Operator Tree: TableScan alias: test_tab - Statistics: Num rows: 8 Data size: 1761 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 17 Data size: 1761 Basic stats: COMPLETE Column stats: NONE GatherStats: false Filter Operator isSamplingPred: false predicate: (key = '0') (type: boolean) - Statistics: Num rows: 4 Data size: 880 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 828 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string), part (type: string) + expressions: '0' (type: string), value (type: string), part (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 4 Data size: 880 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 828 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false GlobalTableId: 0 #### A masked pattern was here #### NumFilesPerFileSink: 1 - Statistics: Num rows: 4 Data size: 880 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 8 Data size: 828 Basic stats: COMPLETE Column stats: NONE #### A masked pattern was here #### table: input format: org.apache.hadoop.mapred.TextInputFormat diff --git ql/src/test/results/clientpositive/type_cast_1.q.out ql/src/test/results/clientpositive/type_cast_1.q.out index d337727..85930ea 100644 --- ql/src/test/results/clientpositive/type_cast_1.q.out +++ ql/src/test/results/clientpositive/type_cast_1.q.out @@ -16,7 +16,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: (if(false, 1, UDFToShort(2)) + 3) (type: int) + expressions: 5 (type: int) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit diff --git ql/src/test/results/clientpositive/type_widening.q.out ql/src/test/results/clientpositive/type_widening.q.out index f1901f4..e48473f 100644 --- ql/src/test/results/clientpositive/type_widening.q.out +++ ql/src/test/results/clientpositive/type_widening.q.out @@ -16,7 +16,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: COALESCE(0,9223372036854775807) (type: bigint) + expressions: 0 (type: bigint) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Limit diff --git ql/src/test/results/clientpositive/udf1.q.out ql/src/test/results/clientpositive/udf1.q.out index 6ce78a2..2a8aad4 100644 --- ql/src/test/results/clientpositive/udf1.q.out +++ ql/src/test/results/clientpositive/udf1.q.out @@ -47,17 +47,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 86) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: ('a' like '%a%') (type: boolean), ('b' like '%a%') (type: boolean), ('ab' like '%a%') (type: boolean), ('ab' like '%a_') (type: boolean), ('%_' like '\%\_') (type: boolean), ('ab' like '\%\_') (type: boolean), ('ab' like '_a%') (type: boolean), ('ab' like 'a') (type: boolean), ('' rlike '.*') (type: boolean), ('a' rlike '[ab]') (type: boolean), ('' rlike '[ab]') (type: boolean), ('hadoop' rlike '[a-z]*') (type: boolean), ('hadoop' rlike 'o*') (type: boolean), regexp_replace('abc', 'b', 'c') (type: string), regexp_replace('abc', 'z', 'a') (type: string), regexp_replace('abbbb', 'bb', 'b') (type: string), regexp_replace('hadoop', '(.)[a-z]*', '$1ive') (type: string), regexp_replace('hadoopAAA', 'A.*', '') (type: string), regexp_replace('abc', '', 'A') (type: string), ('abc' rlike '') (type: boolean) + expressions: true (type: boolean), false (type: boolean), true (type: boolean), true (type: boolean), true (type: boolean), false (type: boolean), false (type: boolean), false (type: boolean), true (type: boolean), true (type: boolean), false (type: boolean), true (type: boolean), true (type: boolean), 'acc' (type: string), 'abc' (type: string), 'abb' (type: string), 'hive' (type: string), 'hadoop' (type: string), 'AaAbAcA' (type: string), false (type: boolean) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/udf4.q.out ql/src/test/results/clientpositive/udf4.q.out index d1bb2ba..81e5470 100644 --- ql/src/test/results/clientpositive/udf4.q.out +++ ql/src/test/results/clientpositive/udf4.q.out @@ -76,7 +76,7 @@ STAGE PLANS: alias: dest1 Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: round(1.0) (type: double), round(1.5) (type: double), round((- 1.5)) (type: double), floor(1.0) (type: bigint), floor(1.5) (type: bigint), floor((- 1.5)) (type: bigint), sqrt(1.0) (type: double), sqrt((- 1.0)) (type: double), sqrt(0.0) (type: double), ceil(1.0) (type: bigint), ceil(1.5) (type: bigint), ceil((- 1.5)) (type: bigint), ceil(1.0) (type: bigint), rand(3) (type: double), 3 (type: int), (- 3) (type: int), (1 + 2) (type: int), (1 + (- 2)) (type: int), (~ 1) (type: int), (~ UDFToByte(1)) (type: tinyint), (~ UDFToShort(1)) (type: smallint), (~ UDFToLong(1)) (type: bigint), (UDFToByte(1) & UDFToByte(2)) (type: tinyint), (UDFToShort(1) & UDFToShort(2)) (type: smallint), (1 & 2) (type: int), (UDFToLong(1) & UDFToLong(2)) (type: bigint), (UDFToByte(1) | UDFToByte(2)) (type: tinyint), (UDFToShort(1) | UDFToShort(2)) (type: smallint), (1 | 2) (type: int), (UDFToLong(1) | UDFToLong(2)) (type: bigint), (UDFToByte(1) ^ UDFToByte(3)) (type: tinyint), (UDFToShort(1) ^ UDFToShort(3)) (type: smallint), (1 ^ 3) (type: int), (UDFToLong(1) ^ UDFToLong(3)) (type: bigint) + expressions: 1.0 (type: double), 2.0 (type: double), -2.0 (type: double), 1 (type: bigint), 1 (type: bigint), -2 (type: bigint), 1.0 (type: double), null (type: void), 0.0 (type: double), 1 (type: bigint), 2 (type: bigint), -1 (type: bigint), 1 (type: bigint), rand(3) (type: double), 3 (type: int), -3 (type: int), 3 (type: int), -1 (type: int), -2 (type: int), -2 (type: tinyint), -2 (type: smallint), -2 (type: bigint), 0 (type: tinyint), 0 (type: smallint), 0 (type: int), 0 (type: bigint), 3 (type: tinyint), 3 (type: smallint), 3 (type: int), 3 (type: bigint), 2 (type: tinyint), 2 (type: smallint), 2 (type: int), 2 (type: bigint) 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 Statistics: Num rows: 1 Data size: 208 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator diff --git ql/src/test/results/clientpositive/udf5.q.out ql/src/test/results/clientpositive/udf5.q.out index b8671f3..7096275 100644 --- ql/src/test/results/clientpositive/udf5.q.out +++ ql/src/test/results/clientpositive/udf5.q.out @@ -32,7 +32,7 @@ STAGE PLANS: alias: dest1 Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: from_unixtime(1226446340) (type: string), to_date(from_unixtime(1226446340)) (type: string), day('2008-11-01') (type: int), month('2008-11-01') (type: int), year('2008-11-01') (type: int), day('2008-11-01 15:32:20') (type: int), month('2008-11-01 15:32:20') (type: int), year('2008-11-01 15:32:20') (type: int) + expressions: '2008-11-11 15:32:20' (type: string), '2008-11-11' (type: string), 1 (type: int), 11 (type: int), 2008 (type: int), 1 (type: int), 11 (type: int), 2008 (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 Statistics: Num rows: 1 Data size: 221 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator diff --git ql/src/test/results/clientpositive/udf6.q.out ql/src/test/results/clientpositive/udf6.q.out index 595354b..a3ac65f 100644 --- ql/src/test/results/clientpositive/udf6.q.out +++ ql/src/test/results/clientpositive/udf6.q.out @@ -32,7 +32,7 @@ STAGE PLANS: alias: dest1 Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: if(true, 1, 2) (type: int) + expressions: 1 (type: int) outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator @@ -86,7 +86,7 @@ STAGE PLANS: alias: dest1 Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: if(true, 1, 2) (type: int), if(false, 1, 2) (type: int), if(null, 1, 2) (type: int), if(true, 'a', 'b') (type: string), if(true, 0.1, 0.2) (type: double), if(false, UDFToLong(1), UDFToLong(2)) (type: bigint), if(false, UDFToByte(127), UDFToByte(126)) (type: tinyint), if(false, UDFToShort(127), UDFToShort(128)) (type: smallint), 128 (type: int), 1.0 (type: double), '128' (type: string) + expressions: 1 (type: int), 2 (type: int), if(null, 1, 2) (type: int), 'a' (type: string), 0.1 (type: double), 2 (type: bigint), 126 (type: tinyint), 128 (type: smallint), 128 (type: int), 1.0 (type: double), '128' (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator diff --git ql/src/test/results/clientpositive/udf7.q.out ql/src/test/results/clientpositive/udf7.q.out index a53387d..c4eef14 100644 --- ql/src/test/results/clientpositive/udf7.q.out +++ ql/src/test/results/clientpositive/udf7.q.out @@ -46,7 +46,7 @@ STAGE PLANS: alias: dest1 Statistics: Num rows: 1 Data size: 7 Basic stats: COMPLETE Column stats: COMPLETE Select Operator - expressions: round(ln(3.0), 12) (type: double), ln(0.0) (type: double), ln((- 1)) (type: double), round(log(3.0), 12) (type: double), log(0.0) (type: double), log((- 1)) (type: double), round(log2(3.0), 12) (type: double), log2(0.0) (type: double), log2((- 1)) (type: double), round(log10(3.0), 12) (type: double), log10(0.0) (type: double), log10((- 1)) (type: double), round(log(2, 3.0), 12) (type: double), log(2, 0.0) (type: double), log(2, (- 1)) (type: double), log(0.5, 2) (type: double), log(2, 0.5) (type: double), round(exp(2.0), 12) (type: double), power(2, 3) (type: double), power(2, 3) (type: double), power(2, (- 3)) (type: double), power(0.5, (- 3)) (type: double), power(4, 0.5) (type: double), power((- 1), 0.5) (type: double), power((- 1), 2) (type: double), power(CAST( 1 AS decimal(10,0)), 0) (type: double), power(CAST( 2 AS decimal(10,0)), 3) (type: double), power(CAST( 2 AS decimal(10,0)), 3) (type: double) + expressions: 1.098612288668 (type: double), null (type: void), null (type: void), 1.098612288668 (type: double), null (type: void), null (type: void), 1.584962500721 (type: double), null (type: void), null (type: void), 0.47712125472 (type: double), null (type: void), null (type: void), 1.584962500721 (type: double), null (type: void), null (type: void), null (type: void), -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), power(CAST( 1 AS decimal(10,0)), 0) (type: double), power(CAST( 2 AS decimal(10,0)), 3) (type: double), power(CAST( 2 AS decimal(10,0)), 3) (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: 224 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator diff --git ql/src/test/results/clientpositive/udf9.q.out ql/src/test/results/clientpositive/udf9.q.out index 4d25988..0c156f5 100644 --- ql/src/test/results/clientpositive/udf9.q.out +++ ql/src/test/results/clientpositive/udf9.q.out @@ -30,17 +30,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 86) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: datediff('2008-12-31', '2009-01-01') (type: int), datediff('2008-03-01', '2008-02-28') (type: int), datediff('2007-03-01', '2007-01-28') (type: int), datediff('2008-03-01 23:59:59', '2008-03-02 00:00:00') (type: int), date_add('2008-12-31', 1) (type: string), date_add('2008-12-31', 365) (type: string), date_add('2008-02-28', 2) (type: string), date_add('2009-02-28', 2) (type: string), date_add('2007-02-28', 365) (type: string), date_add('2007-02-28 23:59:59', 730) (type: string), date_sub('2009-01-01', 1) (type: string), date_sub('2009-01-01', 365) (type: string), date_sub('2008-02-28', 2) (type: string), date_sub('2009-02-28', 2) (type: string), date_sub('2007-02-28', 365) (type: string), date_sub('2007-02-28 01:12:34', 730) (type: string) + expressions: -1 (type: int), 2 (type: int), 32 (type: int), -1 (type: int), '2009-01-01' (type: string), '2009-12-31' (type: string), '2008-03-01' (type: string), '2009-03-02' (type: string), '2008-02-28' (type: string), '2009-02-27' (type: string), '2008-12-31' (type: string), '2008-01-02' (type: string), '2008-02-26' (type: string), '2009-02-26' (type: string), '2006-02-28' (type: string), '2005-02-28' (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/udf_10_trims.q.out ql/src/test/results/clientpositive/udf_10_trims.q.out index 82e4328..3ff6118 100644 --- ql/src/test/results/clientpositive/udf_10_trims.q.out +++ ql/src/test/results/clientpositive/udf_10_trims.q.out @@ -33,17 +33,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 86) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: trim(trim(trim(trim(trim(trim(trim(trim(trim(trim(' abc ')))))))))) (type: string) + expressions: 'abc' (type: string) outputColumnNames: _col0 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/udf_E.q.out ql/src/test/results/clientpositive/udf_E.q.out index a859718..104e34d 100644 --- ql/src/test/results/clientpositive/udf_E.q.out +++ ql/src/test/results/clientpositive/udf_E.q.out @@ -17,7 +17,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: e() (type: double) + expressions: 2.718281828459045 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink @@ -64,7 +64,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: e() (type: double) + expressions: 2.718281828459045 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_PI.q.out ql/src/test/results/clientpositive/udf_PI.q.out index f42850d..339b47b 100644 --- ql/src/test/results/clientpositive/udf_PI.q.out +++ ql/src/test/results/clientpositive/udf_PI.q.out @@ -17,7 +17,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: pi() (type: double) + expressions: 3.141592653589793 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink @@ -64,7 +64,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: pi() (type: double) + expressions: 3.141592653589793 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_abs.q.out ql/src/test/results/clientpositive/udf_abs.q.out index ea68381..97753c1 100644 --- ql/src/test/results/clientpositive/udf_abs.q.out +++ ql/src/test/results/clientpositive/udf_abs.q.out @@ -42,7 +42,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: abs(0) (type: int), abs((- 1)) (type: int), abs(123) (type: int), abs((- 9223372036854775807)) (type: bigint), abs(9223372036854775807) (type: bigint) + expressions: 0 (type: int), 1 (type: int), 123 (type: int), 9223372036854775807 (type: bigint), 9223372036854775807 (type: bigint) outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink @@ -93,7 +93,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: abs(0.0) (type: double), abs((- 3.14159265)) (type: double), abs(3.14159265) (type: double) + expressions: 0.0 (type: double), 3.14159265 (type: double), 3.14159265 (type: double) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_ascii.q.out ql/src/test/results/clientpositive/udf_ascii.q.out index 185a0cd..c9b5501 100644 --- ql/src/test/results/clientpositive/udf_ascii.q.out +++ ql/src/test/results/clientpositive/udf_ascii.q.out @@ -38,7 +38,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: ascii('Facebook') (type: int), ascii('') (type: int), ascii('!') (type: int) + expressions: 70 (type: int), 0 (type: int), 33 (type: int) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_between.q.out ql/src/test/results/clientpositive/udf_between.q.out index 129f3cc..fc01e09 100644 --- ql/src/test/results/clientpositive/udf_between.q.out +++ ql/src/test/results/clientpositive/udf_between.q.out @@ -24,7 +24,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (key + 100) BETWEEN (150 + (- 50)) AND (150 + 50) (type: boolean) + predicate: (key + 100) BETWEEN 100 AND 200 (type: boolean) Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: key (type: string), value (type: string) @@ -79,7 +79,7 @@ STAGE PLANS: alias: src Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (key + 100) NOT BETWEEN (150 + (- 50)) AND (150 + 50) (type: boolean) + predicate: (key + 100) NOT BETWEEN 100 AND 200 (type: boolean) Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: key (type: string), value (type: string) @@ -133,17 +133,14 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: 'b' BETWEEN 'a' AND 'c' (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE - Limit - Number of rows: 1 - Statistics: Num rows: 1 Data size: 200 Basic stats: COMPLETE Column stats: NONE - ListSink + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Limit + Number of rows: 1 + Statistics: Num rows: 1 Data size: 200 Basic stats: COMPLETE Column stats: NONE + ListSink PREHOOK: query: SELECT * FROM src where 'b' between 'a' AND 'c' LIMIT 1 PREHOOK: type: QUERY @@ -169,17 +166,14 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: 2 BETWEEN 2 AND '3' (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE - Limit - Number of rows: 1 - Statistics: Num rows: 1 Data size: 200 Basic stats: COMPLETE Column stats: NONE - ListSink + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Limit + Number of rows: 1 + Statistics: Num rows: 1 Data size: 200 Basic stats: COMPLETE Column stats: NONE + ListSink PREHOOK: query: SELECT * FROM src where 2 between 2 AND '3' LIMIT 1 PREHOOK: type: QUERY diff --git ql/src/test/results/clientpositive/udf_case.q.out ql/src/test/results/clientpositive/udf_case.q.out index fe11fce..6c186bd 100644 --- ql/src/test/results/clientpositive/udf_case.q.out +++ ql/src/test/results/clientpositive/udf_case.q.out @@ -77,7 +77,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: CASE (1) WHEN (1) THEN (2) WHEN (3) THEN (4) ELSE (5) END (type: int), CASE (2) WHEN (1) THEN (2) ELSE (5) END (type: int), CASE (14) WHEN (12) THEN (13) WHEN (14) THEN (15) END (type: int), CASE (16) WHEN (12) THEN (13) WHEN (14) THEN (15) END (type: int), CASE (17) WHEN (18) THEN (null) WHEN (17) THEN (20) END (type: int), CASE (21) WHEN (22) THEN (23) WHEN (21) THEN (24) END (type: int) + expressions: 2 (type: int), 5 (type: int), 15 (type: int), null (type: void), CASE (17) WHEN (18) THEN (null) WHEN (17) THEN (20) END (type: int), 24 (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_coalesce.q.out ql/src/test/results/clientpositive/udf_coalesce.q.out index 78d0ab9..b158965 100644 --- ql/src/test/results/clientpositive/udf_coalesce.q.out +++ ql/src/test/results/clientpositive/udf_coalesce.q.out @@ -66,7 +66,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: COALESCE(1) (type: int), COALESCE(1,2) (type: int), COALESCE(null,2) (type: int), COALESCE(1,null) (type: int), COALESCE(null,null,3) (type: int), COALESCE(4,null,null,null) (type: int), COALESCE('1') (type: string), COALESCE('1','2') (type: string), COALESCE(null,'2') (type: string), COALESCE('1',null) (type: string), COALESCE(null,null,'3') (type: string), COALESCE('4',null,null,null) (type: string), COALESCE(1.0) (type: double), COALESCE(1.0,2.0) (type: double), COALESCE(null,2.0) (type: double), COALESCE(null,2.0,3.0) (type: double), COALESCE(2.0,null,3.0) (type: double), COALESCE(if(true, null, 0),null) (type: int) + expressions: 1 (type: int), 1 (type: int), COALESCE(null,2) (type: int), COALESCE(1,null) (type: int), COALESCE(null,null,3) (type: int), COALESCE(4,null,null,null) (type: int), '1' (type: string), '1' (type: string), COALESCE(null,'2') (type: string), COALESCE('1',null) (type: string), COALESCE(null,null,'3') (type: string), COALESCE('4',null,null,null) (type: string), 1.0 (type: double), 1.0 (type: double), COALESCE(null,2.0) (type: double), COALESCE(null,2.0,3.0) (type: double), COALESCE(2.0,null,3.0) (type: double), COALESCE(if(true, null, 0),null) (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_current_database.q.out ql/src/test/results/clientpositive/udf_current_database.q.out index 6a2319b..b4381e9 100644 --- ql/src/test/results/clientpositive/udf_current_database.q.out +++ ql/src/test/results/clientpositive/udf_current_database.q.out @@ -22,7 +22,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: current_database() (type: string) + expressions: 'default' (type: string) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE File Output Operator @@ -75,7 +75,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: current_database() (type: string) + expressions: 'xxx' (type: string) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE File Output Operator @@ -124,7 +124,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: current_database() (type: string) + expressions: 'default' (type: string) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE ListSink @@ -161,7 +161,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: current_database() (type: string) + expressions: 'xxx' (type: string) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_degrees.q.out ql/src/test/results/clientpositive/udf_degrees.q.out index 82c7705..2882819 100644 --- ql/src/test/results/clientpositive/udf_degrees.q.out +++ ql/src/test/results/clientpositive/udf_degrees.q.out @@ -17,7 +17,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: degrees(pi()) (type: double) + expressions: 180.0 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink @@ -64,7 +64,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: degrees(pi()) (type: double) + expressions: 180.0 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_elt.q.out ql/src/test/results/clientpositive/udf_elt.q.out index c963f9d..0439a5f 100644 --- ql/src/test/results/clientpositive/udf_elt.q.out +++ ql/src/test/results/clientpositive/udf_elt.q.out @@ -52,7 +52,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: elt(2, 'abc', 'defg') (type: string), elt(3, 'aa', 'bb', 'cc', 'dd', 'ee', 'ff', 'gg') (type: string), elt('1', 'abc', 'defg') (type: string), elt(2, 'aa', UDFToByte('2')) (type: string), elt(2, 'aa', UDFToShort('12345')) (type: string), elt(2, 'aa', UDFToLong('123456789012')) (type: string), elt(2, 'aa', UDFToFloat(1.25)) (type: string), elt(2, 'aa', 16.0) (type: string), elt(null, 'abc', 'defg') (type: string), elt(0, 'abc', 'defg') (type: string), elt(3, 'abc', 'defg') (type: string) + expressions: 'defg' (type: string), 'cc' (type: string), 'abc' (type: string), '2' (type: string), '12345' (type: string), '123456789012' (type: string), '1.25' (type: string), '16.0' (type: string), elt(null, 'abc', 'defg') (type: string), null (type: void), null (type: void) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_format_number.q.out ql/src/test/results/clientpositive/udf_format_number.q.out index 6771ae0..3ae8e1d 100644 --- ql/src/test/results/clientpositive/udf_format_number.q.out +++ ql/src/test/results/clientpositive/udf_format_number.q.out @@ -42,7 +42,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: format_number(12332.123456, 4) (type: string), format_number(12332.1, 4) (type: string), format_number(12332.2, 0) (type: string) + expressions: '12,332.1235' (type: string), '12,332.1000' (type: string), '12,332' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_hash.q.out ql/src/test/results/clientpositive/udf_hash.q.out index c2591d7..9e2ebf0 100644 --- ql/src/test/results/clientpositive/udf_hash.q.out +++ ql/src/test/results/clientpositive/udf_hash.q.out @@ -37,7 +37,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: hash(UDFToByte(1)) (type: int), hash(UDFToShort(2)) (type: int), hash(3) (type: int), hash(UDFToLong('123456789012')) (type: int), hash(UDFToFloat(1.25)) (type: int), hash(16.0) (type: int), hash('400') (type: int), hash('abc') (type: int), hash(true) (type: int), hash(false) (type: int), hash(1,2,3) (type: int) + expressions: 1 (type: int), 2 (type: int), 3 (type: int), -1097262584 (type: int), 1067450368 (type: int), 1076887552 (type: int), 51508 (type: int), 96354 (type: int), 1 (type: int), 0 (type: int), 1026 (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_hour.q.out ql/src/test/results/clientpositive/udf_hour.q.out index 156fb5b..45ac209 100644 --- ql/src/test/results/clientpositive/udf_hour.q.out +++ ql/src/test/results/clientpositive/udf_hour.q.out @@ -32,14 +32,14 @@ STAGE PLANS: Processor Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 86) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: hour('2009-08-07 13:14:15') (type: int), hour('13:14:15') (type: int), hour('2009-08-07') (type: int) + expressions: 13 (type: int), 13 (type: int), null (type: void) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE ListSink PREHOOK: query: SELECT hour('2009-08-07 13:14:15'), hour('13:14:15'), hour('2009-08-07') diff --git ql/src/test/results/clientpositive/udf_if.q.out ql/src/test/results/clientpositive/udf_if.q.out index 6a9458d..d5515d0 100644 --- ql/src/test/results/clientpositive/udf_if.q.out +++ ql/src/test/results/clientpositive/udf_if.q.out @@ -39,7 +39,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: if(true, 1, 2) (type: int), if(false, UDFToString(null), UDFToString(1)) (type: string), if((1 = 1), if((2 = 2), 1, 2), if((3 = 3), 3, 4)) (type: int), if((2 = 2), 1, null) (type: int), if((2 = 2), null, 1) (type: int), if(if(true, null, false), 1, 2) (type: int) + expressions: 1 (type: int), if(false, UDFToString(null), '1') (type: string), 1 (type: int), if(true, 1, null) (type: int), if(true, null, 1) (type: int), if(if(true, null, false), 1, 2) (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink @@ -94,7 +94,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: if(true, UDFToShort(128), UDFToByte(1)) (type: smallint), if(false, 1, 1.1) (type: double), if(false, 1, 'ABC') (type: string), if(false, 'ABC', 12.3) (type: string) + expressions: 128 (type: smallint), 1.1 (type: double), 'ABC' (type: string), '12.3' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_instr.q.out ql/src/test/results/clientpositive/udf_instr.q.out index 4533674..e79cff1 100644 --- ql/src/test/results/clientpositive/udf_instr.q.out +++ ql/src/test/results/clientpositive/udf_instr.q.out @@ -56,7 +56,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: instr('abcd''abc') (type: int), instr('abcabc''ccc') (type: int), instr(123'23') (type: int), instr(12323) (type: int), instr(true1) (type: int), instr(false1) (type: int), instr('12345'UDFToByte('2')) (type: int), instr(UDFToShort('12345')'34') (type: int), instr(UDFToLong('123456789012')'456') (type: int), instr(UDFToFloat(1.25)'.25') (type: int), instr(16.0'.0') (type: int), instr(null'abc') (type: int), instr('abcd'null) (type: int) + expressions: 1 (type: int), 0 (type: int), 2 (type: int), 2 (type: int), 0 (type: int), 0 (type: int), 2 (type: int), 3 (type: int), 4 (type: int), 2 (type: int), 3 (type: int), instr(null'abc') (type: int), instr('abcd'null) (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_isnull_isnotnull.q.out ql/src/test/results/clientpositive/udf_isnull_isnotnull.q.out index c6188d3..30c62a8 100644 --- ql/src/test/results/clientpositive/udf_isnull_isnotnull.q.out +++ ql/src/test/results/clientpositive/udf_isnull_isnotnull.q.out @@ -43,17 +43,14 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE - Filter Operator - predicate: true is not null (type: boolean) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: COMPLETE - Select Operator - expressions: null is null (type: boolean), 1 is not null (type: boolean), 'my string' is not null (type: boolean) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: COMPLETE - Limit - Number of rows: 1 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: COMPLETE - ListSink + Select Operator + expressions: null is null (type: boolean), true (type: boolean), true (type: boolean) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE + Limit + Number of rows: 1 + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE + ListSink PREHOOK: query: SELECT NULL IS NULL, 1 IS NOT NULL, diff --git ql/src/test/results/clientpositive/udf_like.q.out ql/src/test/results/clientpositive/udf_like.q.out index 13c9876..3336313 100644 --- ql/src/test/results/clientpositive/udf_like.q.out +++ ql/src/test/results/clientpositive/udf_like.q.out @@ -33,14 +33,14 @@ STAGE PLANS: Processor Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 86) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: ('_%_' like '%\_\%\_%') (type: boolean), ('__' like '%\_\%\_%') (type: boolean), ('%%_%_' like '%\_\%\_%') (type: boolean), ('%_%_%' like '%\%\_\%') (type: boolean), ('_%_' like '\%\_%') (type: boolean), ('%__' like '__\%%') (type: boolean), ('_%' like '\_\%\_\%%') (type: boolean), ('_%' like '\_\%_%') (type: boolean), ('%_' like '\%\_') (type: boolean), ('ab' like '\%\_') (type: boolean), ('ab' like '_a%') (type: boolean), ('ab' like 'a') (type: boolean), ('ab' like '') (type: boolean), ('' like '') (type: boolean) + expressions: true (type: boolean), false (type: boolean), true (type: boolean), true (type: boolean), false (type: boolean), false (type: boolean), false (type: boolean), false (type: boolean), true (type: boolean), false (type: boolean), false (type: boolean), false (type: boolean), false (type: boolean), true (type: boolean) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE ListSink PREHOOK: query: SELECT '_%_' LIKE '%\_\%\_%', '__' LIKE '%\_\%\_%', '%%_%_' LIKE '%\_\%\_%', '%_%_%' LIKE '%\%\_\%', diff --git ql/src/test/results/clientpositive/udf_locate.q.out ql/src/test/results/clientpositive/udf_locate.q.out index 736ff5c..fbde599 100644 --- ql/src/test/results/clientpositive/udf_locate.q.out +++ ql/src/test/results/clientpositive/udf_locate.q.out @@ -64,7 +64,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: locate('abc''abcd') (type: int), locate('ccc''abcabc') (type: int), locate('23'123) (type: int), locate(23123) (type: int), locate('abc''abcabc'2) (type: int), locate('abc''abcabc''2') (type: int), locate(1true) (type: int), locate(1false) (type: int), locate(UDFToByte('2')'12345') (type: int), locate('34'UDFToShort('12345')) (type: int), locate('456'UDFToLong('123456789012')) (type: int), locate('.25'UDFToFloat(1.25)) (type: int), locate('.0'16.0) (type: int), locate(null'abc') (type: int), locate('abc'null) (type: int), locate('abc''abcd'null) (type: int), locate('abc''abcd''invalid number') (type: int) + expressions: 1 (type: int), 0 (type: int), 2 (type: int), 2 (type: int), 4 (type: int), 4 (type: int), 0 (type: int), 0 (type: int), 2 (type: int), 3 (type: int), 4 (type: int), 2 (type: int), 3 (type: int), locate(null'abc') (type: int), locate('abc'null) (type: int), locate('abc''abcd'null) (type: int), 0 (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_lower.q.out ql/src/test/results/clientpositive/udf_lower.q.out index ddc8895..3202fe1 100644 --- ql/src/test/results/clientpositive/udf_lower.q.out +++ ql/src/test/results/clientpositive/udf_lower.q.out @@ -28,17 +28,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 86) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: lower('AbC 123') (type: string), upper('AbC 123') (type: string) + expressions: 'abc 123' (type: string), 'ABC 123' (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/udf_lpad.q.out ql/src/test/results/clientpositive/udf_lpad.q.out index 148db4d..913b002 100644 --- ql/src/test/results/clientpositive/udf_lpad.q.out +++ ql/src/test/results/clientpositive/udf_lpad.q.out @@ -38,7 +38,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: lpad('hi', 1, '?') (type: string), lpad('hi', 5, '.') (type: string), lpad('hi', 6, '123') (type: string) + expressions: 'h' (type: string), '...hi' (type: string), '1231hi' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_minute.q.out ql/src/test/results/clientpositive/udf_minute.q.out index 1dd70d5..6d693de 100644 --- ql/src/test/results/clientpositive/udf_minute.q.out +++ ql/src/test/results/clientpositive/udf_minute.q.out @@ -32,17 +32,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 86) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: minute('2009-08-07 13:14:15') (type: int), minute('13:14:15') (type: int), minute('2009-08-07') (type: int) + expressions: 14 (type: int), 14 (type: int), null (type: void) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/udf_nvl.q.out ql/src/test/results/clientpositive/udf_nvl.q.out index 2565779..29fff78 100644 --- ql/src/test/results/clientpositive/udf_nvl.q.out +++ ql/src/test/results/clientpositive/udf_nvl.q.out @@ -34,7 +34,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: if 1 is null returns2 (type: int), if null is null returns5 (type: int) + expressions: 1 (type: int), if null is null returns5 (type: int) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_parse_url.q.out ql/src/test/results/clientpositive/udf_parse_url.q.out index 0be5722..d6afc1a 100644 --- ql/src/test/results/clientpositive/udf_parse_url.q.out +++ ql/src/test/results/clientpositive/udf_parse_url.q.out @@ -55,17 +55,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2906 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 86) (type: boolean) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'HOST') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'PATH') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'QUERY') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'REF') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'QUERY', 'k2') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'QUERY', 'k1') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'QUERY', 'k3') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'FILE') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'PROTOCOL') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'USERINFO') (type: string), parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'AUTHORITY') (type: string) + expressions: 'facebook.com' (type: string), '/path1/p.php' (type: string), 'k1=v1&k2=v2' (type: string), 'Ref1' (type: string), 'v2' (type: string), 'v1' (type: string), null (type: void), '/path1/p.php?k1=v1&k2=v2' (type: string), 'http' (type: string), null (type: void), 'facebook.com' (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/udf_printf.q.out ql/src/test/results/clientpositive/udf_printf.q.out index 73734bd..be097f8 100644 --- ql/src/test/results/clientpositive/udf_printf.q.out +++ ql/src/test/results/clientpositive/udf_printf.q.out @@ -38,7 +38,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: printf('Hello World %d %s', 100, 'days') (type: string) + expressions: 'Hello World 100 days' (type: string) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_radians.q.out ql/src/test/results/clientpositive/udf_radians.q.out index 0729b1b..1f4b014 100644 --- ql/src/test/results/clientpositive/udf_radians.q.out +++ ql/src/test/results/clientpositive/udf_radians.q.out @@ -17,7 +17,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: radians(57.2958) (type: double) + expressions: 1.000000357564167 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink @@ -73,7 +73,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: radians(57.2958) (type: double) + expressions: 1.000000357564167 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_reflect2.q.out ql/src/test/results/clientpositive/udf_reflect2.q.out index 6b19277..0a123d7 100644 --- ql/src/test/results/clientpositive/udf_reflect2.q.out +++ ql/src/test/results/clientpositive/udf_reflect2.q.out @@ -320,7 +320,7 @@ STAGE PLANS: Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE GatherStats: false Select Operator - expressions: UDFToInteger(key) (type: int), value (type: string), CAST( '2013-02-15 19:41:20' AS TIMESTAMP) (type: timestamp) + expressions: UDFToInteger(key) (type: int), value (type: string), 2013-02-15 19:41:20.0 (type: timestamp) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git ql/src/test/results/clientpositive/udf_repeat.q.out ql/src/test/results/clientpositive/udf_repeat.q.out index 07b09e9..f4c0fef 100644 --- ql/src/test/results/clientpositive/udf_repeat.q.out +++ ql/src/test/results/clientpositive/udf_repeat.q.out @@ -38,7 +38,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: repeat('Facebook', 3) (type: string), repeat('', 4) (type: string), repeat('asd', 0) (type: string), repeat('asdf', (- 1)) (type: string) + expressions: 'FacebookFacebookFacebook' (type: string), '' (type: string), '' (type: string), '' (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_rpad.q.out ql/src/test/results/clientpositive/udf_rpad.q.out index 287f5a9..ea02e10 100644 --- ql/src/test/results/clientpositive/udf_rpad.q.out +++ ql/src/test/results/clientpositive/udf_rpad.q.out @@ -38,7 +38,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: rpad('hi', 1, '?') (type: string), rpad('hi', 5, '.') (type: string), rpad('hi', 6, '123') (type: string) + expressions: 'h' (type: string), 'hi...' (type: string), 'hi1231' (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_second.q.out ql/src/test/results/clientpositive/udf_second.q.out index 4abfae1..096c384 100644 --- ql/src/test/results/clientpositive/udf_second.q.out +++ ql/src/test/results/clientpositive/udf_second.q.out @@ -37,7 +37,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: second('2009-08-07 13:14:15') (type: int), second('13:14:15') (type: int), second('2009-08-07') (type: int) + expressions: 15 (type: int), 15 (type: int), null (type: void) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE ListSink diff --git ql/src/test/results/clientpositive/udf_sign.q.out ql/src/test/results/clientpositive/udf_sign.q.out index f0851a9..f4da95d 100644 --- ql/src/test/results/clientpositive/udf_sign.q.out +++ ql/src/test/results/clientpositive/udf_sign.q.out @@ -17,7 +17,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: sign(0) (type: double) + expressions: 0.0 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink @@ -81,7 +81,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: sign(0) (type: double) + expressions: 0.0 (type: double) outputColumnNames: _col0 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_space.q.out ql/src/test/results/clientpositive/udf_space.q.out index fd8c2ca..14d696a 100644 --- ql/src/test/results/clientpositive/udf_space.q.out +++ ql/src/test/results/clientpositive/udf_space.q.out @@ -40,7 +40,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: space(10) (type: string), space(0) (type: string), space(1) (type: string), space((- 1)) (type: string), space((- 100)) (type: string) + expressions: ' ' (type: string), '' (type: string), ' ' (type: string), '' (type: string), '' (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/udf_when.q.out ql/src/test/results/clientpositive/udf_when.q.out index 42736f4..cbb1210 100644 --- ql/src/test/results/clientpositive/udf_when.q.out +++ ql/src/test/results/clientpositive/udf_when.q.out @@ -77,7 +77,7 @@ STAGE PLANS: Row Limit Per Split: 1 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE Select Operator - expressions: CASE WHEN ((1 = 1)) THEN (2) WHEN ((1 = 3)) THEN (4) ELSE (5) END (type: int), CASE WHEN ((6 = 7)) THEN (8) ELSE (9) END (type: int), CASE WHEN ((10 = 11)) THEN (12) WHEN ((13 = 13)) THEN (14) END (type: int), CASE WHEN ((15 = 16)) THEN (17) WHEN ((18 = 19)) THEN (20) END (type: int), CASE WHEN ((21 = 22)) THEN (null) WHEN ((23 = 23)) THEN (24) END (type: int), CASE WHEN ((25 = 26)) THEN (27) WHEN ((28 = 28)) THEN (null) END (type: int) + expressions: 2 (type: int), 9 (type: int), 14 (type: int), null (type: void), CASE WHEN (false) THEN (null) WHEN (true) THEN (24) END (type: int), CASE WHEN (false) THEN (27) WHEN (true) THEN (null) END (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: COMPLETE ListSink diff --git ql/src/test/results/clientpositive/union33.q.out ql/src/test/results/clientpositive/union33.q.out index 7a2fe67..95632dc 100644 --- ql/src/test/results/clientpositive/union33.q.out +++ ql/src/test/results/clientpositive/union33.q.out @@ -111,23 +111,23 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Union - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -135,14 +135,14 @@ STAGE PLANS: name: default.test_src TableScan Union - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -334,14 +334,14 @@ STAGE PLANS: Map Operator Tree: TableScan Union - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -349,23 +349,23 @@ STAGE PLANS: name: default.test_src TableScan alias: src - Statistics: Num rows: 29 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5812 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 0) (type: boolean) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), value (type: string) + expressions: '0' (type: string), value (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 28 Data size: 2855 Basic stats: COMPLETE Column stats: NONE Union - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 43 Data size: 5711 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 57 Data size: 5761 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/union_remove_19.q.out ql/src/test/results/clientpositive/union_remove_19.q.out index 76a46d7..2ea5f98 100644 --- ql/src/test/results/clientpositive/union_remove_19.q.out +++ ql/src/test/results/clientpositive/union_remove_19.q.out @@ -265,25 +265,25 @@ STAGE PLANS: Map Operator Tree: TableScan alias: inputtbl1 - Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE + Statistics: Num rows: 30 Data size: 30 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 7) (type: boolean) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 15 Data size: 15 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string) + expressions: '7' (type: string) outputColumnNames: key - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 15 Data size: 15 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1) keys: key (type: string) mode: hash outputColumnNames: _col0, _col1 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 15 Data size: 15 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: string) sort order: + Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 15 Data size: 15 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: bigint) Reduce Operator Tree: Group By Operator @@ -291,14 +291,14 @@ STAGE PLANS: keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0, _col1 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 7 Data size: 7 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: bigint) outputColumnNames: _col0, _col1 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 7 Data size: 7 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 7 Data size: 7 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -320,25 +320,25 @@ STAGE PLANS: Map Operator Tree: TableScan alias: inputtbl1 - Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE + Statistics: Num rows: 30 Data size: 30 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: (key = 7) (type: boolean) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 15 Data size: 15 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string) + expressions: '7' (type: string) outputColumnNames: key - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 15 Data size: 15 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count(1) keys: key (type: string) mode: hash outputColumnNames: _col0, _col1 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 15 Data size: 15 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: string) sort order: + Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 15 Data size: 15 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: bigint) Reduce Operator Tree: Group By Operator @@ -346,14 +346,14 @@ STAGE PLANS: keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0, _col1 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 7 Data size: 7 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: bigint) outputColumnNames: _col0, _col1 - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 7 Data size: 7 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 7 Data size: 7 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/compiler/plan/cast1.q.xml ql/src/test/results/compiler/plan/cast1.q.xml index 1143bc4..5b9bbf8 100644 --- ql/src/test/results/compiler/plan/cast1.q.xml +++ ql/src/test/results/compiler/plan/cast1.q.xml @@ -378,7 +378,7 @@ _col6 - + @@ -410,7 +410,7 @@ _col5 - + @@ -442,7 +442,7 @@ _col4 - + @@ -502,7 +502,7 @@ _col3 - + @@ -541,7 +541,7 @@ _col2 - + @@ -580,7 +580,7 @@ _col1 - + @@ -619,7 +619,7 @@ _col0 - + @@ -663,25 +663,74 @@ - + + + + + + 5 + + - + + + + + + 5.0 + + - + + + + + + 5.0 + + - + + + + + + 5.0 + + - + + + + + + 5 + + - + + + + + + true + + - + + + + + + 1 + + @@ -899,6 +948,9 @@ + + key + key diff --git ql/src/test/results/compiler/plan/input6.q.xml ql/src/test/results/compiler/plan/input6.q.xml index 57f96fd..30f44a9 100644 --- ql/src/test/results/compiler/plan/input6.q.xml +++ ql/src/test/results/compiler/plan/input6.q.xml @@ -797,17 +797,7 @@ _col0 - - - key - - - src1 - - - - - + @@ -816,7 +806,7 @@ - + @@ -848,6 +838,9 @@ + + key + _col0 @@ -932,6 +925,9 @@ + + key + key diff --git ql/src/test/results/compiler/plan/join8.q.xml ql/src/test/results/compiler/plan/join8.q.xml index ba128d4..bdd330b 100644 --- ql/src/test/results/compiler/plan/join8.q.xml +++ ql/src/test/results/compiler/plan/join8.q.xml @@ -1640,18 +1640,11 @@ _col2 - - - _col2 - - - - - + _col1 - + _col1 @@ -1662,7 +1655,7 @@ _col0 - + _col0 @@ -1678,15 +1671,15 @@ - - - + + + @@ -1809,7 +1802,14 @@ - + + + _col2 + + + + + @@ -1862,9 +1862,15 @@ + + c3 + _col2 + + b + @@ -1896,7 +1902,7 @@ _col3 - + VALUE._col0 @@ -1907,7 +1913,7 @@ _col2 - + KEY.reducesinkkey0 @@ -1918,7 +1924,7 @@ _col1 - + VALUE._col0 @@ -1929,7 +1935,7 @@ _col0 - + KEY.reducesinkkey0 @@ -1962,10 +1968,10 @@ 0 - + - + @@ -1973,10 +1979,10 @@ 1 - + - + diff --git ql/src/test/results/compiler/plan/udf1.q.xml ql/src/test/results/compiler/plan/udf1.q.xml index cae38f5..f7cf1cd 100644 --- ql/src/test/results/compiler/plan/udf1.q.xml +++ ql/src/test/results/compiler/plan/udf1.q.xml @@ -534,7 +534,7 @@ _col8 - + @@ -579,7 +579,7 @@ _col7 - + @@ -624,7 +624,7 @@ _col6 - + @@ -669,7 +669,7 @@ _col5 - + @@ -714,7 +714,7 @@ _col4 - + @@ -759,7 +759,7 @@ _col3 - + @@ -804,7 +804,7 @@ _col2 - + @@ -849,7 +849,7 @@ _col1 - + @@ -894,7 +894,7 @@ _col9 - + @@ -939,7 +939,7 @@ _col13 - + @@ -991,7 +991,7 @@ _col12 - + @@ -1036,7 +1036,7 @@ _col11 - + @@ -1081,7 +1081,7 @@ _col10 - + @@ -1126,7 +1126,7 @@ _col16 - + @@ -1178,7 +1178,7 @@ _col15 - + @@ -1230,7 +1230,7 @@ _col14 - + @@ -1282,7 +1282,7 @@ _col0 - + @@ -1332,55 +1332,174 @@ - + + + + + + true + + - + + + + + + false + + - + + + + + + true + + - + + + + + + true + + - + + + + + + true + + - + + + + + + false + + - + + + + + + false + + - + + + + + + false + + - + + + + + + true + + - + + + + + + true + + - + + + + + + false + + - + + + + + + true + + - + + + + + + true + + - + + + + + + acc + + - + + + + + + abc + + - + + + + + + abb + + - + + + + + + hive + + @@ -1788,6 +1907,9 @@ + + key + key diff --git ql/src/test/results/compiler/plan/udf4.q.xml ql/src/test/results/compiler/plan/udf4.q.xml index fe62919..994ce7f 100644 --- ql/src/test/results/compiler/plan/udf4.q.xml +++ ql/src/test/results/compiler/plan/udf4.q.xml @@ -547,7 +547,7 @@ _col8 - + @@ -579,7 +579,7 @@ _col7 - + @@ -625,7 +625,7 @@ _col6 - + @@ -657,7 +657,7 @@ _col5 - + @@ -696,7 +696,7 @@ _col4 - + @@ -721,7 +721,7 @@ _col3 - + @@ -746,7 +746,7 @@ _col2 - + @@ -785,7 +785,7 @@ _col1 - + @@ -810,7 +810,7 @@ _col9 - + @@ -835,7 +835,7 @@ _col13 - + @@ -867,7 +867,7 @@ _col12 - + @@ -892,7 +892,7 @@ _col11 - + @@ -931,7 +931,7 @@ _col10 - + @@ -956,7 +956,7 @@ _col17 - + @@ -1009,7 +1009,7 @@ _col16 - + @@ -1048,7 +1048,7 @@ _col15 - + @@ -1084,7 +1084,7 @@ _col0 - + @@ -1109,7 +1109,7 @@ _col18 - + @@ -1149,61 +1149,173 @@ - + + + + + + 1.0 + + - + + + + + + 2.0 + + - + + + + + + -2.0 + + - + + + + + + 1 + + - + + + + + + 1 + + - + + + + + + -2 + + - + + + + + + 1.0 + + - + - + + + + + + 0.0 + + - + + + + + + 1 + + - + + + + + + 2 + + - + + + + + + -1 + + - + + + + + + 1 + + - + - + + + + + + -3 + + - + + + + + + 3 + + - + + + + + + -1 + + - + + + + + + -2 + + diff --git ql/src/test/results/compiler/plan/udf6.q.xml ql/src/test/results/compiler/plan/udf6.q.xml index c4afcf3..22ef3ff 100644 --- ql/src/test/results/compiler/plan/udf6.q.xml +++ ql/src/test/results/compiler/plan/udf6.q.xml @@ -291,7 +291,7 @@ _col1 - + @@ -340,7 +340,7 @@ _col0 - + @@ -380,10 +380,24 @@ - + + + + + + ab + + - + + + + + + 1 + + diff --git ql/src/test/results/compiler/plan/udf_case.q.xml ql/src/test/results/compiler/plan/udf_case.q.xml index 583d975..7f12f53 100644 --- ql/src/test/results/compiler/plan/udf_case.q.xml +++ ql/src/test/results/compiler/plan/udf_case.q.xml @@ -346,7 +346,7 @@ _col1 - + @@ -411,7 +411,7 @@ _col0 - + @@ -491,10 +491,17 @@ - + + + + + + 2 + + - + diff --git ql/src/test/results/compiler/plan/udf_when.q.xml ql/src/test/results/compiler/plan/udf_when.q.xml index 54c2777..ae7db70 100644 --- ql/src/test/results/compiler/plan/udf_when.q.xml +++ ql/src/test/results/compiler/plan/udf_when.q.xml @@ -346,7 +346,7 @@ _col1 - + @@ -453,7 +453,7 @@ _col0 - + @@ -571,10 +571,17 @@ - + + + + + + 2 + + - +