diff --git common/src/java/org/apache/hadoop/hive/conf/HiveConf.java common/src/java/org/apache/hadoop/hive/conf/HiveConf.java index dcfe29a..4f489c4 100644 --- common/src/java/org/apache/hadoop/hive/conf/HiveConf.java +++ common/src/java/org/apache/hadoop/hive/conf/HiveConf.java @@ -1003,12 +1003,12 @@ HIVEEXPLAINDEPENDENCYAPPENDTASKTYPES("hive.explain.dependency.append.tasktype", false), HIVECOUNTERGROUP("hive.counters.group.name", "HIVE"), - + HIVEOPTCONSTANTPROPAGATION("hive.optimize.constant.propagation", true), + HIVE_SERVER2_TEZ_DEFAULT_QUEUES("hive.server2.tez.default.queues", ""), HIVE_SERVER2_TEZ_SESSIONS_PER_DEFAULT_QUEUE("hive.server2.tez.sessions.per.default.queue", 1), HIVE_SERVER2_TEZ_INITIALIZE_DEFAULT_SESSIONS("hive.server2.tez.initialize.default.sessions", false), - // none, column // none is the default(past) behavior. Implies only alphaNumeric and underscore are valid characters in identifiers. // column: implies column names can contain any character. diff --git contrib/src/test/results/clientpositive/udf_example_add.q.out contrib/src/test/results/clientpositive/udf_example_add.q.out index c3499ab..cefc46a 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 ce33649..f5c48f1 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 acaca23..b2b26d4 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/ColumnInfo.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/ColumnInfo.java @@ -20,6 +20,7 @@ import java.io.Serializable; +import org.apache.hadoop.hive.serde2.objectinspector.ConstantObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; @@ -215,4 +216,8 @@ public boolean equals(Object obj) { return true; } + + public void setObjectinspector(ObjectInspector oi) { + this.objectInspector = oi; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/AbstractSMBJoinProc.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/AbstractSMBJoinProc.java index 0b7b1a3..61bf733 100644 --- ql/src/java/org/apache/hadoop/hive/ql/optimizer/AbstractSMBJoinProc.java +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/AbstractSMBJoinProc.java @@ -209,6 +209,7 @@ protected SMBMapJoinOperator convertBucketMapJoinToSMBJoin(MapJoinOperator mapJo aliasToSink.put(srcs[i], dummyStoreOp); smbJop.getParentOperators().remove(i); smbJop.getParentOperators().add(i, dummyStoreOp); + parseContext.getOpParseCtx().put(dummyStoreOp, parseContext.getOpParseCtx().get(par)); } } smbJoinDesc.setAliasToSink(aliasToSink); @@ -469,7 +470,7 @@ protected boolean canConvertJoinToBucketMapJoin( } BigTableSelectorForAutoSMJ bigTableMatcher = - (BigTableSelectorForAutoSMJ) ReflectionUtils.newInstance(bigTableMatcherClass, null); + ReflectionUtils.newInstance(bigTableMatcherClass, null); JoinDesc joinDesc = joinOp.getConf(); JoinCondDesc[] joinCondns = joinDesc.getConds(); Set joinCandidates = MapJoinProcessor.getBigTableCandidates(joinCondns); 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..0209e79 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagate.java @@ -0,0 +1,152 @@ +/** + * 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.ql.exec.Operator; +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 { + 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", "FIL%"), ConstantPropagateProcFactory + .getFilterProc()); + opRules.put(new RuleRegExp("R2", "GBY%"), ConstantPropagateProcFactory + .getGroupByProc()); + opRules.put(new RuleRegExp("R3", "SEL%"), ConstantPropagateProcFactory + .getSelectProc()); + opRules.put(new RuleRegExp("R4", "FS%"), ConstantPropagateProcFactory + .getFileSinkProc()); + opRules.put(new RuleRegExp("R5", "UNION%"), ConstantPropagateProcFactory + .getUnionProc()); + opRules.put(new RuleRegExp("R6", "RS%"), ConstantPropagateProcFactory + .getReduceSinkProc()); + + // 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 post-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..53d61a7 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcCtx.java @@ -0,0 +1,156 @@ +/** + * 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.List; +import java.util.Map; +import java.util.Map.Entry; + +import org.apache.commons.lang.StringUtils; +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.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.ExprNodeColumnDesc; +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> opToParseCtxMap; + + private final List> opToDelete; + + public ConstantPropagateProcCtx( + Map, OpParseContext> opToParseCtxMap) { + opToConstantExprs = new HashMap, Map>(); + opToDelete = new ArrayList>(); + this.opToParseCtxMap = opToParseCtxMap; + } + + public Map, Map> getOpToConstantExprs() { + return opToConstantExprs; + } + + public Map, OpParseContext> getOpToParseCtxMap() { + return opToParseCtxMap; + } + + /** + * 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(); + RowResolver rr = opToParseCtxMap.get(op).getRowResolver(); + LOG.debug("Current rr of op:" + op + " is " + rr); + try { + if (op.getParentOperators() == null) { + return constants; + } + for (Operator parent : op.getParentOperators()) { + RowResolver inputRR = opToParseCtxMap.get(parent).getRowResolver(); + Map c = opToConstantExprs.get(parent); + for (Entry e : c.entrySet()) { + ColumnInfo ci = e.getKey(); + + // Get genuine column alias (instead of retrieve from ColumnInfo, which is unreliable). + String tmp[] = inputRR.reverseLookup(ci.getInternalName()); + + // In some cases reverseLookup by internal name will fail (e.g., items insert by + // RowResolver.putExpression) + if (tmp != null) { + ColumnInfo nci = rr.get(tmp[0], tmp[1]); + if (nci != null) { + constants.put(nci, e.getValue()); + } + } + } + } + LOG.debug("Offerring constants " + StringUtils.join(constants.keySet(), ",") + + " to operator " + op.toString()); + return constants; + } catch (SemanticException e) { + LOG.error(e.getMessage(), e); + throw new RuntimeException(e); + } + } + + /** + * Get ColumnInfo from column expression. + * + * @param op + * @param desc + * @return + */ + public ColumnInfo resolveColumn(Operator op, + ExprNodeColumnDesc desc) { + try { + ColumnInfo ci = null; + for (Operator parent : op.getParentOperators()) { + RowResolver rr = opToParseCtxMap.get(parent).getRowResolver(); + String[] tmp = rr.reverseLookup(desc.getColumn()); + if (tmp == null) { + LOG.debug("Reverse look up of column " + desc + " error!"); + return null; + } + ci = rr.get(tmp[0], tmp[1]); + return ci; + } + return null; + } catch (SemanticException e) { + throw new RuntimeException(e); + } + } + + 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..0801bbb --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcFactory.java @@ -0,0 +1,773 @@ +/** + * 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.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +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.UDF; +import org.apache.hadoop.hive.ql.exec.UDFArgumentException; +import org.apache.hadoop.hive.ql.exec.UnionOperator; +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.AggregationDesc; +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.ReduceSinkDesc; +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; + +/** + * 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 + } + + /** + * 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) { + LOG.debug("Casting " + desc + " to type " + ti); + PrimitiveTypeInfo priti = (PrimitiveTypeInfo) ti; + if (priti.getPrimitiveCategory() == PrimitiveCategory.DECIMAL + || priti.getPrimitiveCategory() == PrimitiveCategory.VARCHAR + || priti.getPrimitiveCategory() == PrimitiveCategory.CHAR) { + + // FIXME: support template types. It currently has conflict with ExprNodeConstantDesc + return null; + } + ExprNodeConstantDesc c = (ExprNodeConstantDesc) desc; + ObjectInspector origOI = TypeInfoUtils + .getStandardJavaObjectInspectorFromTypeInfo(desc.getTypeInfo()); + ObjectInspector oi = TypeInfoUtils + .getStandardJavaObjectInspectorFromTypeInfo(desc.getTypeInfo()); + Converter converter = ObjectInspectorConverters.getConverter(oi, origOI); + 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 + */ + public static ExprNodeDesc foldExpr(ExprNodeDesc desc, + Map constants, + ConstantPropagateProcCtx cppCtx, Operator op, 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; + if (!propagatableUdfs.contains(udf.getClass())) { + propagateNext = false; + } + List newExprs = new ArrayList(); + for (ExprNodeDesc childExpr : desc.getChildren()) { + newExprs.add(foldExpr(childExpr, constants, cppCtx, op, 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, op, constants); + } + + return desc; + } else if (desc instanceof ExprNodeColumnDesc) { + ExprNodeDesc col = evaluateColumn((ExprNodeColumnDesc) desc, cppCtx, op); + LOG.debug("Folding expression:" + desc + " -> " + col); + return col; + } else { + 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, + ConstantPropagateProcCtx cppCtx, Operator op, + Map constants) { + if (udf instanceof GenericUDFOPEqual) { + ExprNodeDesc lOperand = newExprs.get(0); + ExprNodeDesc rOperand = newExprs.get(1); + if (lOperand instanceof ExprNodeColumnDesc && rOperand instanceof ExprNodeConstantDesc) { + LOG.debug("Filter " + udf + + " is identified as a value assignment, propagate it."); + ExprNodeColumnDesc c = (ExprNodeColumnDesc) lOperand; + ExprNodeConstantDesc v = (ExprNodeConstantDesc) rOperand; + ColumnInfo ci = cppCtx.resolveColumn(op, c); + if (ci != 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 = cppCtx.resolveColumn(op, 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 op) { + try { + ColumnInfo ci = null; + for (Operator parent : op.getParentOperators()) { + 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 desc; + } + ci = rr.get(tmp[0], tmp[1]); + if (ci != null) { + ExprNodeDesc constant = cppCtx.getOpToConstantExprs().get(parent).get(ci); + if (constant != null) { + LOG.debug("Fold column " + ci + " to be " + constant); + if (constant instanceof ExprNodeConstantDesc + && !constant.getTypeInfo().equals(desc.getTypeInfo())) { + ExprNodeDesc expr = typeCast(constant, desc.getTypeInfo()); + if (expr == null) { + return desc; + } else { + return expr; + } + } + return constant; + } else { + return desc; + } + } + } + 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, + Map constants) + throws SemanticException { + RowSchema schema = op.getSchema(); + ArrayList cols; + if (schema != null && (cols = schema.getSignature()) != null) { + for (int i = 0; i < cols.size(); i++) { + ColumnInfo col = cols.get(i); + ExprNodeDesc constant = constants.get(col); + if (constant != null) { + LOG.debug("Replacing column " + col + " with constant " + + constant.getExprString() + " in " + op); + col.setObjectinspector(constant.getWritableObjectInspector()); + } + } + } + } + + /** + * 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 { + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, + Object... nodeOutputs) throws SemanticException { + FilterOperator op = (FilterOperator) nd; + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + ExprNodeDesc condn = op.getConf().getPredicate(); + // Fold constants + Map constants = cppCtx.getPropagatedConstants(op); + LOG.debug("Old filter conditions:" + condn.getExprString()); + ExprNodeDesc newCondn = foldExpr(condn, constants, cppCtx, op, 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 conditions:" + newCondn.getExprString()); + + // merge it with the downstream col list + cppCtx.getOpToConstantExprs().put(op, constants); + op.getConf().setPredicate(newCondn); + foldOperator(op, constants); + 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 { + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, + Object... nodeOutputs) throws SemanticException { + GroupByOperator op = (GroupByOperator) nd; + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + GroupByDesc conf = op.getConf(); + ArrayList keys = conf.getKeys(); + + Map colToConstants = cppCtx.getPropagatedConstants(op); + for (int i = 0; i < keys.size(); i++) { + ExprNodeDesc key = keys.get(i); + ExprNodeDesc newkey = foldExpr(key, colToConstants, cppCtx, op, true); + keys.set(i, newkey); + } + + ArrayList aggrs = conf.getAggregators(); + + cppCtx.getOpToConstantExprs().put(op, colToConstants); + + foldOperator(op, colToConstants); + 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 { + @Override + @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); + foldOperator(op, constants); + 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 { + @Override + 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); + 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, false); + colList.set(i, newCol); + } + } + foldOperator(op, constants); + 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 { + @Override + 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); + foldOperator(op, constants); + 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); + } + } + 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 Union Operators. Propagate of constant will + * stop on union operators. + */ + public static class ConstantPropagateUnionProc implements NodeProcessor { + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx ctx, + Object... nodeOutputs) throws SemanticException { + UnionOperator op = (UnionOperator) nd; + ConstantPropagateProcCtx cppCtx = (ConstantPropagateProcCtx) ctx; + cppCtx.getOpToConstantExprs().put(op, new HashMap()); + return null; + } + } + + public static NodeProcessor getUnionProc() { + return new ConstantPropagateUnionProc(); + } + + /** + * 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 { + @Override + 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); + + if (op.getChildOperators().size() == 1 + && op.getChildOperators().get(0) instanceof JoinOperator) { + JoinOperator joinOp = (JoinOperator) op.getChildOperators().get(0); + if (skipFolding(joinOp.getConf(), op.getConf().getTag())) { + LOG.debug("Outer join in the future, skip folding " + op + "."); + cppCtx.getOpToConstantExprs().put(op, new HashMap()); + return null; + } + } + // key columns + ArrayList newKeyExprs = new ArrayList(); + for (ExprNodeDesc desc : rsDesc.getKeyCols()) { + newKeyExprs.add(foldExpr(desc, constants, cppCtx, op, false)); + } + rsDesc.setKeyCols(newKeyExprs); + + // partition columns + ArrayList newPartExprs = new ArrayList(); + for (ExprNodeDesc desc : rsDesc.getPartitionCols()) { + newPartExprs.add(foldExpr(desc, constants, cppCtx, op, false)); + } + rsDesc.setPartitionCols(newPartExprs); + + // value columns + ArrayList newValExprs = new ArrayList(); + for (ExprNodeDesc desc : rsDesc.getValueCols()) { + newValExprs.add(foldExpr(desc, constants, cppCtx, op, false)); + } + rsDesc.setValueCols(newValExprs); + + foldOperator(op, constants); + cppCtx.getOpToConstantExprs().put(op, constants); + 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(); + } + +} 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..7bf5b16 100644 --- ql/src/java/org/apache/hadoop/hive/ql/optimizer/Optimizer.java +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/Optimizer.java @@ -53,6 +53,7 @@ public void initialize(HiveConf hiveConf) { transformations = new ArrayList(); // Add the transformation that computes the lineage information. transformations.add(new Generator()); + if (HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVEOPTPPD)) { transformations.add(new PredicateTransitivePropagate()); transformations.add(new PredicatePushDown()); @@ -95,7 +96,9 @@ public void initialize(HiveConf hiveConf) { if (HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVEOPTIMIZEBUCKETINGSORTING)) { transformations.add(new BucketingSortingReduceSinkOptimizer()); } - + if (HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVEOPTCONSTANTPROPAGATION)) { + transformations.add(new ConstantPropagate()); + } transformations.add(new UnionProcessor()); transformations.add(new JoinReorder()); if(HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.DYNAMICPARTITIONING) && 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/alter_partition_coltype.q ql/src/test/queries/clientpositive/alter_partition_coltype.q index 115eaf9..d62d27e 100644 --- ql/src/test/queries/clientpositive/alter_partition_coltype.q +++ ql/src/test/queries/clientpositive/alter_partition_coltype.q @@ -65,4 +65,4 @@ alter table alterdynamic_part_table partition column (partcol1 int); explain extended select intcol from alterdynamic_part_table where partcol1='1' and partcol2='1'; explain extended select intcol from alterdynamic_part_table where (partcol1='2' and partcol2='1')or (partcol1='1' and partcol2='__HIVE_DEFAULT_PARTITION__'); -select intcol from alterdynamic_part_table where (partcol1='2' and partcol2='1')or (partcol1='1' and partcol2='__HIVE_DEFAULT_PARTITION__'); \ No newline at end of file +select intcol from alterdynamic_part_table where (partcol1='2' and partcol2='1')or (partcol1='1' and partcol2='__HIVE_DEFAULT_PARTITION__'); 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..72ce5a3 --- /dev/null +++ ql/src/test/queries/clientpositive/constprog2.q @@ -0,0 +1,10 @@ +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 50335ec..95ddc4a 100644 --- ql/src/test/results/clientpositive/annotate_stats_filter.q.out +++ ql/src/test/results/clientpositive/annotate_stats_filter.q.out @@ -144,7 +144,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 @@ -288,7 +288,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 @@ -680,7 +680,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 @@ -1188,103 +1188,22 @@ TOK_QUERY STAGE DEPENDENCIES: - Stage-1 is a root stage 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 @@ -1329,7 +1248,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) @@ -1606,7 +1525,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 @@ -1746,7 +1665,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 @@ -2030,7 +1949,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 eee003b..3af0819 100644 --- ql/src/test/results/clientpositive/annotate_stats_part.q.out +++ ql/src/test/results/clientpositive/annotate_stats_part.q.out @@ -1025,7 +1025,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 d1c5be6..b99ab17 100644 --- ql/src/test/results/clientpositive/annotate_stats_select.q.out +++ ql/src/test/results/clientpositive/annotate_stats_select.q.out @@ -1939,7 +1939,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: [B@30b499c (type: binary) outputColumnNames: _col0 Statistics: Num rows: 2 Data size: 96 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator @@ -2081,7 +2081,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 @@ -2219,7 +2219,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 @@ -2357,7 +2357,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/cast1.q.out ql/src/test/results/clientpositive/cast1.q.out index d67df9b..4e537bd 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/column_access_stats.q.out ql/src/test/results/clientpositive/column_access_stats.q.out index d0cd195..42177ef 100644 --- ql/src/test/results/clientpositive/column_access_stats.q.out +++ ql/src/test/results/clientpositive/column_access_stats.q.out @@ -580,7 +580,7 @@ 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: key (type: string), val (type: string) + value expressions: key (type: string), '3' (type: string) TableScan alias: t1 Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -592,7 +592,7 @@ 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: key (type: string), val (type: string) + value expressions: key (type: string), '3' (type: string) Reduce Operator Tree: Join Operator condition map: @@ -603,7 +603,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col4, _col5 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 @@ -618,10 +618,10 @@ STAGE PLANS: Map Operator Tree: TableScan Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) + key expressions: _col0 (type: string), '3' (type: string) sort order: ++ Statistics: Num rows: 2 Data size: 6 Basic stats: COMPLETE Column stats: NONE - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: string) + value expressions: _col0 (type: string), '3' (type: string), _col2 (type: string), '3' (type: string) Reduce Operator Tree: Extract Statistics: Num rows: 2 Data size: 6 Basic stats: COMPLETE Column stats: NONE 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..f6e52c1 --- /dev/null +++ ql/src/test/results/clientpositive/constprog2.q.out @@ -0,0 +1,76 @@ +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 is a root stage + +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 + key expressions: '86' (type: string) + sort order: + + Map-reduce partition columns: '86' (type: string) + 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 + key expressions: '86' (type: string) + sort order: + + Map-reduce partition columns: '86' (type: string) + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + value expressions: '86' (type: string) + Reduce Operator Tree: + Join Operator + condition map: + Inner Join 0 to 1 + condition expressions: + 0 {VALUE._col0} + 1 {VALUE._col1} + outputColumnNames: _col0, _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 + +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..192b46f --- /dev/null +++ ql/src/test/results/clientpositive/constprog_type.q.out @@ -0,0 +1,125 @@ +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 #### +POSTHOOK: Lineage: dest1.d EXPRESSION [] +POSTHOOK: Lineage: dest1.t EXPRESSION [] +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 55b2aa5..9254c48 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) 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 5955c5a..5c27873 100644 --- ql/src/test/results/clientpositive/cross_product_check_1.q.out +++ ql/src/test/results/clientpositive/cross_product_check_1.q.out @@ -209,24 +209,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 @@ -236,17 +233,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: @@ -260,7 +257,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 @@ -334,24 +331,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 @@ -361,17 +355,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: @@ -385,7 +379,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 @@ -467,24 +461,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 @@ -494,17 +485,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: @@ -518,7 +509,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 7f6da11..6178cd2 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 27feb5c..4f3d370 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) 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) 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) 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/groupby_ppd.q.out ql/src/test/results/clientpositive/groupby_ppd.q.out index cc7aa7b..4f7a7db 100644 --- ql/src/test/results/clientpositive/groupby_ppd.q.out +++ ql/src/test/results/clientpositive/groupby_ppd.q.out @@ -26,7 +26,7 @@ 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) + expressions: 1 (type: int), foo (type: int) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Union @@ -52,7 +52,7 @@ 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) + expressions: 1 (type: int), foo (type: int) outputColumnNames: _col0, _col1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Union diff --git ql/src/test/results/clientpositive/groupby_sort_1.q.out ql/src/test/results/clientpositive/groupby_sort_1.q.out index d684158..8c2f155 100644 --- ql/src/test/results/clientpositive/groupby_sort_1.q.out +++ ql/src/test/results/clientpositive/groupby_sort_1.q.out @@ -8049,7 +8049,7 @@ 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) + expressions: '8' (type: string), val (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator 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 8d731b9..15a34b5 100644 --- ql/src/test/results/clientpositive/groupby_sort_skew_1.q.out +++ ql/src/test/results/clientpositive/groupby_sort_skew_1.q.out @@ -8523,7 +8523,7 @@ 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) + expressions: '8' (type: string), val (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git ql/src/test/results/clientpositive/index_auto_empty.q.out ql/src/test/results/clientpositive/index_auto_empty.q.out index 47f396c..5bf84e6 100644 --- ql/src/test/results/clientpositive/index_auto_empty.q.out +++ ql/src/test/results/clientpositive/index_auto_empty.q.out @@ -65,7 +65,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: key (type: string), val (type: string) + expressions: '86' (type: string), val (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/index_auto_file_format.q.out ql/src/test/results/clientpositive/index_auto_file_format.q.out index 550bcbb..26e6c42 100644 --- ql/src/test/results/clientpositive/index_auto_file_format.q.out +++ ql/src/test/results/clientpositive/index_auto_file_format.q.out @@ -74,25 +74,25 @@ STAGE PLANS: TableScan alias: src filterExpr: (key = 86) (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 Filter Operator predicate: (key = 86) (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: '86' (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 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: 28 Data size: 2906 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: 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 @@ -204,25 +204,25 @@ STAGE PLANS: TableScan alias: src filterExpr: (key = 86) (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 Filter Operator predicate: (key = 86) (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: '86' (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 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: 28 Data size: 2906 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: 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/index_auto_multiple.q.out ql/src/test/results/clientpositive/index_auto_multiple.q.out index 06d7b6f..822865a 100644 --- ql/src/test/results/clientpositive/index_auto_multiple.q.out +++ ql/src/test/results/clientpositive/index_auto_multiple.q.out @@ -98,25 +98,25 @@ STAGE PLANS: TableScan alias: src filterExpr: (key = 86) (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 Filter Operator predicate: (key = 86) (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: '86' (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 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: 28 Data size: 2906 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: 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/index_auto_partitioned.q.out ql/src/test/results/clientpositive/index_auto_partitioned.q.out index e790490..8d87af0 100644 --- ql/src/test/results/clientpositive/index_auto_partitioned.q.out +++ ql/src/test/results/clientpositive/index_auto_partitioned.q.out @@ -88,25 +88,25 @@ STAGE PLANS: TableScan alias: srcpart filterExpr: ((key = 86) and (ds = '2008-04-09')) (type: boolean) - 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 Filter Operator predicate: (key = 86) (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) + expressions: '86' (type: string), value (type: string) outputColumnNames: _col0, _col1 - 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 Reduce Output Operator key expressions: _col0 (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 value expressions: _col0 (type: string), _col1 (type: string) Reduce Operator Tree: Extract - 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 - 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 table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/index_auto_update.q.out ql/src/test/results/clientpositive/index_auto_update.q.out index abbd3f4..a55640a 100644 --- ql/src/test/results/clientpositive/index_auto_update.q.out +++ ql/src/test/results/clientpositive/index_auto_update.q.out @@ -281,7 +281,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), val (type: string) + expressions: '86' (type: string), val (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/index_bitmap_auto_partitioned.q.out ql/src/test/results/clientpositive/index_bitmap_auto_partitioned.q.out index b345127..5e9bb85 100644 --- ql/src/test/results/clientpositive/index_bitmap_auto_partitioned.q.out +++ ql/src/test/results/clientpositive/index_bitmap_auto_partitioned.q.out @@ -95,25 +95,25 @@ STAGE PLANS: TableScan alias: srcpart filterExpr: ((key = 86) and (ds = '2008-04-09')) (type: boolean) - 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 Filter Operator predicate: (key = 86) (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) + expressions: '86' (type: string), value (type: string) outputColumnNames: _col0, _col1 - 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 Reduce Output Operator key expressions: _col0 (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 value expressions: _col0 (type: string), _col1 (type: string) Reduce Operator Tree: Extract - 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 - 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 table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat diff --git ql/src/test/results/clientpositive/index_stale.q.out ql/src/test/results/clientpositive/index_stale.q.out index 156ec5e..9ceb5ca 100644 --- ql/src/test/results/clientpositive/index_stale.q.out +++ ql/src/test/results/clientpositive/index_stale.q.out @@ -87,7 +87,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), val (type: string) + expressions: '86' (type: string), val (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/index_stale_partitioned.q.out ql/src/test/results/clientpositive/index_stale_partitioned.q.out index 0dd2fff..d8fa57e 100644 --- ql/src/test/results/clientpositive/index_stale_partitioned.q.out +++ ql/src/test/results/clientpositive/index_stale_partitioned.q.out @@ -115,7 +115,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: string), val (type: string), foo (type: string) + expressions: '86' (type: string), val (type: string), foo (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/infer_const_type.q.out ql/src/test/results/clientpositive/infer_const_type.q.out index 6e84b28..e04900a 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 30a37b5..818848d 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 1dca66a..c0b1e78 100644 --- ql/src/test/results/clientpositive/input23.q.out +++ ql/src/test/results/clientpositive/input23.q.out @@ -136,7 +136,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col6, _col7, _col8, _col9 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/input38.q.out ql/src/test/results/clientpositive/input38.q.out index cbd3c22..14a88ca 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 f34a8d6..71b3050 100644 --- ql/src/test/results/clientpositive/input6.q.out +++ ql/src/test/results/clientpositive/input6.q.out @@ -29,17 +29,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src1 - Statistics: Num rows: 1 Data size: 216 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 2 Data size: 216 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: key is null (type: boolean) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE + Statistics: Num rows: 1 Data size: 108 Basic stats: COMPLETE 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 + Statistics: Num rows: 1 Data size: 108 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: 1 Data size: 108 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/input_part2.q.out ql/src/test/results/clientpositive/input_part2.q.out index b0dfea5..352375c 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 33c146d..0a785e3 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 17073b8..ce8c376 100644 --- ql/src/test/results/clientpositive/insert1.q.out +++ ql/src/test/results/clientpositive/insert1.q.out @@ -46,10 +46,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 @@ -245,10 +245,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 @@ -336,10 +336,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 6f9d52d..0f6def6 100644 --- ql/src/test/results/clientpositive/join38.q.out +++ ql/src/test/results/clientpositive/join38.q.out @@ -87,10 +87,10 @@ 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} @@ -118,22 +118,22 @@ STAGE PLANS: 0 key (type: string) 1 col11 (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 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 @@ -143,14 +143,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 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 f5fc300..d62d4c9 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: 1 (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) TableScan alias: p1 Statistics: Num rows: 5 Data size: 3173 Basic stats: COMPLETE Column stats: NONE @@ -341,7 +341,7 @@ 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: _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), _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) + value expressions: 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), _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) Reduce Operator Tree: Join Operator condition map: @@ -352,7 +352,7 @@ STAGE PLANS: 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 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _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), _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), _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: _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), 1 (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), _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 5bc5626..f018201 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: 1 (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) TableScan alias: p1 Statistics: Num rows: 5 Data size: 3173 Basic stats: COMPLETE Column stats: NONE @@ -358,7 +358,7 @@ 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: _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), _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) + value expressions: 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), _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) Reduce Operator Tree: Join Operator condition map: @@ -369,15 +369,15 @@ STAGE PLANS: 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 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((_col0 = 1) and (_col23 = _col1)) (type: boolean) - Statistics: Num rows: 1 Data size: 767 Basic stats: COMPLETE Column stats: NONE + predicate: (_col23 = _col1) (type: boolean) + Statistics: Num rows: 2 Data size: 1535 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _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), _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), _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: _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), 1 (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), _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 d7f2994..7314dae 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: 1 (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) TableScan alias: p1 Statistics: Num rows: 5 Data size: 3173 Basic stats: COMPLETE Column stats: NONE @@ -395,7 +395,7 @@ 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: _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), _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) + value expressions: 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), _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) Reduce Operator Tree: Join Operator condition map: @@ -406,7 +406,7 @@ STAGE PLANS: 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 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _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), _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), _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: _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), 1 (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), _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 6f0a595..465b43b 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: 1 (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) TableScan alias: p1 Statistics: Num rows: 5 Data size: 3173 Basic stats: COMPLETE Column stats: NONE @@ -412,7 +412,7 @@ 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: _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), _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) + value expressions: 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), _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) Reduce Operator Tree: Join Operator condition map: @@ -423,15 +423,15 @@ STAGE PLANS: 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 Statistics: Num rows: 5 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((_col0 = 1) and (_col23 = _col1)) (type: boolean) - Statistics: Num rows: 1 Data size: 767 Basic stats: COMPLETE Column stats: NONE + predicate: (_col23 = _col1) (type: boolean) + Statistics: Num rows: 2 Data size: 1535 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _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), _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), _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: _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), 1 (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), _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_filters_overlap.q.out ql/src/test/results/clientpositive/join_filters_overlap.q.out index 7c87ba1..8bf4928 100644 --- ql/src/test/results/clientpositive/join_filters_overlap.q.out +++ ql/src/test/results/clientpositive/join_filters_overlap.q.out @@ -254,9 +254,9 @@ POSTHOOK: query: select /*+ MAPJOIN(b,c)*/ * from a left outer join a b on (a.ke POSTHOOK: type: QUERY POSTHOOK: Input: default@a #### A masked pattern was here #### -100 40 NULL NULL NULL NULL -100 50 100 50 NULL NULL -100 60 NULL NULL 100 60 +100 40 NULL 50 NULL 60 +100 50 100 50 NULL 60 +100 60 NULL 50 100 60 PREHOOK: query: -- overlap on b explain extended select * from a right outer join a b on (a.key=b.key AND a.value=50 AND b.value=50) left outer join a c on (b.key=c.key AND b.value=60 AND c.value=60) PREHOOK: type: QUERY @@ -502,9 +502,9 @@ POSTHOOK: query: select /*+ MAPJOIN(a,c)*/ * from a right outer join a b on (a.k POSTHOOK: type: QUERY POSTHOOK: Input: default@a #### A masked pattern was here #### -NULL NULL 100 40 NULL NULL -100 50 100 50 NULL NULL -NULL NULL 100 60 100 60 +NULL 50 100 40 NULL 60 +100 50 100 50 NULL 60 +NULL 50 100 60 100 60 PREHOOK: query: -- overlap on b with two filters for each explain extended select * from a right outer join a b on (a.key=b.key AND a.value=50 AND b.value=50 AND b.value>10) left outer join a c on (b.key=c.key AND b.value=60 AND b.value>20 AND c.value=60) PREHOOK: type: QUERY @@ -764,9 +764,9 @@ POSTHOOK: query: select /*+ MAPJOIN(a,c)*/ * from a right outer join a b on (a.k POSTHOOK: type: QUERY POSTHOOK: Input: default@a #### A masked pattern was here #### -NULL NULL 100 40 NULL NULL -100 50 100 50 NULL NULL -NULL NULL 100 60 100 60 +NULL 50 100 40 NULL 60 +100 50 100 50 NULL 60 +NULL 50 100 60 100 60 PREHOOK: query: -- overlap on a, b explain extended select * from a full outer join a b on (a.key=b.key AND a.value=50 AND b.value=50) left outer join a c on (b.key=c.key AND b.value=60 AND c.value=60) left outer join a d on (a.key=d.key AND a.value=40 AND d.value=40) PREHOOK: type: QUERY @@ -1340,6 +1340,6 @@ POSTHOOK: query: select /*+ MAPJOIN(b,c, d)*/ * from a left outer join a b on (a POSTHOOK: type: QUERY POSTHOOK: Input: default@a #### A masked pattern was here #### -100 40 NULL NULL NULL NULL 100 40 -100 50 100 50 NULL NULL NULL NULL -100 60 NULL NULL 100 60 NULL NULL +100 40 NULL 50 NULL 60 100 40 +100 50 100 50 NULL 60 NULL 40 +100 60 NULL 50 100 60 NULL 40 diff --git ql/src/test/results/clientpositive/join_nullsafe.q.out ql/src/test/results/clientpositive/join_nullsafe.q.out index 5366507..d17c5b3 100644 --- ql/src/test/results/clientpositive/join_nullsafe.q.out +++ ql/src/test/results/clientpositive/join_nullsafe.q.out @@ -1334,11 +1334,11 @@ 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) + key expressions: null (type: void) sort order: + - Map-reduce partition columns: value (type: int) + Map-reduce partition columns: null (type: void) Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE - value expressions: key (type: int), value (type: int) + value expressions: key (type: int), null (type: void) TableScan alias: a Statistics: Num rows: 3 Data size: 26 Basic stats: COMPLETE Column stats: NONE @@ -1346,11 +1346,11 @@ 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) + key expressions: null (type: void) sort order: + - Map-reduce partition columns: key (type: int) + Map-reduce partition columns: null (type: void) Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: NONE - value expressions: key (type: int), value (type: int) + value expressions: null (type: void), value (type: int) Reduce Operator Tree: Join Operator condition map: @@ -1362,7 +1362,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col4, _col5 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 diff --git ql/src/test/results/clientpositive/lateral_view_ppd.q.out ql/src/test/results/clientpositive/lateral_view_ppd.q.out index 919f986..df255c7 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) 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) 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/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 d77b18b..3060368 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 {key} {value} - 1 {key} {value} - keys: - 0 key (type: string) - 1 key (type: string) + HashTable Sink Operator + condition expressions: + 0 {key} {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 2065a12..302e625 100644 --- ql/src/test/results/clientpositive/multi_insert.q.out +++ ql/src/test/results/clientpositive/multi_insert.q.out @@ -3281,45 +3281,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 @@ -3439,45 +3439,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 @@ -3597,45 +3597,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 @@ -3755,45 +3755,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 86118d4..e4d5a13 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 @@ -3330,45 +3330,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 @@ -3492,45 +3492,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 @@ -3654,45 +3654,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 @@ -3816,45 +3816,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 525b9f0..165ebb1 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 146d8e4..5e4b0db 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 5ee5905..de83d6c 100644 --- ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out +++ ql/src/test/results/clientpositive/orc_predicate_pushdown.q.out @@ -436,7 +436,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) @@ -506,10 +506,10 @@ STAGE PLANS: Map Operator Tree: TableScan alias: orc_pred - filterExpr: ((t is not null and (t < 0)) and (t > (- 2))) (type: boolean) + filterExpr: ((t is not null and (t < 0)) and (t > -2)) (type: boolean) 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) @@ -641,10 +641,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 Reduce Output Operator @@ -702,13 +702,13 @@ STAGE PLANS: Map Operator Tree: TableScan alias: orc_pred - filterExpr: (((t = (- 1)) and s is not null) and (s like 'bob%')) (type: boolean) + filterExpr: (((t = -1) and s is not null) and (s like 'bob%')) (type: boolean) 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 Reduce Output Operator @@ -834,7 +834,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) @@ -897,10 +897,10 @@ STAGE PLANS: Map Operator Tree: TableScan alias: orc_pred - filterExpr: (((s is not null and (s like 'bob%')) and (not (t) IN ((- 1), (- 2), (- 3)))) and t BETWEEN 25 AND 30) (type: boolean) + filterExpr: (((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: 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) @@ -1053,7 +1053,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) @@ -1127,10 +1127,10 @@ STAGE PLANS: Map Operator Tree: TableScan alias: orc_pred - filterExpr: (((((((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) + filterExpr: (((((((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: 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) @@ -1295,7 +1295,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) @@ -1396,10 +1396,10 @@ STAGE PLANS: Map Operator Tree: TableScan alias: orc_pred - filterExpr: (((((((((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) + filterExpr: (((((((((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: 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 87e8d21..8cfb448 100644 --- ql/src/test/results/clientpositive/pcr.q.out +++ ql/src/test/results/clientpositive/pcr.q.out @@ -1760,7 +1760,7 @@ 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) + expressions: 14 (type: int), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 20 Data size: 160 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator @@ -4813,7 +4813,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 @@ -4852,7 +4852,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 @@ -5671,20 +5671,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) + expressions: '11' (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 + 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) 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: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: string) Path -> Alias: @@ -5788,13 +5788,13 @@ STAGE PLANS: Needs Tagging: false Reduce Operator Tree: Extract - 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 @@ -5923,20 +5923,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) + expressions: '11' (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 + 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) 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: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: string) Path -> Alias: @@ -6040,13 +6040,13 @@ STAGE PLANS: Needs Tagging: false Reduce Operator Tree: Extract - 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 c6bb4d6..20c5471 100644 --- ql/src/test/results/clientpositive/ppd2.q.out +++ ql/src/test/results/clientpositive/ppd2.q.out @@ -351,28 +351,28 @@ 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) + key expressions: '20' (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 29 Data size: 2906 Basic stats: COMPLETE Column stats: NONE - value expressions: key (type: string) + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + value expressions: '20' (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) + key expressions: '20' (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 14 Data size: 2805 Basic stats: COMPLETE Column stats: NONE - value expressions: key (type: string), value (type: string) + Map-reduce partition columns: '20' (type: string) + Statistics: Num rows: 28 Data size: 2906 Basic stats: COMPLETE Column stats: NONE + value expressions: '20' (type: string), value (type: string) Reduce Operator Tree: Join Operator condition map: @@ -381,11 +381,11 @@ STAGE PLANS: 0 {VALUE._col0} {VALUE._col1} 1 {VALUE._col0} outputColumnNames: _col0, _col1, _col4 - 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 Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col4 (type: string) + expressions: '20' (type: string), _col1 (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 table: @@ -401,14 +401,14 @@ 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), _col1 (type: string), _col2 (type: string) + Statistics: Num rows: 1598 Data size: 3196 Basic stats: COMPLETE Column stats: NONE + value expressions: '20' (type: string), _col1 (type: string), '20' (type: string) Reduce Operator Tree: Extract - 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_constant_where.q.out ql/src/test/results/clientpositive/ppd_constant_where.q.out index 60256ef..66308cc 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 424f1b7..e7d7cf5 100644 --- ql/src/test/results/clientpositive/ppd_join4.q.out +++ ql/src/test/results/clientpositive/ppd_join4.q.out @@ -88,9 +88,9 @@ 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) + key expressions: 'a' (type: string) sort order: + - Map-reduce partition columns: id (type: string) + Map-reduce partition columns: 'a' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE TableScan Reduce Output Operator diff --git ql/src/test/results/clientpositive/ppd_outer_join5.q.out ql/src/test/results/clientpositive/ppd_outer_join5.q.out index bb6823c..d5557d7 100644 --- ql/src/test/results/clientpositive/ppd_outer_join5.q.out +++ ql/src/test/results/clientpositive/ppd_outer_join5.q.out @@ -45,11 +45,11 @@ 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) + key expressions: 20 (type: int) sort order: + - Map-reduce partition columns: id (type: int) + Map-reduce partition columns: 20 (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: id (type: int), key (type: string), value (type: string) + value expressions: 20 (type: int), key (type: string), value (type: string) TableScan alias: t2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE @@ -86,7 +86,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col5, _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: _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 @@ -134,11 +134,11 @@ 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) + key expressions: 20 (type: int) sort order: + - Map-reduce partition columns: id (type: int) + Map-reduce partition columns: 20 (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: id (type: int), key (type: string), value (type: string) + value expressions: 20 (type: int), key (type: string), value (type: string) TableScan alias: t1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE @@ -146,11 +146,11 @@ 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) + key expressions: 20 (type: int) sort order: + - Map-reduce partition columns: id (type: int) + Map-reduce partition columns: 20 (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: id (type: int), key (type: string), value (type: string) + value expressions: 20 (type: int), key (type: string), value (type: string) Reduce Operator Tree: Join Operator condition map: @@ -163,7 +163,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col5, _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 @@ -211,11 +211,11 @@ 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) + key expressions: 20 (type: int) sort order: + - Map-reduce partition columns: id (type: int) + Map-reduce partition columns: 20 (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: id (type: int), key (type: string), value (type: string) + value expressions: 20 (type: int), key (type: string), value (type: string) TableScan alias: t1 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE @@ -223,11 +223,11 @@ 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) + key expressions: 20 (type: int) sort order: + - Map-reduce partition columns: id (type: int) + Map-reduce partition columns: 20 (type: int) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: id (type: int), key (type: string), value (type: string) + value expressions: 20 (type: int), key (type: string), value (type: string) Reduce Operator Tree: Join Operator condition map: @@ -240,7 +240,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col5, _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 c9057cf..f050453 100644 --- ql/src/test/results/clientpositive/ppd_repeated_alias.q.out +++ ql/src/test/results/clientpositive/ppd_repeated_alias.q.out @@ -73,7 +73,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 @@ -206,7 +206,7 @@ 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: foo (type: int), bar (type: int) + value expressions: foo (type: int), 3 (type: int) Reduce Operator Tree: Join Operator condition map: @@ -217,7 +217,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _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 fada814..ba0228a 100644 --- ql/src/test/results/clientpositive/ppd_udf_case.q.out +++ ql/src/test/results/clientpositive/ppd_udf_case.q.out @@ -70,7 +70,7 @@ 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) + expressions: _col0 (type: string), _col1 (type: string), '2008-04-08' (type: string), _col3 (type: string), _col6 (type: string), _col7 (type: string), '2008-04-08' (type: string), _col9 (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 @@ -85,10 +85,10 @@ 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), '2008-04-08' (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), '2008-04-08' (type: string), _col7 (type: string) sort order: ++++++++ Statistics: Num rows: 3 Data size: 618 Basic stats: COMPLETE Column stats: NONE - value 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) + value expressions: _col0 (type: string), _col1 (type: string), '2008-04-08' (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: string), '2008-04-08' (type: string), _col7 (type: string) Reduce Operator Tree: Extract Statistics: Num rows: 3 Data size: 618 Basic stats: COMPLETE Column stats: NONE diff --git ql/src/test/results/clientpositive/ppd_udf_col.q.out ql/src/test/results/clientpositive/ppd_udf_col.q.out index e7bf7f5..05d6ea4 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) + expressions: '100' (type: string), rand() (type: double) outputColumnNames: _col0, _col2 - 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 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 + 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) + expressions: '100' (type: string), rand() (type: double) outputColumnNames: _col0, _col2 - 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 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 + 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) 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) + expressions: '100' (type: string), rand() (type: double), '4' (type: string) outputColumnNames: _col0, _col2, _col3 - 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 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) 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) + expressions: '100' (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 + 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) 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) + expressions: '100' (type: string), rand() (type: double) outputColumnNames: _col0, _col2 - 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 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 + 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) + expressions: '100' (type: string), rand() (type: double) outputColumnNames: _col0, _col2 - 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 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) 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) + expressions: '100' (type: string), rand() (type: double), '4' (type: string) outputColumnNames: _col0, _col2, _col3 - 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 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) 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) + expressions: '100' (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 + 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) 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 afb50c1..4eb1244 100644 --- ql/src/test/results/clientpositive/ppd_union_view.q.out +++ ql/src/test/results/clientpositive/ppd_union_view.q.out @@ -562,7 +562,7 @@ STAGE PLANS: outputColumnNames: _col1, _col2, _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 5310379..b3f79ec 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 d091758..86bc7c5 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,11 +112,11 @@ 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 - keys: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + keys: x+1 (type: string), y&y (type: string), '1' (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE @@ -171,11 +171,11 @@ 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 - keys: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + keys: x+1 (type: string), y&y (type: string), '1' (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE @@ -254,11 +254,11 @@ 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 - keys: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + keys: x+1 (type: string), y&y (type: string), '1' (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE diff --git ql/src/test/results/clientpositive/quotedid_partition.q.out ql/src/test/results/clientpositive/quotedid_partition.q.out index 897e2a9..79f2875 100644 --- ql/src/test/results/clientpositive/quotedid_partition.q.out +++ ql/src/test/results/clientpositive/quotedid_partition.q.out @@ -49,11 +49,11 @@ STAGE PLANS: predicate: (x+1 = '10') (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: 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 - keys: x+1 (type: string), y&y (type: string), !@#$%^&*()_q (type: string) + keys: '10' (type: string), y&y (type: string), !@#$%^&*()_q (type: string) mode: hash outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE diff --git ql/src/test/results/clientpositive/quotedid_skew.q.out ql/src/test/results/clientpositive/quotedid_skew.q.out index 15691d9..137b00c 100644 --- ql/src/test/results/clientpositive/quotedid_skew.q.out +++ ql/src/test/results/clientpositive/quotedid_skew.q.out @@ -138,11 +138,11 @@ STAGE PLANS: predicate: (!@#$%^&*()_q = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: !@#$%^&*()_q (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: !@#$%^&*()_q (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: !@#$%^&*()_q (type: string), y&y (type: string) + value expressions: '2' (type: string), y&y (type: string) TableScan alias: a Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -150,11 +150,11 @@ STAGE PLANS: predicate: (!@#$%^&*()_q = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: !@#$%^&*()_q (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: !@#$%^&*()_q (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: !@#$%^&*()_q (type: string), y&y (type: string) + value expressions: '2' (type: string), y&y (type: string) Reduce Operator Tree: Join Operator condition map: @@ -165,7 +165,7 @@ STAGE PLANS: 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) + expressions: '2' (type: string), _col1 (type: string), '2' (type: string), _col5 (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/regex_col.q.out ql/src/test/results/clientpositive/regex_col.q.out index 530727d..84e2117 100644 --- ql/src/test/results/clientpositive/regex_col.q.out +++ ql/src/test/results/clientpositive/regex_col.q.out @@ -173,27 +173,27 @@ 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: '103' (type: string), 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: '103' (type: string), hr (type: string), ds (type: string) + Statistics: Num rows: 3874 Data size: 11624 Basic stats: COMPLETE Column stats: NONE value expressions: ds (type: string), hr (type: string) 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: '103' (type: string), 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: '103' (type: string), 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: @@ -202,11 +202,11 @@ STAGE PLANS: 0 1 {VALUE._col2} {VALUE._col3} 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: @@ -221,14 +221,14 @@ 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 value expressions: _col0 (type: string), _col1 (type: string) Reduce Operator Tree: Extract - 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 b420023..d2db204 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 @@ -414,7 +414,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 51619ad..272aa69 100644 --- ql/src/test/results/clientpositive/sample8.q.out +++ ql/src/test/results/clientpositive/sample8.q.out @@ -356,7 +356,7 @@ 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) + expressions: _col0 (type: string), _col1 (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 @@ -388,7 +388,7 @@ 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: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: string) + value expressions: _col0 (type: string), _col1 (type: string), '2008-04-08' (type: string), '11' (type: string) Path -> Alias: #### A masked pattern was here #### Path -> Partition: diff --git ql/src/test/results/clientpositive/select_dummy_source.q.out ql/src/test/results/clientpositive/select_dummy_source.q.out index d02b30e..5c4f645 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 630ff9f..9511a52 100644 --- ql/src/test/results/clientpositive/select_unquote_and.q.out +++ ql/src/test/results/clientpositive/select_unquote_and.q.out @@ -68,7 +68,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 1573b1d..ccb8c79 100644 --- ql/src/test/results/clientpositive/select_unquote_not.q.out +++ ql/src/test/results/clientpositive/select_unquote_not.q.out @@ -68,7 +68,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 211b0d2..265049e 100644 --- ql/src/test/results/clientpositive/select_unquote_or.q.out +++ ql/src/test/results/clientpositive/select_unquote_or.q.out @@ -68,7 +68,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 6cf6550..0b20107 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 50975f2..e7313c4 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/skewjoinopt10.q.out ql/src/test/results/clientpositive/skewjoinopt10.q.out index e0d54a1..1cd0e8e 100644 --- ql/src/test/results/clientpositive/skewjoinopt10.q.out +++ ql/src/test/results/clientpositive/skewjoinopt10.q.out @@ -60,15 +60,15 @@ STAGE PLANS: Map Operator Tree: TableScan alias: a - 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: (not (key = '8')) (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 Reduce Output Operator key expressions: key (type: string) sort order: + Map-reduce partition columns: key (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: key (type: string) TableScan alias: b @@ -90,11 +90,11 @@ STAGE PLANS: 0 {VALUE._col0} 1 {VALUE._col1} outputColumnNames: _col0, _col5 - Statistics: Num rows: 3 Data size: 13 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 16 Data size: 16 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col5 (type: array) outputColumnNames: _col0, _col1 - Statistics: Num rows: 3 Data size: 13 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 16 Data size: 16 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -107,25 +107,25 @@ STAGE PLANS: Map Operator Tree: TableScan Union - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE Select Operator SELECT * : (no compute) - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE Lateral View Forward - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE Select Operator SELECT * : (no compute) - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: array), _col2 (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -133,45 +133,45 @@ STAGE PLANS: Select Operator expressions: _col1 (type: array) outputColumnNames: _col0 - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE UDTF Operator - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE function name: explode Lateral View Join Operator outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: array), _col2 (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 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 TableScan Union - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE Select Operator SELECT * : (no compute) - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE Lateral View Forward - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE Select Operator SELECT * : (no compute) - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE Lateral View Join Operator outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: array), _col2 (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -179,20 +179,20 @@ STAGE PLANS: Select Operator expressions: _col1 (type: array) outputColumnNames: _col0 - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE UDTF Operator - Statistics: Num rows: 6 Data size: 26 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 32 Data size: 32 Basic stats: COMPLETE Column stats: NONE function name: explode Lateral View Join Operator outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col0 (type: string), _col1 (type: array), _col2 (type: string) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 12 Data size: 52 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 64 Data size: 64 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -203,16 +203,16 @@ STAGE PLANS: Map Operator Tree: TableScan alias: a - 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 = '8') (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 Reduce Output Operator - key expressions: key (type: string) + key expressions: '8' (type: string) sort order: + - Map-reduce partition columns: key (type: string) - Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string) + Map-reduce partition columns: '8' (type: string) + Statistics: Num rows: 15 Data size: 15 Basic stats: COMPLETE Column stats: NONE + value expressions: '8' (type: string) TableScan alias: b Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE @@ -220,9 +220,9 @@ STAGE PLANS: predicate: (key = '8') (type: boolean) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '8' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '8' (type: string) Statistics: Num rows: 3 Data size: 12 Basic stats: COMPLETE Column stats: NONE value expressions: value (type: array) Reduce Operator Tree: @@ -233,11 +233,11 @@ STAGE PLANS: 0 {VALUE._col0} 1 {VALUE._col1} outputColumnNames: _col0, _col5 - Statistics: Num rows: 3 Data size: 13 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 16 Data size: 16 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col5 (type: array) + expressions: '8' (type: string), _col5 (type: array) outputColumnNames: _col0, _col1 - Statistics: Num rows: 3 Data size: 13 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 16 Data size: 16 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: diff --git ql/src/test/results/clientpositive/skewjoinopt11.q.out ql/src/test/results/clientpositive/skewjoinopt11.q.out index b05cb45..2fa43ae 100644 --- ql/src/test/results/clientpositive/skewjoinopt11.q.out +++ ql/src/test/results/clientpositive/skewjoinopt11.q.out @@ -184,11 +184,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) TableScan alias: b Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -196,9 +196,9 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE value expressions: val (type: string) Reduce Operator Tree: @@ -211,7 +211,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col5 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col5 (type: string) + expressions: '2' (type: string), _col1 (type: string), _col5 (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -231,11 +231,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) TableScan alias: b Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -243,9 +243,9 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE value expressions: val (type: string) Reduce Operator Tree: @@ -258,7 +258,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col5 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col5 (type: string) + expressions: '2' (type: string), _col1 (type: string), _col5 (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/skewjoinopt14.q.out ql/src/test/results/clientpositive/skewjoinopt14.q.out index 03a0c00..303d6df 100644 --- ql/src/test/results/clientpositive/skewjoinopt14.q.out +++ ql/src/test/results/clientpositive/skewjoinopt14.q.out @@ -192,11 +192,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) TableScan alias: a Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -204,11 +204,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) Reduce Operator Tree: Join Operator condition map: diff --git ql/src/test/results/clientpositive/skewjoinopt17.q.out ql/src/test/results/clientpositive/skewjoinopt17.q.out index d634e96..8e7f123 100644 --- ql/src/test/results/clientpositive/skewjoinopt17.q.out +++ ql/src/test/results/clientpositive/skewjoinopt17.q.out @@ -144,11 +144,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) TableScan alias: a Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -156,11 +156,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) Reduce Operator Tree: Join Operator condition map: @@ -171,7 +171,7 @@ STAGE PLANS: 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) + expressions: '2' (type: string), _col1 (type: string), '2' (type: string), _col5 (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/skewjoinopt19.q.out ql/src/test/results/clientpositive/skewjoinopt19.q.out index 8212c26..9704bcd 100644 --- ql/src/test/results/clientpositive/skewjoinopt19.q.out +++ ql/src/test/results/clientpositive/skewjoinopt19.q.out @@ -142,11 +142,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) TableScan alias: a Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -154,11 +154,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) Reduce Operator Tree: Join Operator condition map: @@ -169,7 +169,7 @@ STAGE PLANS: 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) + expressions: '2' (type: string), _col1 (type: string), '2' (type: string), _col5 (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/skewjoinopt20.q.out ql/src/test/results/clientpositive/skewjoinopt20.q.out index cfbace3..694abd2 100644 --- ql/src/test/results/clientpositive/skewjoinopt20.q.out +++ ql/src/test/results/clientpositive/skewjoinopt20.q.out @@ -142,11 +142,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) TableScan alias: a Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -154,11 +154,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) Reduce Operator Tree: Join Operator condition map: @@ -169,7 +169,7 @@ STAGE PLANS: 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) + expressions: '2' (type: string), _col1 (type: string), '2' (type: string), _col5 (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/skewjoinopt4.q.out ql/src/test/results/clientpositive/skewjoinopt4.q.out index 749ca24..fd43234 100644 --- ql/src/test/results/clientpositive/skewjoinopt4.q.out +++ ql/src/test/results/clientpositive/skewjoinopt4.q.out @@ -138,11 +138,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) TableScan alias: a Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -150,11 +150,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) Reduce Operator Tree: Join Operator condition map: @@ -165,7 +165,7 @@ STAGE PLANS: 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) + expressions: '2' (type: string), _col1 (type: string), '2' (type: string), _col5 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE File Output Operator @@ -301,11 +301,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) TableScan alias: a Statistics: Num rows: 0 Data size: 30 Basic stats: PARTIAL Column stats: NONE @@ -313,11 +313,11 @@ STAGE PLANS: predicate: (key = '2') (type: boolean) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Reduce Output Operator - key expressions: key (type: string) + key expressions: '2' (type: string) sort order: + - Map-reduce partition columns: key (type: string) + Map-reduce partition columns: '2' (type: string) Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE - value expressions: key (type: string), val (type: string) + value expressions: '2' (type: string), val (type: string) Reduce Operator Tree: Join Operator condition map: @@ -328,7 +328,7 @@ STAGE PLANS: 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) + expressions: '2' (type: string), _col1 (type: string), '2' (type: string), _col5 (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/smb_mapjoin_18.q.out ql/src/test/results/clientpositive/smb_mapjoin_18.q.out index 8c37752..a9b4ecf 100644 --- ql/src/test/results/clientpositive/smb_mapjoin_18.q.out +++ ql/src/test/results/clientpositive/smb_mapjoin_18.q.out @@ -282,7 +282,7 @@ 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) + expressions: 238 (type: int), 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/smb_mapjoin_25.q.out ql/src/test/results/clientpositive/smb_mapjoin_25.q.out index 37d856f..c149941 100644 --- ql/src/test/results/clientpositive/smb_mapjoin_25.q.out +++ ql/src/test/results/clientpositive/smb_mapjoin_25.q.out @@ -66,9 +66,9 @@ STAGE PLANS: predicate: (key = 5) (type: boolean) Statistics: Num rows: 25 Data size: 100 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: int) + key expressions: 5 (type: int) sort order: + - Map-reduce partition columns: key (type: int) + Map-reduce partition columns: 5 (type: int) Statistics: Num rows: 25 Data size: 100 Basic stats: COMPLETE Column stats: NONE TableScan alias: a @@ -77,11 +77,11 @@ STAGE PLANS: predicate: (key = 5) (type: boolean) Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: int) + key expressions: 5 (type: int) sort order: + - Map-reduce partition columns: key (type: int) + Map-reduce partition columns: 5 (type: int) Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: NONE - value expressions: key (type: int) + value expressions: 5 (type: int) Reduce Operator Tree: Join Operator condition map: @@ -92,7 +92,7 @@ STAGE PLANS: outputColumnNames: _col0 Statistics: Num rows: 28 Data size: 114 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int) + expressions: 5 (type: int) outputColumnNames: _col0 Statistics: Num rows: 28 Data size: 114 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -132,7 +132,7 @@ STAGE PLANS: predicate: (_col1 = 5) (type: boolean) Statistics: Num rows: 15 Data size: 62 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), _col1 (type: int) + expressions: _col0 (type: int), 5 (type: int) outputColumnNames: _col0, _col1 Statistics: Num rows: 15 Data size: 62 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -153,9 +153,9 @@ STAGE PLANS: predicate: (key = 5) (type: boolean) Statistics: Num rows: 27 Data size: 108 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: int) + key expressions: 5 (type: int) sort order: + - Map-reduce partition columns: key (type: int) + Map-reduce partition columns: 5 (type: int) Statistics: Num rows: 27 Data size: 108 Basic stats: COMPLETE Column stats: NONE TableScan alias: c @@ -164,11 +164,11 @@ STAGE PLANS: predicate: (key = 5) (type: boolean) Statistics: Num rows: 25 Data size: 100 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator - key expressions: key (type: int) + key expressions: 5 (type: int) sort order: + - Map-reduce partition columns: key (type: int) + Map-reduce partition columns: 5 (type: int) Statistics: Num rows: 25 Data size: 100 Basic stats: COMPLETE Column stats: NONE - value expressions: key (type: int) + value expressions: 5 (type: int) Reduce Operator Tree: Join Operator condition map: @@ -179,7 +179,7 @@ STAGE PLANS: outputColumnNames: _col0 Statistics: Num rows: 29 Data size: 118 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int) + expressions: 5 (type: int) outputColumnNames: _col0 Statistics: Num rows: 29 Data size: 118 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -236,7 +236,7 @@ STAGE PLANS: 1 key (type: int) outputColumnNames: _col0 Select Operator - expressions: _col0 (type: int) + expressions: 5 (type: int) outputColumnNames: _col0 Reduce Output Operator key expressions: _col0 (type: int) @@ -260,7 +260,7 @@ STAGE PLANS: 1 key (type: int) outputColumnNames: _col0 Select Operator - expressions: _col0 (type: int) + expressions: 5 (type: int) outputColumnNames: _col0 Reduce Output Operator key expressions: _col0 (type: int) @@ -278,7 +278,7 @@ STAGE PLANS: Filter Operator predicate: (_col1 = 5) (type: boolean) Select Operator - expressions: _col0 (type: int), _col1 (type: int) + expressions: _col0 (type: int), 5 (type: int) outputColumnNames: _col0, _col1 File Output Operator compressed: false 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 700c5b8..efe98cb 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 @@ -129,20 +127,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 180186a..89e12e5 100644 --- ql/src/test/results/clientpositive/subquery_exists.q.out +++ ql/src/test/results/clientpositive/subquery_exists.q.out @@ -64,20 +64,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 605777a..87130b2 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 96bee90..3f76bf1 100644 --- ql/src/test/results/clientpositive/subquery_in.q.out +++ ql/src/test/results/clientpositive/subquery_in.q.out @@ -150,20 +150,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 @@ -262,20 +259,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 @@ -436,20 +430,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 @@ -603,20 +594,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 @@ -748,20 +736,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 @@ -934,24 +919,24 @@ STAGE PLANS: value expressions: _col3 (type: int), _col0 (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 da18a9f..b873f40 100644 --- ql/src/test/results/clientpositive/subquery_in_having.q.out +++ ql/src/test/results/clientpositive/subquery_in_having.q.out @@ -129,20 +129,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 @@ -329,20 +326,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 @@ -490,20 +484,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 8e2a004..becd0eb 100644 --- ql/src/test/results/clientpositive/subquery_multiinsert.q.out +++ ql/src/test/results/clientpositive/subquery_multiinsert.q.out @@ -114,21 +114,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 @@ -207,12 +204,12 @@ 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 table: @@ -227,14 +224,14 @@ STAGE PLANS: 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: _col0 (type: string), _col1 (type: string) Reduce Operator Tree: Extract - 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 @@ -259,12 +256,12 @@ STAGE PLANS: Map Operator Tree: TableScan alias: s1 - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: NONE Filter Operator predicate: ((key > '2') and key is null) (type: boolean) - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Group By Operator aggregations: count() mode: hash @@ -554,12 +551,12 @@ STAGE PLANS: Map Operator Tree: TableScan alias: s1 - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: NONE Filter Operator predicate: ((key > '2') and key is null) (type: boolean) - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Group By Operator aggregations: count() mode: hash @@ -679,25 +676,25 @@ 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 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: _col0 (type: string), _col1 (type: string) Local Work: Map Reduce Local Work Reduce Operator Tree: Extract - 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 @@ -793,21 +790,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: diff --git ql/src/test/results/clientpositive/subquery_notexists.q.out ql/src/test/results/clientpositive/subquery_notexists.q.out index de73dff..5b59b45 100644 --- ql/src/test/results/clientpositive/subquery_notexists.q.out +++ ql/src/test/results/clientpositive/subquery_notexists.q.out @@ -61,15 +61,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 @@ -315,15 +315,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 249add4..7e6dae0 100644 --- ql/src/test/results/clientpositive/subquery_notexists_having.q.out +++ ql/src/test/results/clientpositive/subquery_notexists_having.q.out @@ -95,15 +95,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col8 Statistics: Num rows: 31 Data size: 6393 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col8 is null) (type: boolean) - Statistics: Num rows: 7 Data size: 1443 Basic stats: COMPLETE Column stats: NONE + predicate: _col8 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 @@ -240,15 +240,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 diff --git ql/src/test/results/clientpositive/subquery_notin.q.out ql/src/test/results/clientpositive/subquery_notin.q.out index a8d9305..946055f 100644 --- ql/src/test/results/clientpositive/subquery_notin.q.out +++ ql/src/test/results/clientpositive/subquery_notin.q.out @@ -123,12 +123,12 @@ STAGE PLANS: Map Operator Tree: TableScan alias: s1 - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: NONE Filter Operator predicate: ((key > '2') and key is null) (type: boolean) - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Group By Operator aggregations: count() mode: hash @@ -229,15 +229,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 @@ -471,15 +471,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 @@ -746,15 +746,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 @@ -1044,15 +1044,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 @@ -1573,15 +1573,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 01d8fd8..29189b7 100644 --- ql/src/test/results/clientpositive/subquery_notin_having.q.out +++ ql/src/test/results/clientpositive/subquery_notin_having.q.out @@ -73,12 +73,12 @@ STAGE PLANS: Map Operator Tree: TableScan alias: s1 - Statistics: Num rows: 58 Data size: 5812 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 5812 Basic stats: PARTIAL Column stats: NONE Filter Operator predicate: ((key > '12') and key is null) (type: boolean) - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Select Operator - Statistics: Num rows: 9 Data size: 901 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 0 Data size: 0 Basic stats: NONE Column stats: NONE Group By Operator aggregations: count() mode: hash @@ -177,15 +177,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col4 Statistics: Num rows: 69 Data size: 7032 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col4 is null) (type: boolean) - Statistics: Num rows: 17 Data size: 1732 Basic stats: COMPLETE Column stats: NONE + predicate: _col4 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 @@ -357,15 +357,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col7 Statistics: Num rows: 34 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col7 is null) (type: boolean) - Statistics: Num rows: 8 Data size: 903 Basic stats: COMPLETE Column stats: NONE + predicate: _col7 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 @@ -650,15 +650,15 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col5 Statistics: Num rows: 34 Data size: 3839 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((1 = 1) and _col5 is null) (type: boolean) - Statistics: Num rows: 8 Data size: 903 Basic stats: COMPLETE Column stats: NONE + predicate: _col5 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 @@ -669,25 +669,25 @@ STAGE PLANS: Map Operator Tree: TableScan alias: a - Statistics: Num rows: 29 Data size: 3173 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 396 Data size: 3173 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: p_mfgr is null (type: boolean) - Statistics: Num rows: 14 Data size: 1531 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 198 Data size: 1586 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 + Statistics: Num rows: 198 Data size: 1586 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: max(p_retailprice), min(p_retailprice) - keys: p_mfgr (type: string) + keys: null (type: void) mode: hash outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 14 Data size: 1531 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 198 Data size: 1586 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: 1531 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 198 Data size: 1586 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: double), _col2 (type: double) Reduce Operator Tree: Group By Operator @@ -695,12 +695,12 @@ STAGE PLANS: keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 7 Data size: 765 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 99 Data size: 793 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: ((_col1 - _col2) > 600) (type: boolean) - Statistics: Num rows: 2 Data size: 218 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 33 Data size: 264 Basic stats: COMPLETE Column stats: NONE Select Operator - Statistics: Num rows: 2 Data size: 218 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 33 Data size: 264 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: count() mode: hash diff --git ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out index 54af989..71a6c29 100644 --- ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out +++ ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out @@ -117,20 +117,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 @@ -188,20 +185,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 @@ -331,20 +325,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 @@ -472,20 +463,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 @@ -591,20 +579,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 @@ -694,20 +679,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 @@ -851,7 +833,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 11e6bbb..f927aa3 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/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 9919461..15b067b 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 0cd0222..234cf43 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 f2844d5..93c01ed 100644 --- ql/src/test/results/clientpositive/udf4.q.out +++ ql/src/test/results/clientpositive/udf4.q.out @@ -77,7 +77,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 f1d9f1c..9d02048 100644 --- ql/src/test/results/clientpositive/udf5.q.out +++ ql/src/test/results/clientpositive/udf5.q.out @@ -33,7 +33,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 a5351f4..1336234 100644 --- ql/src/test/results/clientpositive/udf6.q.out +++ ql/src/test/results/clientpositive/udf6.q.out @@ -33,7 +33,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 @@ -89,7 +89,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 ff0f117..64ae757 100644 --- ql/src/test/results/clientpositive/udf7.q.out +++ ql/src/test/results/clientpositive/udf7.q.out @@ -47,7 +47,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 80d2825..fd2a8a3 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 eeb0245..213e6bb 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 870b744..983d3b8 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 67af3b8..b623336 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 085612f..a85fdd0 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 416aed9..a60e2ae 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 4c76aa7..76879af 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..50dcff0 100644 --- ql/src/test/results/clientpositive/udf_second.q.out +++ ql/src/test/results/clientpositive/udf_second.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: 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 + Statistics: Num rows: 1453 Data size: 2906 Basic stats: COMPLETE Column stats: NONE ListSink PREHOOK: query: SELECT second('2009-08-07 13:14:15'), second('13:14:15'), second('2009-08-07') 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 6ac1951..86c2223 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 @@ -338,14 +338,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 @@ -353,23 +353,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_view.q.out ql/src/test/results/clientpositive/union_view.q.out index 6df11b8..baac6a9 100644 --- ql/src/test/results/clientpositive/union_view.q.out +++ ql/src/test/results/clientpositive/union_view.q.out @@ -76,7 +76,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -135,7 +135,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -194,7 +194,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -474,7 +474,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Union @@ -539,7 +539,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Union @@ -604,7 +604,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Union @@ -673,7 +673,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Union @@ -695,7 +695,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Union @@ -717,7 +717,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE Union @@ -1076,7 +1076,7 @@ STAGE PLANS: predicate: (key = 86) (type: boolean) Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: key (type: int), value (type: string), ds (type: string) + expressions: 86 (type: int), value (type: string), ds (type: string) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE Union diff --git ql/src/test/results/clientpositive/vector_between_in.q.out ql/src/test/results/clientpositive/vector_between_in.q.out index cac9c85..0ddd4bc 100644 --- ql/src/test/results/clientpositive/vector_between_in.q.out +++ ql/src/test/results/clientpositive/vector_between_in.q.out @@ -21,7 +21,7 @@ STAGE PLANS: alias: decimal_date_test Statistics: Num rows: 12288 Data size: 2467616 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (cdate) IN (CAST( '1969-10-26' AS DATE), CAST( '1969-07-14' AS DATE)) (type: boolean) + predicate: (cdate) IN (1969-10-26, 1969-07-14) (type: boolean) Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cdate (type: date) @@ -66,7 +66,7 @@ STAGE PLANS: alias: decimal_date_test Statistics: Num rows: 12288 Data size: 2467616 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (not (cdate) IN (CAST( '1969-10-26' AS DATE), CAST( '1969-07-14' AS DATE), CAST( '1970-01-21' AS DATE))) (type: boolean) + predicate: (not (cdate) IN (1969-10-26, 1969-07-14, 1970-01-21)) (type: boolean) Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE Select Operator Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE @@ -120,7 +120,7 @@ STAGE PLANS: alias: decimal_date_test Statistics: Num rows: 12288 Data size: 2467616 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (cdecimal1) IN (2365.8945945946, 881.0135135135, (- 3367.6517567568)) (type: boolean) + predicate: (cdecimal1) IN (2365.8945945946, 881.0135135135, -3367.6517567568) (type: boolean) Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cdecimal1 (type: decimal(20,10)) @@ -165,7 +165,7 @@ STAGE PLANS: alias: decimal_date_test Statistics: Num rows: 12288 Data size: 2467616 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (not (cdecimal1) IN (2365.8945945946, 881.0135135135, (- 3367.6517567568))) (type: boolean) + predicate: (not (cdecimal1) IN (2365.8945945946, 881.0135135135, -3367.6517567568)) (type: boolean) Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE Select Operator Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE @@ -219,7 +219,7 @@ STAGE PLANS: alias: decimal_date_test Statistics: Num rows: 12288 Data size: 2467616 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: cdate BETWEEN CAST( '1969-12-30' AS DATE) AND CAST( '1970-01-02' AS DATE) (type: boolean) + predicate: cdate BETWEEN 1969-12-30 AND 1970-01-02 (type: boolean) Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cdate (type: date) @@ -264,7 +264,7 @@ STAGE PLANS: alias: decimal_date_test Statistics: Num rows: 12288 Data size: 2467616 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: cdate NOT BETWEEN CAST( '1968-05-01' AS DATE) AND CAST( '1971-09-01' AS DATE) (type: boolean) + predicate: cdate NOT BETWEEN 1968-05-01 AND 1971-09-01 (type: boolean) Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cdate (type: date) @@ -309,7 +309,7 @@ STAGE PLANS: alias: decimal_date_test Statistics: Num rows: 12288 Data size: 2467616 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: cdecimal1 BETWEEN (- 20) AND 45.9918918919 (type: boolean) + predicate: cdecimal1 BETWEEN -20 AND 45.9918918919 (type: boolean) Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cdecimal1 (type: decimal(20,10)) @@ -354,7 +354,7 @@ STAGE PLANS: alias: decimal_date_test Statistics: Num rows: 12288 Data size: 2467616 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: cdecimal1 NOT BETWEEN (- 2000) AND 4390.1351351351 (type: boolean) + predicate: cdecimal1 NOT BETWEEN -2000 AND 4390.1351351351 (type: boolean) Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE Select Operator Statistics: Num rows: 6144 Data size: 1233808 Basic stats: COMPLETE Column stats: NONE diff --git ql/src/test/results/clientpositive/vector_coalesce.q.out ql/src/test/results/clientpositive/vector_coalesce.q.out index 2f970d2..07e5002 100644 --- ql/src/test/results/clientpositive/vector_coalesce.q.out +++ ql/src/test/results/clientpositive/vector_coalesce.q.out @@ -21,7 +21,7 @@ STAGE PLANS: predicate: cdouble is null (type: boolean) Statistics: Num rows: 1571 Data size: 188558 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: cdouble (type: double), cstring1 (type: string), cint (type: int), cfloat (type: float), csmallint (type: smallint), COALESCE(cdouble,cstring1,cint,cfloat,csmallint) (type: string) + expressions: null (type: void), cstring1 (type: string), cint (type: int), cfloat (type: float), csmallint (type: smallint), COALESCE(null,cstring1,cint,cfloat,csmallint) (type: string) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 1571 Data size: 188558 Basic stats: COMPLETE Column stats: NONE Limit @@ -34,7 +34,6 @@ STAGE PLANS: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - Execution mode: vectorized Stage: Stage-0 Fetch Operator @@ -87,7 +86,7 @@ STAGE PLANS: predicate: ctinyint is null (type: boolean) Statistics: Num rows: 11788 Data size: 188610 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: ctinyint (type: tinyint), cdouble (type: double), cint (type: int), COALESCE((ctinyint + 10),(cdouble + log2(cint)),0) (type: double) + expressions: null (type: void), cdouble (type: double), cint (type: int), COALESCE((null + 10),(cdouble + log2(cint)),0) (type: double) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 11788 Data size: 188610 Basic stats: COMPLETE Column stats: NONE Limit @@ -100,7 +99,6 @@ STAGE PLANS: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - Execution mode: vectorized Stage: Stage-0 Fetch Operator @@ -153,7 +151,7 @@ STAGE PLANS: predicate: (cfloat is null and cbigint is null) (type: boolean) Statistics: Num rows: 7859 Data size: 94309 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: cfloat (type: float), cbigint (type: bigint), COALESCE(cfloat,cbigint,0) (type: float) + expressions: null (type: void), null (type: void), COALESCE(null,null,0) (type: float) outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 7859 Data size: 94309 Basic stats: COMPLETE Column stats: NONE Limit @@ -166,7 +164,6 @@ STAGE PLANS: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - Execution mode: vectorized Stage: Stage-0 Fetch Operator diff --git ql/src/test/results/clientpositive/vector_decimal_mapjoin.q.out ql/src/test/results/clientpositive/vector_decimal_mapjoin.q.out index 33f3d43..6c2f4a3 100644 --- ql/src/test/results/clientpositive/vector_decimal_mapjoin.q.out +++ ql/src/test/results/clientpositive/vector_decimal_mapjoin.q.out @@ -48,8 +48,8 @@ STAGE PLANS: 0 {cdecimal1} {cint} 1 {cdecimal2} {cint} keys: - 0 cint (type: int) - 1 cint (type: int) + 0 6981 (type: int) + 1 6981 (type: int) Stage: Stage-3 Map Reduce @@ -67,12 +67,12 @@ STAGE PLANS: 0 {cdecimal1} {cint} 1 {cdecimal2} {cint} keys: - 0 cint (type: int) - 1 cint (type: int) + 0 6981 (type: int) + 1 6981 (type: int) outputColumnNames: _col1, _col3, _col8, _col9 Statistics: Num rows: 6758 Data size: 1190783 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col3 (type: int), _col9 (type: int), _col1 (type: decimal(20,10)), _col8 (type: decimal(23,14)) + expressions: 6981 (type: int), 6981 (type: int), _col1 (type: decimal(20,10)), _col8 (type: decimal(23,14)) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 6758 Data size: 1190783 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/vector_decimal_math_funcs.q.out ql/src/test/results/clientpositive/vector_decimal_math_funcs.q.out index 952a7a4..023938f 100644 --- ql/src/test/results/clientpositive/vector_decimal_math_funcs.q.out +++ ql/src/test/results/clientpositive/vector_decimal_math_funcs.q.out @@ -95,7 +95,7 @@ STAGE PLANS: alias: decimal_test Statistics: Num rows: 12288 Data size: 2201752 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((cbigint % 500) = 0) and (sin(cdecimal1) >= (- 1.0))) (type: boolean) + predicate: (((cbigint % 500) = 0) and (sin(cdecimal1) >= -1.0)) (type: boolean) Statistics: Num rows: 2048 Data size: 366958 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cdecimal1 (type: decimal(20,10)), round(cdecimal1, 2) (type: decimal(13,2)), round(cdecimal1) (type: decimal(11,0)), floor(cdecimal1) (type: decimal(11,0)), ceil(cdecimal1) (type: decimal(11,0)), exp(cdecimal1) (type: double), ln(cdecimal1) (type: double), log10(cdecimal1) (type: double), log2(cdecimal1) (type: double), log2((cdecimal1 - 15601.0)) (type: double), log(2.0, cdecimal1) (type: double), power(log2(cdecimal1), 2.0) (type: double), power(log2(cdecimal1), 2.0) (type: double), sqrt(cdecimal1) (type: double), abs(cdecimal1) (type: decimal(38,18)), sin(cdecimal1) (type: double), asin(cdecimal1) (type: double), cos(cdecimal1) (type: double), acos(cdecimal1) (type: double), atan(cdecimal1) (type: double), degrees(cdecimal1) (type: double), radians(cdecimal1) (type: double), cdecimal1 (type: decimal(20,10)), (- cdecimal1) (type: decimal(20,10)), sign(cdecimal1) (type: int), cos(((- sin(log(cdecimal1))) + 3.14159)) (type: double) diff --git ql/src/test/results/clientpositive/vectorization_div0.q.out ql/src/test/results/clientpositive/vectorization_div0.q.out index 0752ae6..b0b156c 100644 --- ql/src/test/results/clientpositive/vectorization_div0.q.out +++ ql/src/test/results/clientpositive/vectorization_div0.q.out @@ -339,7 +339,7 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 23577 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((cdouble >= (- 500)) and (cdouble < (- 199))) (type: boolean) + predicate: ((cdouble >= -500) and (cdouble < -199)) (type: boolean) Statistics: Num rows: 2619 Data size: 41904 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: (cdouble + 200.0) (type: double), (cbigint / (cdouble + 200.0)) (type: double), ((cdouble + 200.0) / (cdouble + 200.0)) (type: double), (cbigint / (cdouble + 200.0)) (type: double), (3 / (cdouble + 200.0)) (type: double), (1.2 / (cdouble + 200.0)) (type: double) diff --git ql/src/test/results/clientpositive/vectorization_short_regress.q.out ql/src/test/results/clientpositive/vectorization_short_regress.q.out index 44cbae8..1881b37 100644 --- ql/src/test/results/clientpositive/vectorization_short_regress.q.out +++ ql/src/test/results/clientpositive/vectorization_short_regress.q.out @@ -143,7 +143,7 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 1347 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((((762 = cbigint) or ((csmallint < cfloat) and ((ctimestamp2 > (- 10669)) and (cdouble <> cint)))) or (cstring1 = 'a')) or ((cbigint <= (- 1.389)) and ((cstring2 <> 'a') and ((79.553 <> cint) and (cboolean2 <> cboolean1))))) (type: boolean) + predicate: ((((762 = cbigint) or ((csmallint < cfloat) and ((ctimestamp2 > -10669) and (cdouble <> cint)))) or (cstring1 = 'a')) or ((cbigint <= -1.389) and ((cstring2 <> 'a') and ((79.553 <> cint) and (cboolean2 <> cboolean1))))) (type: boolean) Statistics: Num rows: 1347 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cint (type: int), cdouble (type: double), csmallint (type: smallint), cfloat (type: float), ctinyint (type: tinyint) @@ -166,7 +166,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 Statistics: Num rows: 1 Data size: 68 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: double), (_col0 + (- 3728)) (type: double), (- (_col0 + (- 3728))) (type: double), (- (- (_col0 + (- 3728)))) (type: double), ((- (- (_col0 + (- 3728)))) * (_col0 + (- 3728))) (type: double), _col1 (type: double), (- _col0) (type: double), _col2 (type: double), (((- (- (_col0 + (- 3728)))) * (_col0 + (- 3728))) * (- (- (_col0 + (- 3728))))) (type: double), _col3 (type: double), (- _col2) (type: double), (_col2 - (- (- (_col0 + (- 3728))))) (type: double), ((_col2 - (- (- (_col0 + (- 3728))))) * _col2) (type: double), _col4 (type: double), _col5 (type: double), (10.175 - _col4) (type: double), (- (10.175 - _col4)) (type: double), ((- _col2) / (- 563)) (type: double), _col6 (type: double), (- ((- _col2) / (- 563))) (type: double), (_col0 / _col1) (type: double), _col7 (type: tinyint), _col8 (type: bigint), (_col7 / ((- _col2) / (- 563))) (type: double), (- (_col0 / _col1)) (type: double) + expressions: _col0 (type: double), (_col0 + -3728) (type: double), (- (_col0 + -3728)) (type: double), (- (- (_col0 + -3728))) (type: double), ((- (- (_col0 + -3728))) * (_col0 + -3728)) (type: double), _col1 (type: double), (- _col0) (type: double), _col2 (type: double), (((- (- (_col0 + -3728))) * (_col0 + -3728)) * (- (- (_col0 + -3728)))) (type: double), _col3 (type: double), (- _col2) (type: double), (_col2 - (- (- (_col0 + -3728)))) (type: double), ((_col2 - (- (- (_col0 + -3728)))) * _col2) (type: double), _col4 (type: double), _col5 (type: double), (10.175 - _col4) (type: double), (- (10.175 - _col4)) (type: double), ((- _col2) / -563) (type: double), _col6 (type: double), (- ((- _col2) / -563)) (type: double), (_col0 / _col1) (type: double), _col7 (type: tinyint), _col8 (type: bigint), (_col7 / ((- _col2) / -563)) (type: double), (- (_col0 / _col1)) (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 Statistics: Num rows: 1 Data size: 68 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -349,7 +349,7 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 1626 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((((cbigint <= 197) and (cint < cbigint)) or ((cdouble >= (- 26.28)) and (csmallint > cdouble))) or ((ctinyint > cfloat) and (cstring1 rlike '.*ss.*'))) or ((cfloat > 79.553) and (cstring2 like '10%'))) (type: boolean) + predicate: (((((cbigint <= 197) and (cint < cbigint)) or ((cdouble >= -26.28) and (csmallint > cdouble))) or ((ctinyint > cfloat) and (cstring1 rlike '.*ss.*'))) or ((cfloat > 79.553) and (cstring2 like '10%'))) (type: boolean) Statistics: Num rows: 902 Data size: 209266 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cint (type: int), cbigint (type: bigint), csmallint (type: smallint), cdouble (type: double), ctinyint (type: tinyint) @@ -372,7 +372,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 Statistics: Num rows: 1 Data size: 64 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: int), (_col0 / (- 3728)) (type: double), (_col0 * (- 3728)) (type: int), _col1 (type: double), (- (_col0 * (- 3728))) (type: int), _col2 (type: double), ((- 563) % (_col0 * (- 3728))) (type: int), (_col1 / _col2) (type: double), (- _col2) (type: double), _col3 (type: double), _col4 (type: double), (_col2 - 10.175) (type: double), _col5 (type: int), ((_col0 * (- 3728)) % (_col2 - 10.175)) (type: double), (- _col3) (type: double), _col6 (type: double), (_col3 % (- 26.28)) (type: double), _col7 (type: double), (- (_col0 / (- 3728))) (type: double), ((- (_col0 * (- 3728))) % ((- 563) % (_col0 * (- 3728)))) (type: int), ((_col0 / (- 3728)) - _col4) (type: double), (- (_col0 * (- 3728))) (type: int), _col8 (type: double) + expressions: _col0 (type: int), (_col0 / -3728) (type: double), (_col0 * -3728) (type: int), _col1 (type: double), (- (_col0 * -3728)) (type: int), _col2 (type: double), (-563 % (_col0 * -3728)) (type: int), (_col1 / _col2) (type: double), (- _col2) (type: double), _col3 (type: double), _col4 (type: double), (_col2 - 10.175) (type: double), _col5 (type: int), ((_col0 * -3728) % (_col2 - 10.175)) (type: double), (- _col3) (type: double), _col6 (type: double), (_col3 % -26.28) (type: double), _col7 (type: double), (- (_col0 / -3728)) (type: double), ((- (_col0 * -3728)) % (-563 % (_col0 * -3728))) (type: int), ((_col0 / -3728) - _col4) (type: double), (- (_col0 * -3728)) (type: int), _col8 (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 Statistics: Num rows: 1 Data size: 64 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -569,7 +569,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 Statistics: Num rows: 1 Data size: 56 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: double), (- _col0) (type: double), (_col0 - (- _col0)) (type: double), _col1 (type: bigint), (_col1 % 79.553) (type: double), _col2 (type: tinyint), (_col1 - (- _col0)) (type: double), (- (- _col0)) (type: double), ((- 1) % (- _col0)) (type: double), _col1 (type: bigint), (- _col1) (type: bigint), _col3 (type: double), (- (- (- _col0))) (type: double), (762 * (- _col1)) (type: bigint), _col4 (type: int), (_col2 + (762 * (- _col1))) (type: bigint), ((- _col0) + _col4) (type: double), _col5 (type: double), ((- _col1) % _col1) (type: bigint), _col6 (type: bigint), _col7 (type: double), ((- 3728) % (_col2 + (762 * (- _col1)))) (type: bigint) + expressions: _col0 (type: double), (- _col0) (type: double), (_col0 - (- _col0)) (type: double), _col1 (type: bigint), (_col1 % 79.553) (type: double), _col2 (type: tinyint), (_col1 - (- _col0)) (type: double), (- (- _col0)) (type: double), (-1 % (- _col0)) (type: double), _col1 (type: bigint), (- _col1) (type: bigint), _col3 (type: double), (- (- (- _col0))) (type: double), (762 * (- _col1)) (type: bigint), _col4 (type: int), (_col2 + (762 * (- _col1))) (type: bigint), ((- _col0) + _col4) (type: double), _col5 (type: double), ((- _col1) % _col1) (type: bigint), _col6 (type: bigint), _col7 (type: double), (-3728 % (_col2 + (762 * (- _col1)))) (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 Statistics: Num rows: 1 Data size: 56 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -745,7 +745,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Statistics: Num rows: 1 Data size: 44 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: double), (_col0 + 6981) (type: double), ((_col0 + 6981) + _col0) (type: double), _col1 (type: bigint), (((_col0 + 6981) + _col0) / _col0) (type: double), (- (_col0 + 6981)) (type: double), _col2 (type: double), (_col0 % (- (_col0 + 6981))) (type: double), _col3 (type: double), _col4 (type: double), (- _col1) (type: bigint), ((- _col1) / _col2) (type: double), _col5 (type: float), (_col4 * (- 26.28)) (type: double) + expressions: _col0 (type: double), (_col0 + 6981) (type: double), ((_col0 + 6981) + _col0) (type: double), _col1 (type: bigint), (((_col0 + 6981) + _col0) / _col0) (type: double), (- (_col0 + 6981)) (type: double), _col2 (type: double), (_col0 % (- (_col0 + 6981))) (type: double), _col3 (type: double), _col4 (type: double), (- _col1) (type: bigint), ((- _col1) / _col2) (type: double), _col5 (type: float), (_col4 * -26.28) (type: double) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 Statistics: Num rows: 1 Data size: 44 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -902,10 +902,10 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 1193 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((((cstring1 rlike 'a.*') and (cstring2 like '%ss%')) or ((1 <> cboolean2) and ((csmallint < 79.553) and ((- 257) <> ctinyint)))) or ((cdouble > ctinyint) and (cfloat >= cint))) or ((cint < cbigint) and (ctinyint > cbigint))) (type: boolean) + predicate: (((((cstring1 rlike 'a.*') and (cstring2 like '%ss%')) or ((1 <> cboolean2) and ((csmallint < 79.553) and (-257 <> ctinyint)))) or ((cdouble > ctinyint) and (cfloat >= cint))) or ((cint < cbigint) and (ctinyint > cbigint))) (type: boolean) Statistics: Num rows: 959 Data size: 303244 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: cint (type: int), cdouble (type: double), ctimestamp2 (type: timestamp), cstring1 (type: string), cboolean2 (type: boolean), ctinyint (type: tinyint), cfloat (type: float), ctimestamp1 (type: timestamp), csmallint (type: smallint), cbigint (type: bigint), ((- 3728) * cbigint) (type: bigint), (- cint) (type: int), ((- 863.257) - cint) (type: double), (- csmallint) (type: smallint), (csmallint - (- csmallint)) (type: smallint), ((csmallint - (- csmallint)) + (- csmallint)) (type: smallint), (cint / cint) (type: double), (((- 863.257) - cint) - (- 26.28)) (type: double), (- cfloat) (type: float), (cdouble * (- 89010)) (type: double), (ctinyint / 988888) (type: double), (- ctinyint) (type: tinyint), (79.553 / ctinyint) (type: double) + expressions: cint (type: int), cdouble (type: double), ctimestamp2 (type: timestamp), cstring1 (type: string), cboolean2 (type: boolean), ctinyint (type: tinyint), cfloat (type: float), ctimestamp1 (type: timestamp), csmallint (type: smallint), cbigint (type: bigint), (-3728 * cbigint) (type: bigint), (- cint) (type: int), (-863.257 - cint) (type: double), (- csmallint) (type: smallint), (csmallint - (- csmallint)) (type: smallint), ((csmallint - (- csmallint)) + (- csmallint)) (type: smallint), (cint / cint) (type: double), ((-863.257 - cint) - -26.28) (type: double), (- cfloat) (type: float), (cdouble * -89010) (type: double), (ctinyint / 988888) (type: double), (- ctinyint) (type: tinyint), (79.553 / ctinyint) (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 Statistics: Num rows: 959 Data size: 303244 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -2311,7 +2311,7 @@ STAGE PLANS: predicate: (((((197.0 > ctinyint) and (cint = cbigint)) or (cbigint = 359)) or (cboolean1 < 0)) or ((cstring1 like '%ss') and (cfloat <= ctinyint))) (type: boolean) Statistics: Num rows: 1347 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: cint (type: int), cbigint (type: bigint), cstring1 (type: string), cboolean1 (type: boolean), cfloat (type: float), cdouble (type: double), ctimestamp2 (type: timestamp), csmallint (type: smallint), cstring2 (type: string), cboolean2 (type: boolean), (cint / cbigint) (type: double), (cbigint % 79.553) (type: double), (- (cint / cbigint)) (type: double), (10.175 % cfloat) (type: double), (- cfloat) (type: float), (cfloat - (- cfloat)) (type: float), ((cfloat - (- cfloat)) % (- 6432)) (type: float), (cdouble * csmallint) (type: double), (- cdouble) (type: double), (- cbigint) (type: bigint), (cfloat - (cint / cbigint)) (type: double), (- csmallint) (type: smallint), (3569 % cbigint) (type: bigint), (359 - cdouble) (type: double), (- csmallint) (type: smallint) + expressions: cint (type: int), cbigint (type: bigint), cstring1 (type: string), cboolean1 (type: boolean), cfloat (type: float), cdouble (type: double), ctimestamp2 (type: timestamp), csmallint (type: smallint), cstring2 (type: string), cboolean2 (type: boolean), (cint / cbigint) (type: double), (cbigint % 79.553) (type: double), (- (cint / cbigint)) (type: double), (10.175 % cfloat) (type: double), (- cfloat) (type: float), (cfloat - (- cfloat)) (type: float), ((cfloat - (- cfloat)) % -6432) (type: float), (cdouble * csmallint) (type: double), (- cdouble) (type: double), (- cbigint) (type: bigint), (cfloat - (cint / cbigint)) (type: double), (- csmallint) (type: smallint), (3569 % cbigint) (type: bigint), (359 - cdouble) (type: double), (- csmallint) (type: smallint) 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 Statistics: Num rows: 1347 Data size: 377237 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -2490,10 +2490,10 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 1347 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((((csmallint > (- 26.28)) and (cstring2 like 'ss')) or ((cdouble <= cbigint) and ((cstring1 >= 'ss') and (cint <> cdouble)))) or (ctinyint = (- 89010))) or ((cbigint <= cfloat) and ((- 26.28) <= csmallint))) (type: boolean) + predicate: (((((csmallint > -26.28) and (cstring2 like 'ss')) or ((cdouble <= cbigint) and ((cstring1 >= 'ss') and (cint <> cdouble)))) or (ctinyint = -89010)) or ((cbigint <= cfloat) and (-26.28 <= csmallint))) (type: boolean) Statistics: Num rows: 1195 Data size: 334668 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: cint (type: int), cstring1 (type: string), cboolean2 (type: boolean), ctimestamp2 (type: timestamp), cdouble (type: double), cfloat (type: float), cbigint (type: bigint), csmallint (type: smallint), cboolean1 (type: boolean), (cint + csmallint) (type: int), (cbigint - ctinyint) (type: bigint), (- cbigint) (type: bigint), (- cfloat) (type: float), ((cbigint - ctinyint) + cbigint) (type: bigint), (cdouble / cdouble) (type: double), (- cdouble) (type: double), ((cint + csmallint) * (- cbigint)) (type: bigint), ((- cdouble) + cbigint) (type: double), ((- 1.389) / ctinyint) (type: double), (cbigint % cdouble) (type: double), (- csmallint) (type: smallint), (csmallint + (cint + csmallint)) (type: int) + expressions: cint (type: int), cstring1 (type: string), cboolean2 (type: boolean), ctimestamp2 (type: timestamp), cdouble (type: double), cfloat (type: float), cbigint (type: bigint), csmallint (type: smallint), cboolean1 (type: boolean), (cint + csmallint) (type: int), (cbigint - ctinyint) (type: bigint), (- cbigint) (type: bigint), (- cfloat) (type: float), ((cbigint - ctinyint) + cbigint) (type: bigint), (cdouble / cdouble) (type: double), (- cdouble) (type: double), ((cint + csmallint) * (- cbigint)) (type: bigint), ((- cdouble) + cbigint) (type: double), (-1.389 / ctinyint) (type: double), (cbigint % cdouble) (type: double), (- csmallint) (type: smallint), (csmallint + (cint + csmallint)) (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21 Statistics: Num rows: 1195 Data size: 334668 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator @@ -3250,10 +3250,10 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 1386 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((((- 1.389) >= cint) and ((csmallint < ctinyint) and ((- 6432) > csmallint))) or ((cdouble >= cfloat) and (cstring2 <= 'a'))) or ((cstring1 like 'ss%') and (10.175 > cbigint))) (type: boolean) + predicate: ((((-1.389 >= cint) and ((csmallint < ctinyint) and (-6432 > csmallint))) or ((cdouble >= cfloat) and (cstring2 <= 'a'))) or ((cstring1 like 'ss%') and (10.175 > cbigint))) (type: boolean) Statistics: Num rows: 436 Data size: 118669 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: ctimestamp1 (type: timestamp), cstring2 (type: string), cdouble (type: double), cfloat (type: float), cbigint (type: bigint), csmallint (type: smallint), (cbigint / 3569) (type: double), ((- 257) - csmallint) (type: int), ((- 6432) * cfloat) (type: float), (- cdouble) (type: double), (cdouble * 10.175) (type: double), (((- 6432) * cfloat) / cfloat) (type: double), (- cfloat) (type: float), (cint % csmallint) (type: int), (- cdouble) (type: double), (cdouble * (- cdouble)) (type: double) + expressions: ctimestamp1 (type: timestamp), cstring2 (type: string), cdouble (type: double), cfloat (type: float), cbigint (type: bigint), csmallint (type: smallint), (cbigint / 3569) (type: double), (-257 - csmallint) (type: int), (-6432 * cfloat) (type: float), (- cdouble) (type: double), (cdouble * 10.175) (type: double), ((-6432 * cfloat) / cfloat) (type: double), (- cfloat) (type: float), (cint % csmallint) (type: int), (- cdouble) (type: double), (cdouble * (- cdouble)) (type: double) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15 Statistics: Num rows: 436 Data size: 118669 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator @@ -4066,7 +4066,7 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 13472 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((csmallint >= (- 257)) and (((- 6432) = csmallint) or ((cint >= cdouble) and (ctinyint <= cint)))) (type: boolean) + predicate: ((csmallint >= -257) and ((-6432 = csmallint) or ((cint >= cdouble) and (ctinyint <= cint)))) (type: boolean) Statistics: Num rows: 2743 Data size: 76808 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: csmallint (type: smallint), cbigint (type: bigint), ctinyint (type: tinyint) @@ -4093,7 +4093,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 1371 Data size: 38389 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: smallint), (_col0 % (- 75)) (type: int), _col1 (type: double), ((- 1.389) / _col0) (type: double), _col2 (type: bigint), ((_col0 % (- 75)) / _col2) (type: double), (- (_col0 % (- 75))) (type: int), _col3 (type: double), (- (- (_col0 % (- 75)))) (type: int), _col4 (type: bigint), (_col4 - (- 89010)) (type: bigint) + expressions: _col0 (type: smallint), (_col0 % -75) (type: int), _col1 (type: double), (-1.389 / _col0) (type: double), _col2 (type: bigint), ((_col0 % -75) / _col2) (type: double), (- (_col0 % -75)) (type: int), _col3 (type: double), (- (- (_col0 % -75))) (type: int), _col4 (type: bigint), (_col4 - -89010) (type: bigint) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 Statistics: Num rows: 1371 Data size: 38389 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -5701,23 +5701,23 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 13472 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((cdouble > 2563.58) and ((((cbigint >= cint) and ((csmallint < cint) and (cfloat < (- 5638.15)))) or false) or ((cdouble <= cbigint) and ((- 5638.15) > cbigint)))) (type: boolean) - Statistics: Num rows: 2909 Data size: 81456 Basic stats: COMPLETE Column stats: NONE + predicate: ((cdouble > 2563.58) and (((cbigint >= cint) and ((csmallint < cint) and (cfloat < -5638.15))) or ((cdouble <= cbigint) and (-5638.15 > cbigint)))) (type: boolean) + Statistics: Num rows: 664 Data size: 18593 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cdouble (type: double), cfloat (type: float) outputColumnNames: cdouble, cfloat - Statistics: Num rows: 2909 Data size: 81456 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 664 Data size: 18593 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: var_samp(cdouble), count(cfloat), sum(cfloat), var_pop(cdouble), stddev_pop(cdouble), sum(cdouble) keys: cdouble (type: double) mode: hash outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 - Statistics: Num rows: 2909 Data size: 81456 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 664 Data size: 18593 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: double) sort order: + Map-reduce partition columns: _col0 (type: double) - Statistics: Num rows: 2909 Data size: 81456 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 664 Data size: 18593 Basic stats: COMPLETE Column stats: NONE value expressions: _col1 (type: struct), _col2 (type: bigint), _col3 (type: double), _col4 (type: struct), _col5 (type: struct), _col6 (type: double) Execution mode: vectorized Reduce Operator Tree: @@ -5726,11 +5726,11 @@ STAGE PLANS: keys: KEY._col0 (type: double) mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 - Statistics: Num rows: 1454 Data size: 40713 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 332 Data size: 9296 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: double), _col1 (type: double), (2563.58 * _col1) (type: double), (- _col1) (type: double), _col2 (type: bigint), ((2563.58 * _col1) + (- 5638.15)) (type: double), ((- _col1) * ((2563.58 * _col1) + (- 5638.15))) (type: double), _col3 (type: double), _col4 (type: double), (_col0 - (- _col1)) (type: double), _col5 (type: double), (_col0 + _col1) (type: double), (_col0 * 762) (type: double), _col6 (type: double), ((- 863.257) % (_col0 * 762)) (type: double), _col6 (type: double) + expressions: _col0 (type: double), _col1 (type: double), (2563.58 * _col1) (type: double), (- _col1) (type: double), _col2 (type: bigint), ((2563.58 * _col1) + -5638.15) (type: double), ((- _col1) * ((2563.58 * _col1) + -5638.15)) (type: double), _col3 (type: double), _col4 (type: double), (_col0 - (- _col1)) (type: double), _col5 (type: double), (_col0 + _col1) (type: double), (_col0 * 762) (type: double), _col6 (type: double), (-863.257 % (_col0 * 762)) (type: double), _col6 (type: double) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15 - Statistics: Num rows: 1454 Data size: 40713 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 332 Data size: 9296 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -5745,14 +5745,14 @@ STAGE PLANS: Reduce Output Operator key expressions: _col0 (type: double) sort order: + - Statistics: Num rows: 1454 Data size: 40713 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 332 Data size: 9296 Basic stats: COMPLETE Column stats: NONE value expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), _col3 (type: double), _col4 (type: bigint), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double), _col9 (type: double), _col10 (type: double), _col11 (type: double), _col12 (type: double), _col13 (type: double), _col14 (type: double), _col15 (type: double) Reduce Operator Tree: Extract - Statistics: Num rows: 1454 Data size: 40713 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 332 Data size: 9296 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false - Statistics: Num rows: 1454 Data size: 40713 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 332 Data size: 9296 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.TextInputFormat output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat @@ -5952,7 +5952,7 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 1209 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((ctimestamp1 <> 0) and ((((((((- 257) <> ctinyint) and cboolean2 is not null) and ((cstring1 rlike '.*ss') and ((- 10669) < ctimestamp1))) or (ctimestamp2 = (- 10669))) or ((ctimestamp1 < 0) and (cstring2 like '%b%'))) or (cdouble = cint)) or (cboolean1 is null and (cfloat < cint)))) (type: boolean) + predicate: ((ctimestamp1 <> 0) and (((((((-257 <> ctinyint) and cboolean2 is not null) and ((cstring1 rlike '.*ss') and (-10669 < ctimestamp1))) or (ctimestamp2 = -10669)) or ((ctimestamp1 < 0) and (cstring2 like '%b%'))) or (cdouble = cint)) or (cboolean1 is null and (cfloat < cint)))) (type: boolean) Statistics: Num rows: 1209 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: ctimestamp1 (type: timestamp), cstring1 (type: string), cint (type: int), csmallint (type: smallint), ctinyint (type: tinyint), cfloat (type: float), cdouble (type: double) @@ -5979,7 +5979,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 Statistics: Num rows: 604 Data size: 188462 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: timestamp), _col1 (type: string), _col2 (type: double), (_col2 * 10.175) (type: double), (- _col2) (type: double), _col3 (type: double), (- _col2) (type: double), ((- 26.28) - _col2) (type: double), _col4 (type: bigint), (- _col4) (type: bigint), (((- 26.28) - _col2) * (- _col2)) (type: double), _col5 (type: tinyint), ((((- 26.28) - _col2) * (- _col2)) * (- _col4)) (type: double), (- (_col2 * 10.175)) (type: double), _col6 (type: double), (_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) (type: double), (- (- _col2)) (type: double), ((- _col4) / _col2) (type: double), _col7 (type: double), (10.175 / _col3) (type: double), _col8 (type: double), _col9 (type: double), ((_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) - ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) (type: double), (- (- (_col2 * 10.175))) (type: double), _col10 (type: double), (((_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) - ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) * 10.175) (type: double), (10.175 % (10.175 / _col3)) (type: double), (- _col5) (type: tinyint), _col11 (type: double), _col12 (type: double), (- (((- 26.28) - _col2) * (- _col2))) (type: double), ((- _col2) % _col10) (type: double), ((- 26.28) / (- _col5)) (type: double), _col13 (type: double), _col14 (type: bigint), ((_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) / _col7) (type: double), (- (- _col4)) (type: bigint), _col4 (type: bigint), ((_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) % (- 26.28)) (type: double) + expressions: _col0 (type: timestamp), _col1 (type: string), _col2 (type: double), (_col2 * 10.175) (type: double), (- _col2) (type: double), _col3 (type: double), (- _col2) (type: double), (-26.28 - _col2) (type: double), _col4 (type: bigint), (- _col4) (type: bigint), ((-26.28 - _col2) * (- _col2)) (type: double), _col5 (type: tinyint), (((-26.28 - _col2) * (- _col2)) * (- _col4)) (type: double), (- (_col2 * 10.175)) (type: double), _col6 (type: double), (_col6 + (((-26.28 - _col2) * (- _col2)) * (- _col4))) (type: double), (- (- _col2)) (type: double), ((- _col4) / _col2) (type: double), _col7 (type: double), (10.175 / _col3) (type: double), _col8 (type: double), _col9 (type: double), ((_col6 + (((-26.28 - _col2) * (- _col2)) * (- _col4))) - (((-26.28 - _col2) * (- _col2)) * (- _col4))) (type: double), (- (- (_col2 * 10.175))) (type: double), _col10 (type: double), (((_col6 + (((-26.28 - _col2) * (- _col2)) * (- _col4))) - (((-26.28 - _col2) * (- _col2)) * (- _col4))) * 10.175) (type: double), (10.175 % (10.175 / _col3)) (type: double), (- _col5) (type: tinyint), _col11 (type: double), _col12 (type: double), (- ((-26.28 - _col2) * (- _col2))) (type: double), ((- _col2) % _col10) (type: double), (-26.28 / (- _col5)) (type: double), _col13 (type: double), _col14 (type: bigint), ((_col6 + (((-26.28 - _col2) * (- _col2)) * (- _col4))) / _col7) (type: double), (- (- _col4)) (type: bigint), _col4 (type: bigint), ((_col6 + (((-26.28 - _col2) * (- _col2)) * (- _col4))) % -26.28) (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, _col28, _col29, _col30, _col31, _col32, _col33, _col34, _col35, _col36, _col37, _col38 Statistics: Num rows: 604 Data size: 188462 Basic stats: COMPLETE Column stats: NONE File Output Operator @@ -6455,7 +6455,7 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 1347 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (cboolean1 is not null and (((((cdouble < csmallint) and ((cboolean2 = cboolean1) and (cbigint <= (- 863.257)))) or ((cint >= (- 257)) and (cstring1 is not null and (cboolean1 >= 1)))) or (cstring2 rlike 'b')) or ((csmallint >= ctinyint) and ctimestamp2 is null))) (type: boolean) + predicate: (cboolean1 is not null and (((((cdouble < csmallint) and ((cboolean2 = cboolean1) and (cbigint <= -863.257))) or ((cint >= -257) and (cstring1 is not null and (cboolean1 >= 1)))) or (cstring2 rlike 'b')) or ((csmallint >= ctinyint) and ctimestamp2 is null))) (type: boolean) Statistics: Num rows: 523 Data size: 146469 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cboolean1 (type: boolean), cfloat (type: float), cbigint (type: bigint), cint (type: int), cdouble (type: double), ctinyint (type: tinyint), csmallint (type: smallint) @@ -6482,7 +6482,7 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 Statistics: Num rows: 261 Data size: 73094 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col0 (type: boolean), _col1 (type: float), (- _col1) (type: float), ((- 26.28) / _col1) (type: double), _col2 (type: bigint), (_col2 - 10.175) (type: double), _col3 (type: double), (_col3 % _col1) (type: double), (10.175 + (- _col1)) (type: double), _col4 (type: double), ((_col2 - 10.175) + _col3) (type: double), _col5 (type: bigint), _col6 (type: double), (- (10.175 + (- _col1))) (type: double), (79.553 / _col6) (type: double), (_col3 % (79.553 / _col6)) (type: double), (- (10.175 + (- _col1))) (type: double), _col7 (type: bigint), _col8 (type: double), ((- 1.389) * _col5) (type: double), (_col7 - ((- 1.389) * _col5)) (type: double), _col9 (type: double), (- (_col7 - ((- 1.389) * _col5))) (type: double), _col10 (type: double), (- _col10) (type: double), (_col10 * _col7) (type: double) + expressions: _col0 (type: boolean), _col1 (type: float), (- _col1) (type: float), (-26.28 / _col1) (type: double), _col2 (type: bigint), (_col2 - 10.175) (type: double), _col3 (type: double), (_col3 % _col1) (type: double), (10.175 + (- _col1)) (type: double), _col4 (type: double), ((_col2 - 10.175) + _col3) (type: double), _col5 (type: bigint), _col6 (type: double), (- (10.175 + (- _col1))) (type: double), (79.553 / _col6) (type: double), (_col3 % (79.553 / _col6)) (type: double), (- (10.175 + (- _col1))) (type: double), _col7 (type: bigint), _col8 (type: double), (-1.389 * _col5) (type: double), (_col7 - (-1.389 * _col5)) (type: double), _col9 (type: double), (- (_col7 - (-1.389 * _col5))) (type: double), _col10 (type: double), (- _col10) (type: double), (_col10 * _col7) (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 Statistics: Num rows: 261 Data size: 73094 Basic stats: COMPLETE Column stats: NONE File Output Operator diff --git ql/src/test/results/clientpositive/vectorized_math_funcs.q.out ql/src/test/results/clientpositive/vectorized_math_funcs.q.out index 3b22970..afa9e71 100644 --- ql/src/test/results/clientpositive/vectorized_math_funcs.q.out +++ ql/src/test/results/clientpositive/vectorized_math_funcs.q.out @@ -118,7 +118,7 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 11788 Data size: 377237 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: (((cbigint % 500) = 0) and (sin(cfloat) >= (- 1.0))) (type: boolean) + predicate: (((cbigint % 500) = 0) and (sin(cfloat) >= -1.0)) (type: boolean) Statistics: Num rows: 1964 Data size: 62851 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: cdouble (type: double), round(cdouble, 2) (type: double), floor(cdouble) (type: bigint), ceil(cdouble) (type: bigint), rand() (type: double), rand(98007) (type: double), exp(ln(cdouble)) (type: double), ln(cdouble) (type: double), ln(cfloat) (type: double), log10(cdouble) (type: double), log2(cdouble) (type: double), log2((cdouble - 15601.0)) (type: double), log2(cfloat) (type: double), log2(cbigint) (type: double), log2(cint) (type: double), log2(csmallint) (type: double), log2(ctinyint) (type: double), log(2.0, cdouble) (type: double), power(log2(cdouble), 2.0) (type: double), power(log2(cdouble), 2.0) (type: double), sqrt(cdouble) (type: double), sqrt(cbigint) (type: double), bin(cbigint) (type: string), hex(cdouble) (type: string), conv(cbigint, 10, 16) (type: string), abs(cdouble) (type: double), abs(ctinyint) (type: int), (cint pmod 3) (type: int), sin(cdouble) (type: double), asin(cdouble) (type: double), cos(cdouble) (type: double), acos(cdouble) (type: double), atan(cdouble) (type: double), degrees(cdouble) (type: double), radians(cdouble) (type: double), cdouble (type: double), cbigint (type: bigint), (- cdouble) (type: double), sign(cdouble) (type: double), sign(cbigint) (type: double), cos(((- sin(log(cdouble))) + 3.14159)) (type: double) diff --git ql/src/test/results/compiler/plan/cast1.q.xml ql/src/test/results/compiler/plan/cast1.q.xml index 41d3e7c..3dfb562 100644 --- ql/src/test/results/compiler/plan/cast1.q.xml +++ ql/src/test/results/compiler/plan/cast1.q.xml @@ -380,7 +380,7 @@ _col6 - + @@ -412,7 +412,7 @@ _col5 - + @@ -444,7 +444,7 @@ _col4 - + @@ -504,7 +504,7 @@ _col3 - + @@ -543,7 +543,7 @@ _col2 - + @@ -582,7 +582,7 @@ _col1 - + @@ -621,7 +621,7 @@ _col0 - + @@ -665,25 +665,74 @@ - + + + + + + 5 + + - + + + + + + 5.0 + + - + + + + + + 5.0 + + - + + + + + + 5.0 + + - + + + + + + 5 + + - + + + + + + true + + - + + + + + + 1 + + @@ -911,7 +960,7 @@ src - + string diff --git ql/src/test/results/compiler/plan/groupby1.q.xml ql/src/test/results/compiler/plan/groupby1.q.xml index 284f0a3..5cea7c6 100755 --- ql/src/test/results/compiler/plan/groupby1.q.xml +++ ql/src/test/results/compiler/plan/groupby1.q.xml @@ -363,7 +363,7 @@ - + @@ -423,7 +423,11 @@ - + + + + + -1 @@ -617,7 +621,7 @@ - + 0.9 @@ -1330,7 +1334,7 @@ - + 0.9 diff --git ql/src/test/results/compiler/plan/groupby4.q.xml ql/src/test/results/compiler/plan/groupby4.q.xml index cb1a99b..3478d2f 100644 --- ql/src/test/results/compiler/plan/groupby4.q.xml +++ ql/src/test/results/compiler/plan/groupby4.q.xml @@ -197,7 +197,7 @@ - + @@ -253,7 +253,11 @@ - + + + + + -1 @@ -407,7 +411,7 @@ - + 0.9 @@ -1014,7 +1018,7 @@ - + 0.9 diff --git ql/src/test/results/compiler/plan/groupby5.q.xml ql/src/test/results/compiler/plan/groupby5.q.xml index 2fb8f20..59f9ee5 100644 --- ql/src/test/results/compiler/plan/groupby5.q.xml +++ ql/src/test/results/compiler/plan/groupby5.q.xml @@ -215,7 +215,7 @@ - + @@ -275,7 +275,11 @@ - + + + + + -1 @@ -469,7 +473,7 @@ - + 0.9 @@ -1205,7 +1209,7 @@ - + 0.9 diff --git ql/src/test/results/compiler/plan/groupby6.q.xml ql/src/test/results/compiler/plan/groupby6.q.xml index c2d9a36..f1b62e3 100644 --- ql/src/test/results/compiler/plan/groupby6.q.xml +++ ql/src/test/results/compiler/plan/groupby6.q.xml @@ -197,7 +197,7 @@ - + @@ -253,7 +253,11 @@ - + + + + + -1 @@ -407,7 +411,7 @@ - + 0.9 @@ -1014,7 +1018,7 @@ - + 0.9 diff --git ql/src/test/results/compiler/plan/input6.q.xml ql/src/test/results/compiler/plan/input6.q.xml index a94ee15..ab912fa 100644 --- ql/src/test/results/compiler/plan/input6.q.xml +++ ql/src/test/results/compiler/plan/input6.q.xml @@ -795,7 +795,7 @@ _col0 - + key @@ -814,7 +814,9 @@ - + + + @@ -854,7 +856,7 @@ src1 - + string @@ -940,7 +942,7 @@ src1 - + string diff --git ql/src/test/results/compiler/plan/join1.q.xml ql/src/test/results/compiler/plan/join1.q.xml index f5a6123..e93f422 100644 --- ql/src/test/results/compiler/plan/join1.q.xml +++ ql/src/test/results/compiler/plan/join1.q.xml @@ -418,9 +418,9 @@ - + - + key @@ -488,7 +488,11 @@ - + + + + + 1 @@ -710,7 +714,7 @@ VALUE._col0 - + key @@ -730,9 +734,9 @@ - + - + key @@ -800,12 +804,16 @@ - + + + + + - + @@ -1213,7 +1221,7 @@ _col1 - + _col5 @@ -1227,7 +1235,7 @@ _col0 - + _col0 @@ -1246,10 +1254,10 @@ - + - + @@ -1320,7 +1328,7 @@ _col5 - + VALUE._col1 @@ -1334,7 +1342,7 @@ _col0 - + VALUE._col0 @@ -1367,7 +1375,7 @@ 0 - + @@ -1375,7 +1383,7 @@ 1 - + diff --git ql/src/test/results/compiler/plan/join2.q.xml ql/src/test/results/compiler/plan/join2.q.xml index 92292b7..7571754 100644 --- ql/src/test/results/compiler/plan/join2.q.xml +++ ql/src/test/results/compiler/plan/join2.q.xml @@ -350,9 +350,9 @@ - + - + @@ -455,7 +455,11 @@ - + + + + + @@ -629,9 +633,9 @@ - + - + @@ -720,7 +724,11 @@ - + + + + + 1 @@ -1722,9 +1730,9 @@ - + - + key @@ -1792,7 +1800,11 @@ - + + + + + 1 @@ -1988,7 +2000,7 @@ VALUE._col0 - + key @@ -2008,9 +2020,9 @@ - + - + key @@ -2078,12 +2090,16 @@ - + + + + + - + @@ -2425,7 +2441,7 @@ _col4 - + VALUE._col0 @@ -2439,7 +2455,7 @@ _col0 - + VALUE._col0 @@ -2472,7 +2488,7 @@ 0 - + @@ -2480,7 +2496,7 @@ 1 - + diff --git ql/src/test/results/compiler/plan/join3.q.xml ql/src/test/results/compiler/plan/join3.q.xml index c44132b..4b28521 100644 --- ql/src/test/results/compiler/plan/join3.q.xml +++ ql/src/test/results/compiler/plan/join3.q.xml @@ -469,9 +469,9 @@ - + - + key @@ -535,7 +535,11 @@ - + + + + + 1 @@ -731,7 +735,7 @@ VALUE._col1 - + value @@ -765,9 +769,9 @@ - + - + key @@ -835,7 +839,11 @@ - + + + + + 2 @@ -843,7 +851,7 @@ - + @@ -1053,7 +1061,7 @@ VALUE._col0 - + key @@ -1073,9 +1081,9 @@ - + - + key @@ -1143,12 +1151,16 @@ - + + + + + - + @@ -1559,7 +1571,7 @@ _col1 - + _col9 @@ -1573,7 +1585,7 @@ _col0 - + _col0 @@ -1592,10 +1604,10 @@ - + - + @@ -1666,7 +1678,7 @@ _col0 - + VALUE._col0 @@ -1680,7 +1692,7 @@ _col9 - + VALUE._col1 @@ -1720,7 +1732,7 @@ 0 - + @@ -1732,7 +1744,7 @@ 2 - + diff --git ql/src/test/results/compiler/plan/join4.q.xml ql/src/test/results/compiler/plan/join4.q.xml index c7257e8..0cfaf61 100644 --- ql/src/test/results/compiler/plan/join4.q.xml +++ ql/src/test/results/compiler/plan/join4.q.xml @@ -270,9 +270,9 @@ - + - + _col0 @@ -340,7 +340,11 @@ - + + + + + @@ -439,7 +443,7 @@ _col1 - + value @@ -453,7 +457,7 @@ _col0 - + key @@ -472,10 +476,10 @@ - + - + @@ -794,7 +798,7 @@ VALUE._col1 - + _col1 @@ -805,7 +809,7 @@ VALUE._col0 - + _col0 @@ -822,7 +826,7 @@ - + @@ -892,7 +896,7 @@ - + 1 @@ -900,10 +904,10 @@ - + - + @@ -994,7 +998,7 @@ _col1 - + value @@ -1008,7 +1012,7 @@ _col0 - + key @@ -1027,10 +1031,10 @@ - + - + @@ -1600,7 +1604,7 @@ _col3 - + _col3 @@ -1614,7 +1618,7 @@ _col2 - + _col2 @@ -1628,7 +1632,7 @@ _col1 - + _col1 @@ -1642,7 +1646,7 @@ _col0 - + _col0 @@ -1661,6 +1665,9 @@ + + + @@ -1669,9 +1676,6 @@ - - - @@ -1791,7 +1795,7 @@ _col3 - + VALUE._col1 @@ -1805,7 +1809,7 @@ _col2 - + VALUE._col0 @@ -1819,7 +1823,7 @@ _col1 - + VALUE._col1 @@ -1833,7 +1837,7 @@ _col0 - + VALUE._col0 @@ -1869,10 +1873,10 @@ 0 - + - + @@ -1880,10 +1884,10 @@ 1 - + - + diff --git ql/src/test/results/compiler/plan/join5.q.xml ql/src/test/results/compiler/plan/join5.q.xml index bc62668..d8e6daf 100644 --- ql/src/test/results/compiler/plan/join5.q.xml +++ ql/src/test/results/compiler/plan/join5.q.xml @@ -822,9 +822,9 @@ - + - + _col0 @@ -892,7 +892,11 @@ - + + + + + 1 @@ -994,7 +998,7 @@ _col1 - + value @@ -1008,7 +1012,7 @@ _col0 - + key @@ -1027,10 +1031,10 @@ - + - + @@ -1600,7 +1604,7 @@ _col3 - + _col3 @@ -1614,7 +1618,7 @@ _col2 - + _col2 @@ -1628,7 +1632,7 @@ _col1 - + _col1 @@ -1642,7 +1646,7 @@ _col0 - + _col0 @@ -1661,6 +1665,9 @@ + + + @@ -1669,9 +1676,6 @@ - - - @@ -1791,7 +1795,7 @@ _col3 - + VALUE._col1 @@ -1805,7 +1809,7 @@ _col2 - + VALUE._col0 @@ -1819,7 +1823,7 @@ _col1 - + VALUE._col1 @@ -1833,7 +1837,7 @@ _col0 - + VALUE._col0 @@ -1869,10 +1873,10 @@ 0 - + - + @@ -1880,10 +1884,10 @@ 1 - + - + diff --git ql/src/test/results/compiler/plan/join8.q.xml ql/src/test/results/compiler/plan/join8.q.xml index bb9ec1f..6b9a4d9 100644 --- ql/src/test/results/compiler/plan/join8.q.xml +++ ql/src/test/results/compiler/plan/join8.q.xml @@ -270,9 +270,9 @@ - + - + _col0 @@ -340,7 +340,11 @@ - + + + + + @@ -439,7 +443,7 @@ _col1 - + value @@ -453,7 +457,7 @@ _col0 - + key @@ -472,10 +476,10 @@ - + - + @@ -835,7 +839,7 @@ VALUE._col1 - + _col1 @@ -846,7 +850,7 @@ VALUE._col0 - + _col0 @@ -863,7 +867,7 @@ - + @@ -933,7 +937,7 @@ - + 1 @@ -941,10 +945,10 @@ - + - + @@ -1035,7 +1039,7 @@ _col1 - + value @@ -1049,7 +1053,7 @@ _col0 - + key @@ -1068,10 +1072,10 @@ - + - + @@ -1685,7 +1689,7 @@ _col3 - + _col3 @@ -1699,7 +1703,7 @@ _col2 - + _col2 @@ -1713,7 +1717,7 @@ _col1 - + _col1 @@ -1727,7 +1731,7 @@ _col0 - + _col0 @@ -1746,6 +1750,9 @@ + + + @@ -1754,9 +1761,6 @@ - - - @@ -1879,7 +1883,7 @@ - + @@ -1946,7 +1950,11 @@ b - + + + void + + string @@ -1980,7 +1988,7 @@ _col3 - + VALUE._col1 @@ -1994,7 +2002,7 @@ _col2 - + VALUE._col0 @@ -2008,7 +2016,7 @@ _col1 - + VALUE._col1 @@ -2022,7 +2030,7 @@ _col0 - + VALUE._col0 @@ -2058,10 +2066,10 @@ 0 - + - + @@ -2069,10 +2077,10 @@ 1 - + - + diff --git ql/src/test/results/compiler/plan/udf1.q.xml ql/src/test/results/compiler/plan/udf1.q.xml index 3e944ad..cc6c978 100644 --- ql/src/test/results/compiler/plan/udf1.q.xml +++ ql/src/test/results/compiler/plan/udf1.q.xml @@ -536,7 +536,7 @@ _col8 - + @@ -581,7 +581,7 @@ _col7 - + @@ -626,7 +626,7 @@ _col6 - + @@ -671,7 +671,7 @@ _col5 - + @@ -716,7 +716,7 @@ _col4 - + @@ -761,7 +761,7 @@ _col3 - + @@ -806,7 +806,7 @@ _col2 - + @@ -851,7 +851,7 @@ _col1 - + @@ -896,7 +896,7 @@ _col9 - + @@ -941,7 +941,7 @@ _col13 - + @@ -993,7 +993,7 @@ _col12 - + @@ -1038,7 +1038,7 @@ _col11 - + @@ -1083,7 +1083,7 @@ _col10 - + @@ -1128,7 +1128,7 @@ _col16 - + @@ -1180,7 +1180,7 @@ _col15 - + @@ -1232,7 +1232,7 @@ _col14 - + @@ -1284,7 +1284,7 @@ _col0 - + @@ -1334,55 +1334,174 @@ - + + + + + + true + + - + + + + + + false + + - + + + + + + true + + - + + + + + + true + + - + + + + + + true + + - + + + + + + false + + - + + + + + + false + + - + + + + + + false + + - + + + + + + true + + - + + + + + + true + + - + + + + + + false + + - + + + + + + true + + - + + + + + + true + + - + + + + + + acc + + - + + + + + + abc + + - + + + + + + abb + + - + + + + + + hive + + @@ -1756,7 +1875,7 @@ - + int @@ -1800,7 +1919,7 @@ src - + string diff --git ql/src/test/results/compiler/plan/udf4.q.xml ql/src/test/results/compiler/plan/udf4.q.xml index 61434ea..c57a3d8 100644 --- ql/src/test/results/compiler/plan/udf4.q.xml +++ ql/src/test/results/compiler/plan/udf4.q.xml @@ -549,7 +549,7 @@ _col8 - + @@ -581,7 +581,7 @@ _col7 - + @@ -627,7 +627,7 @@ _col6 - + @@ -659,7 +659,7 @@ _col5 - + @@ -698,7 +698,7 @@ _col4 - + @@ -723,7 +723,7 @@ _col3 - + @@ -748,7 +748,7 @@ _col2 - + @@ -787,7 +787,7 @@ _col1 - + @@ -812,7 +812,7 @@ _col9 - + @@ -837,7 +837,7 @@ _col13 - + @@ -869,7 +869,7 @@ _col12 - + @@ -894,7 +894,7 @@ _col11 - + @@ -933,7 +933,7 @@ _col10 - + @@ -958,7 +958,7 @@ _col17 - + @@ -1011,7 +1011,7 @@ _col16 - + @@ -1050,7 +1050,7 @@ _col15 - + @@ -1086,7 +1086,7 @@ _col0 - + @@ -1111,7 +1111,7 @@ _col18 - + @@ -1151,61 +1151,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 c04aaba..6e97894 100644 --- ql/src/test/results/compiler/plan/udf6.q.xml +++ ql/src/test/results/compiler/plan/udf6.q.xml @@ -293,7 +293,7 @@ _col1 - + @@ -342,7 +342,7 @@ _col0 - + @@ -382,10 +382,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 40fe450..de3144d 100644 --- ql/src/test/results/compiler/plan/udf_case.q.xml +++ ql/src/test/results/compiler/plan/udf_case.q.xml @@ -350,7 +350,7 @@ _col1 - + @@ -415,7 +415,7 @@ _col0 - + @@ -495,10 +495,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 6b73dbd..98ca0cf 100644 --- ql/src/test/results/compiler/plan/udf_when.q.xml +++ ql/src/test/results/compiler/plan/udf_when.q.xml @@ -350,7 +350,7 @@ _col1 - + @@ -457,7 +457,7 @@ _col0 - + @@ -575,10 +575,17 @@ - + + + + + + 2 + + - +